(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory(require("Rx"), require("rxjs/operator/toPromise"));
	else if(typeof define === 'function' && define.amd)
		define(["Rx", "rxjs/operator/toPromise"], factory);
	else if(typeof exports === 'object')
		exports["ng"] = factory(require("Rx"), require("rxjs/operator/toPromise"));
	else
		root["ng"] = factory(root["Rx"], root["Rx"]["Observable"]["prototype"]);
})(this, function(__WEBPACK_EXTERNAL_MODULE_43__, __WEBPACK_EXTERNAL_MODULE_60__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}


/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = __webpack_require__(1);


/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {

	exports.core = __webpack_require__(2);
	exports.common = __webpack_require__(89);
	exports.compiler = __webpack_require__(139);
	exports.platform = {
	  browser: __webpack_require__(203),
	  common_dom: __webpack_require__(226)
	};
	exports.http = __webpack_require__(234);
	exports.router = __webpack_require__(249);
	exports.router_link_dsl = __webpack_require__(280);
	exports.instrumentation = __webpack_require__(282);
	exports.upgrade = __webpack_require__(283);


/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	function __export(m) {
	    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
	}
	/**
	 * @module
	 * @description
	 * Starting point to import all public core APIs.
	 */
	__export(__webpack_require__(3));
	__export(__webpack_require__(38));
	__export(__webpack_require__(39));
	__export(__webpack_require__(6));
	__export(__webpack_require__(40));
	var lang_1 = __webpack_require__(5);
	exports.enableProdMode = lang_1.enableProdMode;
	var application_ref_1 = __webpack_require__(61);
	exports.createPlatform = application_ref_1.createPlatform;
	exports.assertPlatform = application_ref_1.assertPlatform;
	exports.disposePlatform = application_ref_1.disposePlatform;
	exports.getPlatform = application_ref_1.getPlatform;
	exports.coreBootstrap = application_ref_1.coreBootstrap;
	exports.coreLoadAndBootstrap = application_ref_1.coreLoadAndBootstrap;
	exports.createNgZone = application_ref_1.createNgZone;
	exports.PlatformRef = application_ref_1.PlatformRef;
	exports.ApplicationRef = application_ref_1.ApplicationRef;
	var application_tokens_1 = __webpack_require__(64);
	exports.APP_ID = application_tokens_1.APP_ID;
	exports.APP_INITIALIZER = application_tokens_1.APP_INITIALIZER;
	exports.PACKAGE_ROOT_URL = application_tokens_1.PACKAGE_ROOT_URL;
	exports.PLATFORM_INITIALIZER = application_tokens_1.PLATFORM_INITIALIZER;
	__export(__webpack_require__(78));
	__export(__webpack_require__(79));
	__export(__webpack_require__(80));
	var debug_node_1 = __webpack_require__(85);
	exports.DebugElement = debug_node_1.DebugElement;
	exports.DebugNode = debug_node_1.DebugNode;
	exports.asNativeElements = debug_node_1.asNativeElements;
	__export(__webpack_require__(65));
	__export(__webpack_require__(28));
	__export(__webpack_require__(86));
	__export(__webpack_require__(87));
	__export(__webpack_require__(88));
	__export(__webpack_require__(18));


/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * This indirection is needed to free up Component, etc symbols in the public API
	 * to be used by the decorator versions of these annotations.
	 */
	"use strict";
	var di_1 = __webpack_require__(4);
	exports.QueryMetadata = di_1.QueryMetadata;
	exports.ContentChildrenMetadata = di_1.ContentChildrenMetadata;
	exports.ContentChildMetadata = di_1.ContentChildMetadata;
	exports.ViewChildrenMetadata = di_1.ViewChildrenMetadata;
	exports.ViewQueryMetadata = di_1.ViewQueryMetadata;
	exports.ViewChildMetadata = di_1.ViewChildMetadata;
	exports.AttributeMetadata = di_1.AttributeMetadata;
	var directives_1 = __webpack_require__(27);
	exports.ComponentMetadata = directives_1.ComponentMetadata;
	exports.DirectiveMetadata = directives_1.DirectiveMetadata;
	exports.PipeMetadata = directives_1.PipeMetadata;
	exports.InputMetadata = directives_1.InputMetadata;
	exports.OutputMetadata = directives_1.OutputMetadata;
	exports.HostBindingMetadata = directives_1.HostBindingMetadata;
	exports.HostListenerMetadata = directives_1.HostListenerMetadata;
	var view_1 = __webpack_require__(37);
	exports.ViewMetadata = view_1.ViewMetadata;
	exports.ViewEncapsulation = view_1.ViewEncapsulation;
	var di_2 = __webpack_require__(4);
	var directives_2 = __webpack_require__(27);
	var view_2 = __webpack_require__(37);
	var decorators_1 = __webpack_require__(9);
	// TODO(alexeagle): remove the duplication of this doc. It is copied from ComponentMetadata.
	/**
	 * Declare reusable UI building blocks for an application.
	 *
	 * Each Angular component requires a single `@Component` annotation. The `@Component`
	 * annotation specifies when a component is instantiated, and which properties and hostListeners it
	 * binds to.
	 *
	 * When a component is instantiated, Angular
	 * - creates a shadow DOM for the component.
	 * - loads the selected template into the shadow DOM.
	 * - creates all the injectable objects configured with `providers` and `viewProviders`.
	 *
	 * All template expressions and statements are then evaluated against the component instance.
	 *
	 * ## Lifecycle hooks
	 *
	 * When the component class implements some {@link ../../guide/lifecycle-hooks.html} the callbacks
	 * are called by the change detection at defined points in time during the life of the component.
	 *
	 * ### Example
	 *
	 * {@example core/ts/metadata/metadata.ts region='component'}
	 */
	exports.Component = decorators_1.makeDecorator(directives_2.ComponentMetadata, function (fn) { return fn.View = View; });
	// TODO(alexeagle): remove the duplication of this doc. It is copied from DirectiveMetadata.
	/**
	 * Directives allow you to attach behavior to elements in the DOM.
	 *
	 * {@link DirectiveMetadata}s with an embedded view are called {@link ComponentMetadata}s.
	 *
	 * A directive consists of a single directive annotation and a controller class. When the
	 * directive's `selector` matches
	 * elements in the DOM, the following steps occur:
	 *
	 * 1. For each directive, the `ElementInjector` attempts to resolve the directive's constructor
	 * arguments.
	 * 2. Angular instantiates directives for each matched element using `ElementInjector` in a
	 * depth-first order,
	 *    as declared in the HTML.
	 *
	 * ## Understanding How Injection Works
	 *
	 * There are three stages of injection resolution.
	 * - *Pre-existing Injectors*:
	 *   - The terminal {@link Injector} cannot resolve dependencies. It either throws an error or, if
	 * the dependency was
	 *     specified as `@Optional`, returns `null`.
	 *   - The platform injector resolves browser singleton resources, such as: cookies, title,
	 * location, and others.
	 * - *Component Injectors*: Each component instance has its own {@link Injector}, and they follow
	 * the same parent-child hierarchy
	 *     as the component instances in the DOM.
	 * - *Element Injectors*: Each component instance has a Shadow DOM. Within the Shadow DOM each
	 * element has an `ElementInjector`
	 *     which follow the same parent-child hierarchy as the DOM elements themselves.
	 *
	 * When a template is instantiated, it also must instantiate the corresponding directives in a
	 * depth-first order. The
	 * current `ElementInjector` resolves the constructor dependencies for each directive.
	 *
	 * Angular then resolves dependencies as follows, according to the order in which they appear in the
	 * {@link ViewMetadata}:
	 *
	 * 1. Dependencies on the current element
	 * 2. Dependencies on element injectors and their parents until it encounters a Shadow DOM boundary
	 * 3. Dependencies on component injectors and their parents until it encounters the root component
	 * 4. Dependencies on pre-existing injectors
	 *
	 *
	 * The `ElementInjector` can inject other directives, element-specific special objects, or it can
	 * delegate to the parent
	 * injector.
	 *
	 * To inject other directives, declare the constructor parameter as:
	 * - `directive:DirectiveType`: a directive on the current element only
	 * - `@Host() directive:DirectiveType`: any directive that matches the type between the current
	 * element and the
	 *    Shadow DOM root.
	 * - `@Query(DirectiveType) query:QueryList<DirectiveType>`: A live collection of direct child
	 * directives.
	 * - `@QueryDescendants(DirectiveType) query:QueryList<DirectiveType>`: A live collection of any
	 * child directives.
	 *
	 * To inject element-specific special objects, declare the constructor parameter as:
	 * - `element: ElementRef` to obtain a reference to logical element in the view.
	 * - `viewContainer: ViewContainerRef` to control child template instantiation, for
	 * {@link DirectiveMetadata} directives only
	 * - `bindingPropagation: BindingPropagation` to control change detection in a more granular way.
	 *
	 * ### Example
	 *
	 * The following example demonstrates how dependency injection resolves constructor arguments in
	 * practice.
	 *
	 *
	 * Assume this HTML template:
	 *
	 * ```
	 * <div dependency="1">
	 *   <div dependency="2">
	 *     <div dependency="3" my-directive>
	 *       <div dependency="4">
	 *         <div dependency="5"></div>
	 *       </div>
	 *       <div dependency="6"></div>
	 *     </div>
	 *   </div>
	 * </div>
	 * ```
	 *
	 * With the following `dependency` decorator and `SomeService` injectable class.
	 *
	 * ```
	 * @Injectable()
	 * class SomeService {
	 * }
	 *
	 * @Directive({
	 *   selector: '[dependency]',
	 *   inputs: [
	 *     'id: dependency'
	 *   ]
	 * })
	 * class Dependency {
	 *   id:string;
	 * }
	 * ```
	 *
	 * Let's step through the different ways in which `MyDirective` could be declared...
	 *
	 *
	 * ### No injection
	 *
	 * Here the constructor is declared with no arguments, therefore nothing is injected into
	 * `MyDirective`.
	 *
	 * ```
	 * @Directive({ selector: '[my-directive]' })
	 * class MyDirective {
	 *   constructor() {
	 *   }
	 * }
	 * ```
	 *
	 * This directive would be instantiated with no dependencies.
	 *
	 *
	 * ### Component-level injection
	 *
	 * Directives can inject any injectable instance from the closest component injector or any of its
	 * parents.
	 *
	 * Here, the constructor declares a parameter, `someService`, and injects the `SomeService` type
	 * from the parent
	 * component's injector.
	 * ```
	 * @Directive({ selector: '[my-directive]' })
	 * class MyDirective {
	 *   constructor(someService: SomeService) {
	 *   }
	 * }
	 * ```
	 *
	 * This directive would be instantiated with a dependency on `SomeService`.
	 *
	 *
	 * ### Injecting a directive from the current element
	 *
	 * Directives can inject other directives declared on the current element.
	 *
	 * ```
	 * @Directive({ selector: '[my-directive]' })
	 * class MyDirective {
	 *   constructor(dependency: Dependency) {
	 *     expect(dependency.id).toEqual(3);
	 *   }
	 * }
	 * ```
	 * This directive would be instantiated with `Dependency` declared at the same element, in this case
	 * `dependency="3"`.
	 *
	 * ### Injecting a directive from any ancestor elements
	 *
	 * Directives can inject other directives declared on any ancestor element (in the current Shadow
	 * DOM), i.e. on the current element, the
	 * parent element, or its parents.
	 * ```
	 * @Directive({ selector: '[my-directive]' })
	 * class MyDirective {
	 *   constructor(@Host() dependency: Dependency) {
	 *     expect(dependency.id).toEqual(2);
	 *   }
	 * }
	 * ```
	 *
	 * `@Host` checks the current element, the parent, as well as its parents recursively. If
	 * `dependency="2"` didn't
	 * exist on the direct parent, this injection would
	 * have returned
	 * `dependency="1"`.
	 *
	 *
	 * ### Injecting a live collection of direct child directives
	 *
	 *
	 * A directive can also query for other child directives. Since parent directives are instantiated
	 * before child directives, a directive can't simply inject the list of child directives. Instead,
	 * the directive injects a {@link QueryList}, which updates its contents as children are added,
	 * removed, or moved by a directive that uses a {@link ViewContainerRef} such as a `ngFor`, an
	 * `ngIf`, or an `ngSwitch`.
	 *
	 * ```
	 * @Directive({ selector: '[my-directive]' })
	 * class MyDirective {
	 *   constructor(@Query(Dependency) dependencies:QueryList<Dependency>) {
	 *   }
	 * }
	 * ```
	 *
	 * This directive would be instantiated with a {@link QueryList} which contains `Dependency` 4 and
	 * 6. Here, `Dependency` 5 would not be included, because it is not a direct child.
	 *
	 * ### Injecting a live collection of descendant directives
	 *
	 * By passing the descendant flag to `@Query` above, we can include the children of the child
	 * elements.
	 *
	 * ```
	 * @Directive({ selector: '[my-directive]' })
	 * class MyDirective {
	 *   constructor(@Query(Dependency, {descendants: true}) dependencies:QueryList<Dependency>) {
	 *   }
	 * }
	 * ```
	 *
	 * This directive would be instantiated with a Query which would contain `Dependency` 4, 5 and 6.
	 *
	 * ### Optional injection
	 *
	 * The normal behavior of directives is to return an error when a specified dependency cannot be
	 * resolved. If you
	 * would like to inject `null` on unresolved dependency instead, you can annotate that dependency
	 * with `@Optional()`.
	 * This explicitly permits the author of a template to treat some of the surrounding directives as
	 * optional.
	 *
	 * ```
	 * @Directive({ selector: '[my-directive]' })
	 * class MyDirective {
	 *   constructor(@Optional() dependency:Dependency) {
	 *   }
	 * }
	 * ```
	 *
	 * This directive would be instantiated with a `Dependency` directive found on the current element.
	 * If none can be
	 * found, the injector supplies `null` instead of throwing an error.
	 *
	 * ### Example
	 *
	 * Here we use a decorator directive to simply define basic tool-tip behavior.
	 *
	 * ```
	 * @Directive({
	 *   selector: '[tooltip]',
	 *   inputs: [
	 *     'text: tooltip'
	 *   ],
	 *   host: {
	 *     '(mouseenter)': 'onMouseEnter()',
	 *     '(mouseleave)': 'onMouseLeave()'
	 *   }
	 * })
	 * class Tooltip{
	 *   text:string;
	 *   overlay:Overlay; // NOT YET IMPLEMENTED
	 *   overlayManager:OverlayManager; // NOT YET IMPLEMENTED
	 *
	 *   constructor(overlayManager:OverlayManager) {
	 *     this.overlay = overlay;
	 *   }
	 *
	 *   onMouseEnter() {
	 *     // exact signature to be determined
	 *     this.overlay = this.overlayManager.open(text, ...);
	 *   }
	 *
	 *   onMouseLeave() {
	 *     this.overlay.close();
	 *     this.overlay = null;
	 *   }
	 * }
	 * ```
	 * In our HTML template, we can then add this behavior to a `<div>` or any other element with the
	 * `tooltip` selector,
	 * like so:
	 *
	 * ```
	 * <div tooltip="some text here"></div>
	 * ```
	 *
	 * Directives can also control the instantiation, destruction, and positioning of inline template
	 * elements:
	 *
	 * A directive uses a {@link ViewContainerRef} to instantiate, insert, move, and destroy views at
	 * runtime.
	 * The {@link ViewContainerRef} is created as a result of `<template>` element, and represents a
	 * location in the current view
	 * where these actions are performed.
	 *
	 * Views are always created as children of the current {@link ViewMetadata}, and as siblings of the
	 * `<template>` element. Thus a
	 * directive in a child view cannot inject the directive that created it.
	 *
	 * Since directives that create views via ViewContainers are common in Angular, and using the full
	 * `<template>` element syntax is wordy, Angular
	 * also supports a shorthand notation: `<li *foo="bar">` and `<li template="foo: bar">` are
	 * equivalent.
	 *
	 * Thus,
	 *
	 * ```
	 * <ul>
	 *   <li *foo="bar" title="text"></li>
	 * </ul>
	 * ```
	 *
	 * Expands in use to:
	 *
	 * ```
	 * <ul>
	 *   <template [foo]="bar">
	 *     <li title="text"></li>
	 *   </template>
	 * </ul>
	 * ```
	 *
	 * Notice that although the shorthand places `*foo="bar"` within the `<li>` element, the binding for
	 * the directive
	 * controller is correctly instantiated on the `<template>` element rather than the `<li>` element.
	 *
	 * ## Lifecycle hooks
	 *
	 * When the directive class implements some {@link ../../guide/lifecycle-hooks.html} the callbacks
	 * are called by the change detection at defined points in time during the life of the directive.
	 *
	 * ### Example
	 *
	 * Let's suppose we want to implement the `unless` behavior, to conditionally include a template.
	 *
	 * Here is a simple directive that triggers on an `unless` selector:
	 *
	 * ```
	 * @Directive({
	 *   selector: '[unless]',
	 *   inputs: ['unless']
	 * })
	 * export class Unless {
	 *   viewContainer: ViewContainerRef;
	 *   templateRef: TemplateRef;
	 *   prevCondition: boolean;
	 *
	 *   constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef) {
	 *     this.viewContainer = viewContainer;
	 *     this.templateRef = templateRef;
	 *     this.prevCondition = null;
	 *   }
	 *
	 *   set unless(newCondition) {
	 *     if (newCondition && (isBlank(this.prevCondition) || !this.prevCondition)) {
	 *       this.prevCondition = true;
	 *       this.viewContainer.clear();
	 *     } else if (!newCondition && (isBlank(this.prevCondition) || this.prevCondition)) {
	 *       this.prevCondition = false;
	 *       this.viewContainer.create(this.templateRef);
	 *     }
	 *   }
	 * }
	 * ```
	 *
	 * We can then use this `unless` selector in a template:
	 * ```
	 * <ul>
	 *   <li *unless="expr"></li>
	 * </ul>
	 * ```
	 *
	 * Once the directive instantiates the child view, the shorthand notation for the template expands
	 * and the result is:
	 *
	 * ```
	 * <ul>
	 *   <template [unless]="exp">
	 *     <li></li>
	 *   </template>
	 *   <li></li>
	 * </ul>
	 * ```
	 *
	 * Note also that although the `<li></li>` template still exists inside the `<template></template>`,
	 * the instantiated
	 * view occurs on the second `<li></li>` which is a sibling to the `<template>` element.
	 */
	exports.Directive = decorators_1.makeDecorator(directives_2.DirectiveMetadata);
	// TODO(alexeagle): remove the duplication of this doc. It is copied from ViewMetadata.
	/**
	 * Metadata properties available for configuring Views.
	 *
	 * Each Angular component requires a single `@Component` and at least one `@View` annotation. The
	 * `@View` annotation specifies the HTML template to use, and lists the directives that are active
	 * within the template.
	 *
	 * When a component is instantiated, the template is loaded into the component's shadow root, and
	 * the expressions and statements in the template are evaluated against the component.
	 *
	 * For details on the `@Component` annotation, see {@link ComponentMetadata}.
	 *
	 * ### Example
	 *
	 * ```
	 * @Component({
	 *   selector: 'greet',
	 *   template: 'Hello {{name}}!',
	 *   directives: [GreetUser, Bold]
	 * })
	 * class Greet {
	 *   name: string;
	 *
	 *   constructor() {
	 *     this.name = 'World';
	 *   }
	 * }
	 * ```
	 */
	var View = decorators_1.makeDecorator(view_2.ViewMetadata, function (fn) { return fn.View = View; });
	/**
	 * Specifies that a constant attribute value should be injected.
	 *
	 * The directive can inject constant string literals of host element attributes.
	 *
	 * ### Example
	 *
	 * Suppose we have an `<input>` element and want to know its `type`.
	 *
	 * ```html
	 * <input type="text">
	 * ```
	 *
	 * A decorator can inject string literal `text` like so:
	 *
	 * {@example core/ts/metadata/metadata.ts region='attributeMetadata'}
	 */
	exports.Attribute = decorators_1.makeParamDecorator(di_2.AttributeMetadata);
	// TODO(alexeagle): remove the duplication of this doc. It is copied from QueryMetadata.
	/**
	 * Declares an injectable parameter to be a live list of directives or variable
	 * bindings from the content children of a directive.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/lY9m8HLy7z06vDoUaSN2?p=preview))
	 *
	 * Assume that `<tabs>` component would like to get a list its children `<pane>`
	 * components as shown in this example:
	 *
	 * ```html
	 * <tabs>
	 *   <pane title="Overview">...</pane>
	 *   <pane *ngFor="let o of objects" [title]="o.title">{{o.text}}</pane>
	 * </tabs>
	 * ```
	 *
	 * The preferred solution is to query for `Pane` directives using this decorator.
	 *
	 * ```javascript
	 * @Component({
	 *   selector: 'pane',
	 *   inputs: ['title']
	 * })
	 * class Pane {
	 *   title:string;
	 * }
	 *
	 * @Component({
	 *  selector: 'tabs',
	 *  template: `
	 *    <ul>
	 *      <li *ngFor="let pane of panes">{{pane.title}}</li>
	 *    </ul>
	 *    <ng-content></ng-content>
	 *  `
	 * })
	 * class Tabs {
	 *   panes: QueryList<Pane>;
	 *   constructor(@Query(Pane) panes:QueryList<Pane>) {
	 *     this.panes = panes;
	 *   }
	 * }
	 * ```
	 *
	 * A query can look for variable bindings by passing in a string with desired binding symbol.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/sT2j25cH1dURAyBRCKx1?p=preview))
	 * ```html
	 * <seeker>
	 *   <div #findme>...</div>
	 * </seeker>
	 *
	 * @Component({ selector: 'seeker' })
	 * class seeker {
	 *   constructor(@Query('findme') elList: QueryList<ElementRef>) {...}
	 * }
	 * ```
	 *
	 * In this case the object that is injected depend on the type of the variable
	 * binding. It can be an ElementRef, a directive or a component.
	 *
	 * Passing in a comma separated list of variable bindings will query for all of them.
	 *
	 * ```html
	 * <seeker>
	 *   <div #findMe>...</div>
	 *   <div #findMeToo>...</div>
	 * </seeker>
	 *
	 *  @Component({
	 *   selector: 'seeker'
	 * })
	 * class Seeker {
	 *   constructor(@Query('findMe, findMeToo') elList: QueryList<ElementRef>) {...}
	 * }
	 * ```
	 *
	 * Configure whether query looks for direct children or all descendants
	 * of the querying element, by using the `descendants` parameter.
	 * It is set to `false` by default.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/wtGeB977bv7qvA5FTYl9?p=preview))
	 * ```html
	 * <container #first>
	 *   <item>a</item>
	 *   <item>b</item>
	 *   <container #second>
	 *     <item>c</item>
	 *   </container>
	 * </container>
	 * ```
	 *
	 * When querying for items, the first container will see only `a` and `b` by default,
	 * but with `Query(TextDirective, {descendants: true})` it will see `c` too.
	 *
	 * The queried directives are kept in a depth-first pre-order with respect to their
	 * positions in the DOM.
	 *
	 * Query does not look deep into any subcomponent views.
	 *
	 * Query is updated as part of the change-detection cycle. Since change detection
	 * happens after construction of a directive, QueryList will always be empty when observed in the
	 * constructor.
	 *
	 * The injected object is an unmodifiable live list.
	 * See {@link QueryList} for more details.
	 */
	exports.Query = decorators_1.makeParamDecorator(di_2.QueryMetadata);
	// TODO(alexeagle): remove the duplication of this doc. It is copied from ContentChildrenMetadata.
	/**
	 * Configures a content query.
	 *
	 * Content queries are set before the `ngAfterContentInit` callback is called.
	 *
	 * ### Example
	 *
	 * ```
	 * @Directive({
	 *   selector: 'someDir'
	 * })
	 * class SomeDir {
	 *   @ContentChildren(ChildDirective) contentChildren: QueryList<ChildDirective>;
	 *
	 *   ngAfterContentInit() {
	 *     // contentChildren is set
	 *   }
	 * }
	 * ```
	 */
	exports.ContentChildren = decorators_1.makePropDecorator(di_2.ContentChildrenMetadata);
	// TODO(alexeagle): remove the duplication of this doc. It is copied from ContentChildMetadata.
	/**
	 * Configures a content query.
	 *
	 * Content queries are set before the `ngAfterContentInit` callback is called.
	 *
	 * ### Example
	 *
	 * ```
	 * @Directive({
	 *   selector: 'someDir'
	 * })
	 * class SomeDir {
	 *   @ContentChild(ChildDirective) contentChild;
	 *
	 *   ngAfterContentInit() {
	 *     // contentChild is set
	 *   }
	 * }
	 * ```
	 */
	exports.ContentChild = decorators_1.makePropDecorator(di_2.ContentChildMetadata);
	// TODO(alexeagle): remove the duplication of this doc. It is copied from ViewChildrenMetadata.
	/**
	 * Declares a list of child element references.
	 *
	 * Angular automatically updates the list when the DOM is updated.
	 *
	 * `ViewChildren` takes a argument to select elements.
	 *
	 * - If the argument is a type, directives or components with the type will be bound.
	 *
	 * - If the argument is a string, the string is interpreted as a list of comma-separated selectors.
	 * For each selector, an element containing the matching template variable (e.g. `#child`) will be
	 * bound.
	 *
	 * View children are set before the `ngAfterViewInit` callback is called.
	 *
	 * ### Example
	 *
	 * With type selector:
	 *
	 * ```
	 * @Component({
	 *   selector: 'child-cmp',
	 *   template: '<p>child</p>'
	 * })
	 * class ChildCmp {
	 *   doSomething() {}
	 * }
	 *
	 * @Component({
	 *   selector: 'some-cmp',
	 *   template: `
	 *     <child-cmp></child-cmp>
	 *     <child-cmp></child-cmp>
	 *     <child-cmp></child-cmp>
	 *   `,
	 *   directives: [ChildCmp]
	 * })
	 * class SomeCmp {
	 *   @ViewChildren(ChildCmp) children:QueryList<ChildCmp>;
	 *
	 *   ngAfterViewInit() {
	 *     // children are set
	 *     this.children.toArray().forEach((child)=>child.doSomething());
	 *   }
	 * }
	 * ```
	 *
	 * With string selector:
	 *
	 * ```
	 * @Component({
	 *   selector: 'child-cmp',
	 *   template: '<p>child</p>'
	 * })
	 * class ChildCmp {
	 *   doSomething() {}
	 * }
	 *
	 * @Component({
	 *   selector: 'some-cmp',
	 *   template: `
	 *     <child-cmp #child1></child-cmp>
	 *     <child-cmp #child2></child-cmp>
	 *     <child-cmp #child3></child-cmp>
	 *   `,
	 *   directives: [ChildCmp]
	 * })
	 * class SomeCmp {
	 *   @ViewChildren('child1,child2,child3') children:QueryList<ChildCmp>;
	 *
	 *   ngAfterViewInit() {
	 *     // children are set
	 *     this.children.toArray().forEach((child)=>child.doSomething());
	 *   }
	 * }
	 * ```
	 *
	 * See also: [ViewChildrenMetadata]
	 */
	exports.ViewChildren = decorators_1.makePropDecorator(di_2.ViewChildrenMetadata);
	// TODO(alexeagle): remove the duplication of this doc. It is copied from ViewChildMetadata.
	/**
	 * Declares a reference to a child element.
	 *
	 * `ViewChildren` takes a argument to select elements.
	 *
	 * - If the argument is a type, a directive or a component with the type will be bound.
	 *
	 * - If the argument is a string, the string is interpreted as a selector. An element containing the
	 * matching template variable (e.g. `#child`) will be bound.
	 *
	 * In either case, `@ViewChild()` assigns the first (looking from above) element if there are
	 * multiple matches.
	 *
	 * View child is set before the `ngAfterViewInit` callback is called.
	 *
	 * ### Example
	 *
	 * With type selector:
	 *
	 * ```
	 * @Component({
	 *   selector: 'child-cmp',
	 *   template: '<p>child</p>'
	 * })
	 * class ChildCmp {
	 *   doSomething() {}
	 * }
	 *
	 * @Component({
	 *   selector: 'some-cmp',
	 *   template: '<child-cmp></child-cmp>',
	 *   directives: [ChildCmp]
	 * })
	 * class SomeCmp {
	 *   @ViewChild(ChildCmp) child:ChildCmp;
	 *
	 *   ngAfterViewInit() {
	 *     // child is set
	 *     this.child.doSomething();
	 *   }
	 * }
	 * ```
	 *
	 * With string selector:
	 *
	 * ```
	 * @Component({
	 *   selector: 'child-cmp',
	 *   template: '<p>child</p>'
	 * })
	 * class ChildCmp {
	 *   doSomething() {}
	 * }
	 *
	 * @Component({
	 *   selector: 'some-cmp',
	 *   template: '<child-cmp #child></child-cmp>',
	 *   directives: [ChildCmp]
	 * })
	 * class SomeCmp {
	 *   @ViewChild('child') child:ChildCmp;
	 *
	 *   ngAfterViewInit() {
	 *     // child is set
	 *     this.child.doSomething();
	 *   }
	 * }
	 * ```
	 * See also: [ViewChildMetadata]
	 */
	exports.ViewChild = decorators_1.makePropDecorator(di_2.ViewChildMetadata);
	// TODO(alexeagle): remove the duplication of this doc. It is copied from ViewQueryMetadata.
	/**
	 * Similar to {@link QueryMetadata}, but querying the component view, instead of
	 * the content children.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/eNsFHDf7YjyM6IzKxM1j?p=preview))
	 *
	 * ```javascript
	 * @Component({
	 *   ...,
	 *   template: `
	 *     <item> a </item>
	 *     <item> b </item>
	 *     <item> c </item>
	 *   `
	 * })
	 * class MyComponent {
	 *   shown: boolean;
	 *
	 *   constructor(private @Query(Item) items:QueryList<Item>) {
	 *     items.changes.subscribe(() => console.log(items.length));
	 *   }
	 * }
	 * ```
	 *
	 * Supports the same querying parameters as {@link QueryMetadata}, except
	 * `descendants`. This always queries the whole view.
	 *
	 * As `shown` is flipped between true and false, items will contain zero of one
	 * items.
	 *
	 * Specifies that a {@link QueryList} should be injected.
	 *
	 * The injected object is an iterable and observable live list.
	 * See {@link QueryList} for more details.
	 */
	exports.ViewQuery = decorators_1.makeParamDecorator(di_2.ViewQueryMetadata);
	// TODO(alexeagle): remove the duplication of this doc. It is copied from PipeMetadata.
	/**
	 * Declare reusable pipe function.
	 *
	 * ### Example
	 *
	 * {@example core/ts/metadata/metadata.ts region='pipe'}
	 */
	exports.Pipe = decorators_1.makeDecorator(directives_2.PipeMetadata);
	// TODO(alexeagle): remove the duplication of this doc. It is copied from InputMetadata.
	/**
	 * Declares a data-bound input property.
	 *
	 * Angular automatically updates data-bound properties during change detection.
	 *
	 * `InputMetadata` takes an optional parameter that specifies the name
	 * used when instantiating a component in the template. When not provided,
	 * the name of the decorated property is used.
	 *
	 * ### Example
	 *
	 * The following example creates a component with two input properties.
	 *
	 * ```typescript
	 * @Component({
	 *   selector: 'bank-account',
	 *   template: `
	 *     Bank Name: {{bankName}}
	 *     Account Id: {{id}}
	 *   `
	 * })
	 * class BankAccount {
	 *   @Input() bankName: string;
	 *   @Input('account-id') id: string;
	 *
	 *   // this property is not bound, and won't be automatically updated by Angular
	 *   normalizedBankName: string;
	 * }
	 *
	 * @Component({
	 *   selector: 'app',
	 *   template: `
	 *     <bank-account bank-name="RBC" account-id="4747"></bank-account>
	 *   `,
	 *   directives: [BankAccount]
	 * })
	 * class App {}
	 *
	 * bootstrap(App);
	 * ```
	 */
	exports.Input = decorators_1.makePropDecorator(directives_2.InputMetadata);
	// TODO(alexeagle): remove the duplication of this doc. It is copied from OutputMetadata.
	/**
	 * Declares an event-bound output property.
	 *
	 * When an output property emits an event, an event handler attached to that event
	 * the template is invoked.
	 *
	 * `OutputMetadata` takes an optional parameter that specifies the name
	 * used when instantiating a component in the template. When not provided,
	 * the name of the decorated property is used.
	 *
	 * ### Example
	 *
	 * ```typescript
	 * @Directive({
	 *   selector: 'interval-dir',
	 * })
	 * class IntervalDir {
	 *   @Output() everySecond = new EventEmitter();
	 *   @Output('everyFiveSeconds') five5Secs = new EventEmitter();
	 *
	 *   constructor() {
	 *     setInterval(() => this.everySecond.emit("event"), 1000);
	 *     setInterval(() => this.five5Secs.emit("event"), 5000);
	 *   }
	 * }
	 *
	 * @Component({
	 *   selector: 'app',
	 *   template: `
	 *     <interval-dir (everySecond)="everySecond()" (everyFiveSeconds)="everyFiveSeconds()">
	 *     </interval-dir>
	 *   `,
	 *   directives: [IntervalDir]
	 * })
	 * class App {
	 *   everySecond() { console.log('second'); }
	 *   everyFiveSeconds() { console.log('five seconds'); }
	 * }
	 * bootstrap(App);
	 * ```
	 */
	exports.Output = decorators_1.makePropDecorator(directives_2.OutputMetadata);
	// TODO(alexeagle): remove the duplication of this doc. It is copied from HostBindingMetadata.
	/**
	 * Declares a host property binding.
	 *
	 * Angular automatically checks host property bindings during change detection.
	 * If a binding changes, it will update the host element of the directive.
	 *
	 * `HostBindingMetadata` takes an optional parameter that specifies the property
	 * name of the host element that will be updated. When not provided,
	 * the class property name is used.
	 *
	 * ### Example
	 *
	 * The following example creates a directive that sets the `valid` and `invalid` classes
	 * on the DOM element that has ngModel directive on it.
	 *
	 * ```typescript
	 * @Directive({selector: '[ngModel]'})
	 * class NgModelStatus {
	 *   constructor(public control:NgModel) {}
	 *   @HostBinding('[class.valid]') get valid { return this.control.valid; }
	 *   @HostBinding('[class.invalid]') get invalid { return this.control.invalid; }
	 * }
	 *
	 * @Component({
	 *   selector: 'app',
	 *   template: `<input [(ngModel)]="prop">`,
	 *   directives: [FORM_DIRECTIVES, NgModelStatus]
	 * })
	 * class App {
	 *   prop;
	 * }
	 *
	 * bootstrap(App);
	 * ```
	 */
	exports.HostBinding = decorators_1.makePropDecorator(directives_2.HostBindingMetadata);
	// TODO(alexeagle): remove the duplication of this doc. It is copied from HostListenerMetadata.
	/**
	 * Declares a host listener.
	 *
	 * Angular will invoke the decorated method when the host element emits the specified event.
	 *
	 * If the decorated method returns `false`, then `preventDefault` is applied on the DOM
	 * event.
	 *
	 * ### Example
	 *
	 * The following example declares a directive that attaches a click listener to the button and
	 * counts clicks.
	 *
	 * ```typescript
	 * @Directive({selector: 'button[counting]'})
	 * class CountClicks {
	 *   numberOfClicks = 0;
	 *
	 *   @HostListener('click', ['$event.target'])
	 *   onClick(btn) {
	 *     console.log("button", btn, "number of clicks:", this.numberOfClicks++);
	 *   }
	 * }
	 *
	 * @Component({
	 *   selector: 'app',
	 *   template: `<button counting>Increment</button>`,
	 *   directives: [CountClicks]
	 * })
	 * class App {}
	 *
	 * bootstrap(App);
	 * ```
	 */
	exports.HostListener = decorators_1.makePropDecorator(directives_2.HostListenerMetadata);


/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var di_1 = __webpack_require__(6);
	var metadata_1 = __webpack_require__(7);
	/**
	 * Specifies that a constant attribute value should be injected.
	 *
	 * The directive can inject constant string literals of host element attributes.
	 *
	 * ### Example
	 *
	 * Suppose we have an `<input>` element and want to know its `type`.
	 *
	 * ```html
	 * <input type="text">
	 * ```
	 *
	 * A decorator can inject string literal `text` like so:
	 *
	 * {@example core/ts/metadata/metadata.ts region='attributeMetadata'}
	 * @ts2dart_const
	 */
	var AttributeMetadata = (function (_super) {
	    __extends(AttributeMetadata, _super);
	    function AttributeMetadata(attributeName) {
	        _super.call(this);
	        this.attributeName = attributeName;
	    }
	    Object.defineProperty(AttributeMetadata.prototype, "token", {
	        get: function () {
	            // Normally one would default a token to a type of an injected value but here
	            // the type of a variable is "string" and we can't use primitive type as a return value
	            // so we use instance of Attribute instead. This doesn't matter much in practice as arguments
	            // with @Attribute annotation are injected by ElementInjector that doesn't take tokens into
	            // account.
	            return this;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    AttributeMetadata.prototype.toString = function () { return "@Attribute(" + lang_1.stringify(this.attributeName) + ")"; };
	    return AttributeMetadata;
	}(metadata_1.DependencyMetadata));
	exports.AttributeMetadata = AttributeMetadata;
	/**
	 * Declares an injectable parameter to be a live list of directives or variable
	 * bindings from the content children of a directive.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/lY9m8HLy7z06vDoUaSN2?p=preview))
	 *
	 * Assume that `<tabs>` component would like to get a list its children `<pane>`
	 * components as shown in this example:
	 *
	 * ```html
	 * <tabs>
	 *   <pane title="Overview">...</pane>
	 *   <pane *ngFor="let o of objects" [title]="o.title">{{o.text}}</pane>
	 * </tabs>
	 * ```
	 *
	 * The preferred solution is to query for `Pane` directives using this decorator.
	 *
	 * ```javascript
	 * @Component({
	 *   selector: 'pane',
	 *   inputs: ['title']
	 * })
	 * class Pane {
	 *   title:string;
	 * }
	 *
	 * @Component({
	 *  selector: 'tabs',
	 *  template: `
	 *    <ul>
	 *      <li *ngFor="let pane of panes">{{pane.title}}</li>
	 *    </ul>
	 *    <ng-content></ng-content>
	 *  `
	 * })
	 * class Tabs {
	 *   panes: QueryList<Pane>;
	 *   constructor(@Query(Pane) panes:QueryList<Pane>) {
	  *    this.panes = panes;
	  *  }
	 * }
	 * ```
	 *
	 * A query can look for variable bindings by passing in a string with desired binding symbol.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/sT2j25cH1dURAyBRCKx1?p=preview))
	 * ```html
	 * <seeker>
	 *   <div #findme>...</div>
	 * </seeker>
	 *
	 * @Component({ selector: 'seeker' })
	 * class Seeker {
	 *   constructor(@Query('findme') elList: QueryList<ElementRef>) {...}
	 * }
	 * ```
	 *
	 * In this case the object that is injected depend on the type of the variable
	 * binding. It can be an ElementRef, a directive or a component.
	 *
	 * Passing in a comma separated list of variable bindings will query for all of them.
	 *
	 * ```html
	 * <seeker>
	 *   <div #find-me>...</div>
	 *   <div #find-me-too>...</div>
	 * </seeker>
	 *
	 *  @Component({
	 *   selector: 'seeker'
	 * })
	 * class Seeker {
	 *   constructor(@Query('findMe, findMeToo') elList: QueryList<ElementRef>) {...}
	 * }
	 * ```
	 *
	 * Configure whether query looks for direct children or all descendants
	 * of the querying element, by using the `descendants` parameter.
	 * It is set to `false` by default.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/wtGeB977bv7qvA5FTYl9?p=preview))
	 * ```html
	 * <container #first>
	 *   <item>a</item>
	 *   <item>b</item>
	 *   <container #second>
	 *     <item>c</item>
	 *   </container>
	 * </container>
	 * ```
	 *
	 * When querying for items, the first container will see only `a` and `b` by default,
	 * but with `Query(TextDirective, {descendants: true})` it will see `c` too.
	 *
	 * The queried directives are kept in a depth-first pre-order with respect to their
	 * positions in the DOM.
	 *
	 * Query does not look deep into any subcomponent views.
	 *
	 * Query is updated as part of the change-detection cycle. Since change detection
	 * happens after construction of a directive, QueryList will always be empty when observed in the
	 * constructor.
	 *
	 * The injected object is an unmodifiable live list.
	 * See {@link QueryList} for more details.
	 * @ts2dart_const
	 */
	var QueryMetadata = (function (_super) {
	    __extends(QueryMetadata, _super);
	    function QueryMetadata(_selector, _a) {
	        var _b = _a === void 0 ? {} : _a, _c = _b.descendants, descendants = _c === void 0 ? false : _c, _d = _b.first, first = _d === void 0 ? false : _d, _e = _b.read, read = _e === void 0 ? null : _e;
	        _super.call(this);
	        this._selector = _selector;
	        this.descendants = descendants;
	        this.first = first;
	        this.read = read;
	    }
	    Object.defineProperty(QueryMetadata.prototype, "isViewQuery", {
	        /**
	         * always `false` to differentiate it with {@link ViewQueryMetadata}.
	         */
	        get: function () { return false; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(QueryMetadata.prototype, "selector", {
	        /**
	         * what this is querying for.
	         */
	        get: function () { return di_1.resolveForwardRef(this._selector); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(QueryMetadata.prototype, "isVarBindingQuery", {
	        /**
	         * whether this is querying for a variable binding or a directive.
	         */
	        get: function () { return lang_1.isString(this.selector); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(QueryMetadata.prototype, "varBindings", {
	        /**
	         * returns a list of variable bindings this is querying for.
	         * Only applicable if this is a variable bindings query.
	         */
	        get: function () { return this.selector.split(','); },
	        enumerable: true,
	        configurable: true
	    });
	    QueryMetadata.prototype.toString = function () { return "@Query(" + lang_1.stringify(this.selector) + ")"; };
	    return QueryMetadata;
	}(metadata_1.DependencyMetadata));
	exports.QueryMetadata = QueryMetadata;
	// TODO: add an example after ContentChildren and ViewChildren are in master
	/**
	 * Configures a content query.
	 *
	 * Content queries are set before the `ngAfterContentInit` callback is called.
	 *
	 * ### Example
	 *
	 * ```
	 * @Directive({
	 *   selector: 'someDir'
	 * })
	 * class SomeDir {
	 *   @ContentChildren(ChildDirective) contentChildren: QueryList<ChildDirective>;
	 *
	 *   ngAfterContentInit() {
	 *     // contentChildren is set
	 *   }
	 * }
	 * ```
	 * @ts2dart_const
	 */
	var ContentChildrenMetadata = (function (_super) {
	    __extends(ContentChildrenMetadata, _super);
	    function ContentChildrenMetadata(_selector, _a) {
	        var _b = _a === void 0 ? {} : _a, _c = _b.descendants, descendants = _c === void 0 ? false : _c, _d = _b.read, read = _d === void 0 ? null : _d;
	        _super.call(this, _selector, { descendants: descendants, read: read });
	    }
	    return ContentChildrenMetadata;
	}(QueryMetadata));
	exports.ContentChildrenMetadata = ContentChildrenMetadata;
	// TODO: add an example after ContentChild and ViewChild are in master
	/**
	 * Configures a content query.
	 *
	 * Content queries are set before the `ngAfterContentInit` callback is called.
	 *
	 * ### Example
	 *
	 * ```
	 * @Directive({
	 *   selector: 'someDir'
	 * })
	 * class SomeDir {
	 *   @ContentChild(ChildDirective) contentChild;
	 *
	 *   ngAfterContentInit() {
	 *     // contentChild is set
	 *   }
	 * }
	 * ```
	 * @ts2dart_const
	 */
	var ContentChildMetadata = (function (_super) {
	    __extends(ContentChildMetadata, _super);
	    function ContentChildMetadata(_selector, _a) {
	        var _b = (_a === void 0 ? {} : _a).read, read = _b === void 0 ? null : _b;
	        _super.call(this, _selector, { descendants: true, first: true, read: read });
	    }
	    return ContentChildMetadata;
	}(QueryMetadata));
	exports.ContentChildMetadata = ContentChildMetadata;
	/**
	 * Similar to {@link QueryMetadata}, but querying the component view, instead of
	 * the content children.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/eNsFHDf7YjyM6IzKxM1j?p=preview))
	 *
	 * ```javascript
	 * @Component({
	 *   ...,
	 *   template: `
	 *     <item> a </item>
	 *     <item> b </item>
	 *     <item> c </item>
	 *   `
	 * })
	 * class MyComponent {
	 *   shown: boolean;
	 *
	 *   constructor(private @ViewQuery(Item) items:QueryList<Item>) {
	 *     items.changes.subscribe(() => console.log(items.length));
	 *   }
	 * }
	 * ```
	 *
	 * Supports the same querying parameters as {@link QueryMetadata}, except
	 * `descendants`. This always queries the whole view.
	 *
	 * As `shown` is flipped between true and false, items will contain zero of one
	 * items.
	 *
	 * Specifies that a {@link QueryList} should be injected.
	 *
	 * The injected object is an iterable and observable live list.
	 * See {@link QueryList} for more details.
	 * @ts2dart_const
	 */
	var ViewQueryMetadata = (function (_super) {
	    __extends(ViewQueryMetadata, _super);
	    function ViewQueryMetadata(_selector, _a) {
	        var _b = _a === void 0 ? {} : _a, _c = _b.descendants, descendants = _c === void 0 ? false : _c, _d = _b.first, first = _d === void 0 ? false : _d, _e = _b.read, read = _e === void 0 ? null : _e;
	        _super.call(this, _selector, { descendants: descendants, first: first, read: read });
	    }
	    Object.defineProperty(ViewQueryMetadata.prototype, "isViewQuery", {
	        /**
	         * always `true` to differentiate it with {@link QueryMetadata}.
	         */
	        get: function () { return true; },
	        enumerable: true,
	        configurable: true
	    });
	    ViewQueryMetadata.prototype.toString = function () { return "@ViewQuery(" + lang_1.stringify(this.selector) + ")"; };
	    return ViewQueryMetadata;
	}(QueryMetadata));
	exports.ViewQueryMetadata = ViewQueryMetadata;
	/**
	 * Declares a list of child element references.
	 *
	 * Angular automatically updates the list when the DOM is updated.
	 *
	 * `ViewChildren` takes an argument to select elements.
	 *
	 * - If the argument is a type, directives or components with the type will be bound.
	 *
	 * - If the argument is a string, the string is interpreted as a list of comma-separated selectors.
	 * For each selector, an element containing the matching template variable (e.g. `#child`) will be
	 * bound.
	 *
	 * View children are set before the `ngAfterViewInit` callback is called.
	 *
	 * ### Example
	 *
	 * With type selector:
	 *
	 * ```
	 * @Component({
	 *   selector: 'child-cmp',
	 *   template: '<p>child</p>'
	 * })
	 * class ChildCmp {
	 *   doSomething() {}
	 * }
	 *
	 * @Component({
	 *   selector: 'some-cmp',
	 *   template: `
	 *     <child-cmp></child-cmp>
	 *     <child-cmp></child-cmp>
	 *     <child-cmp></child-cmp>
	 *   `,
	 *   directives: [ChildCmp]
	 * })
	 * class SomeCmp {
	 *   @ViewChildren(ChildCmp) children:QueryList<ChildCmp>;
	 *
	 *   ngAfterViewInit() {
	 *     // children are set
	 *     this.children.toArray().forEach((child)=>child.doSomething());
	 *   }
	 * }
	 * ```
	 *
	 * With string selector:
	 *
	 * ```
	 * @Component({
	 *   selector: 'child-cmp',
	 *   template: '<p>child</p>'
	 * })
	 * class ChildCmp {
	 *   doSomething() {}
	 * }
	 *
	 * @Component({
	 *   selector: 'some-cmp',
	 *   template: `
	 *     <child-cmp #child1></child-cmp>
	 *     <child-cmp #child2></child-cmp>
	 *     <child-cmp #child3></child-cmp>
	 *   `,
	 *   directives: [ChildCmp]
	 * })
	 * class SomeCmp {
	 *   @ViewChildren('child1,child2,child3') children:QueryList<ChildCmp>;
	 *
	 *   ngAfterViewInit() {
	 *     // children are set
	 *     this.children.toArray().forEach((child)=>child.doSomething());
	 *   }
	 * }
	 * ```
	 * @ts2dart_const
	 */
	var ViewChildrenMetadata = (function (_super) {
	    __extends(ViewChildrenMetadata, _super);
	    function ViewChildrenMetadata(_selector, _a) {
	        var _b = (_a === void 0 ? {} : _a).read, read = _b === void 0 ? null : _b;
	        _super.call(this, _selector, { descendants: true, read: read });
	    }
	    return ViewChildrenMetadata;
	}(ViewQueryMetadata));
	exports.ViewChildrenMetadata = ViewChildrenMetadata;
	/**
	 *
	 * Declares a reference of child element.
	 *
	 * `ViewChildren` takes an argument to select elements.
	 *
	 * - If the argument is a type, a directive or a component with the type will be bound.
	 *
	 If the argument is a string, the string is interpreted as a selector. An element containing the
	 matching template variable (e.g. `#child`) will be bound.
	 *
	 * In either case, `@ViewChild()` assigns the first (looking from above) element if there are
	 multiple matches.
	 *
	 * View child is set before the `ngAfterViewInit` callback is called.
	 *
	 * ### Example
	 *
	 * With type selector:
	 *
	 * ```
	 * @Component({
	 *   selector: 'child-cmp',
	 *   template: '<p>child</p>'
	 * })
	 * class ChildCmp {
	 *   doSomething() {}
	 * }
	 *
	 * @Component({
	 *   selector: 'some-cmp',
	 *   template: '<child-cmp></child-cmp>',
	 *   directives: [ChildCmp]
	 * })
	 * class SomeCmp {
	 *   @ViewChild(ChildCmp) child:ChildCmp;
	 *
	 *   ngAfterViewInit() {
	 *     // child is set
	 *     this.child.doSomething();
	 *   }
	 * }
	 * ```
	 *
	 * With string selector:
	 *
	 * ```
	 * @Component({
	 *   selector: 'child-cmp',
	 *   template: '<p>child</p>'
	 * })
	 * class ChildCmp {
	 *   doSomething() {}
	 * }
	 *
	 * @Component({
	 *   selector: 'some-cmp',
	 *   template: '<child-cmp #child></child-cmp>',
	 *   directives: [ChildCmp]
	 * })
	 * class SomeCmp {
	 *   @ViewChild('child') child:ChildCmp;
	 *
	 *   ngAfterViewInit() {
	 *     // child is set
	 *     this.child.doSomething();
	 *   }
	 * }
	 * ```
	 * @ts2dart_const
	 */
	var ViewChildMetadata = (function (_super) {
	    __extends(ViewChildMetadata, _super);
	    function ViewChildMetadata(_selector, _a) {
	        var _b = (_a === void 0 ? {} : _a).read, read = _b === void 0 ? null : _b;
	        _super.call(this, _selector, { descendants: true, first: true, read: read });
	    }
	    return ViewChildMetadata;
	}(ViewQueryMetadata));
	exports.ViewChildMetadata = ViewChildMetadata;


/***/ },
/* 5 */
/***/ function(module, exports) {

	/* WEBPACK VAR INJECTION */(function(global) {"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var globalScope;
	if (typeof window === 'undefined') {
	    if (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) {
	        // TODO: Replace any with WorkerGlobalScope from lib.webworker.d.ts #3492
	        globalScope = self;
	    }
	    else {
	        globalScope = global;
	    }
	}
	else {
	    globalScope = window;
	}
	function scheduleMicroTask(fn) {
	    Zone.current.scheduleMicroTask('scheduleMicrotask', fn);
	}
	exports.scheduleMicroTask = scheduleMicroTask;
	exports.IS_DART = false;
	// Need to declare a new variable for global here since TypeScript
	// exports the original value of the symbol.
	var _global = globalScope;
	exports.global = _global;
	exports.Type = Function;
	function getTypeNameForDebugging(type) {
	    if (type['name']) {
	        return type['name'];
	    }
	    return typeof type;
	}
	exports.getTypeNameForDebugging = getTypeNameForDebugging;
	exports.Math = _global.Math;
	exports.Date = _global.Date;
	var _devMode = true;
	var _modeLocked = false;
	function lockMode() {
	    _modeLocked = true;
	}
	exports.lockMode = lockMode;
	/**
	 * Disable Angular's development mode, which turns off assertions and other
	 * checks within the framework.
	 *
	 * One important assertion this disables verifies that a change detection pass
	 * does not result in additional changes to any bindings (also known as
	 * unidirectional data flow).
	 */
	function enableProdMode() {
	    if (_modeLocked) {
	        // Cannot use BaseException as that ends up importing from facade/lang.
	        throw 'Cannot enable prod mode after platform setup.';
	    }
	    _devMode = false;
	}
	exports.enableProdMode = enableProdMode;
	function assertionsEnabled() {
	    return _devMode;
	}
	exports.assertionsEnabled = assertionsEnabled;
	// TODO: remove calls to assert in production environment
	// Note: Can't just export this and import in in other files
	// as `assert` is a reserved keyword in Dart
	_global.assert = function assert(condition) {
	    // TODO: to be fixed properly via #2830, noop for now
	};
	function isPresent(obj) {
	    return obj !== undefined && obj !== null;
	}
	exports.isPresent = isPresent;
	function isBlank(obj) {
	    return obj === undefined || obj === null;
	}
	exports.isBlank = isBlank;
	function isBoolean(obj) {
	    return typeof obj === "boolean";
	}
	exports.isBoolean = isBoolean;
	function isNumber(obj) {
	    return typeof obj === "number";
	}
	exports.isNumber = isNumber;
	function isString(obj) {
	    return typeof obj === "string";
	}
	exports.isString = isString;
	function isFunction(obj) {
	    return typeof obj === "function";
	}
	exports.isFunction = isFunction;
	function isType(obj) {
	    return isFunction(obj);
	}
	exports.isType = isType;
	function isStringMap(obj) {
	    return typeof obj === 'object' && obj !== null;
	}
	exports.isStringMap = isStringMap;
	var STRING_MAP_PROTO = Object.getPrototypeOf({});
	function isStrictStringMap(obj) {
	    return isStringMap(obj) && Object.getPrototypeOf(obj) === STRING_MAP_PROTO;
	}
	exports.isStrictStringMap = isStrictStringMap;
	function isPromise(obj) {
	    return obj instanceof _global.Promise;
	}
	exports.isPromise = isPromise;
	function isArray(obj) {
	    return Array.isArray(obj);
	}
	exports.isArray = isArray;
	function isDate(obj) {
	    return obj instanceof exports.Date && !isNaN(obj.valueOf());
	}
	exports.isDate = isDate;
	function noop() { }
	exports.noop = noop;
	function stringify(token) {
	    if (typeof token === 'string') {
	        return token;
	    }
	    if (token === undefined || token === null) {
	        return '' + token;
	    }
	    if (token.name) {
	        return token.name;
	    }
	    if (token.overriddenName) {
	        return token.overriddenName;
	    }
	    var res = token.toString();
	    var newLineIndex = res.indexOf("\n");
	    return (newLineIndex === -1) ? res : res.substring(0, newLineIndex);
	}
	exports.stringify = stringify;
	// serialize / deserialize enum exist only for consistency with dart API
	// enums in typescript don't need to be serialized
	function serializeEnum(val) {
	    return val;
	}
	exports.serializeEnum = serializeEnum;
	function deserializeEnum(val, values) {
	    return val;
	}
	exports.deserializeEnum = deserializeEnum;
	function resolveEnumToken(enumValue, val) {
	    return enumValue[val];
	}
	exports.resolveEnumToken = resolveEnumToken;
	var StringWrapper = (function () {
	    function StringWrapper() {
	    }
	    StringWrapper.fromCharCode = function (code) { return String.fromCharCode(code); };
	    StringWrapper.charCodeAt = function (s, index) { return s.charCodeAt(index); };
	    StringWrapper.split = function (s, regExp) { return s.split(regExp); };
	    StringWrapper.equals = function (s, s2) { return s === s2; };
	    StringWrapper.stripLeft = function (s, charVal) {
	        if (s && s.length) {
	            var pos = 0;
	            for (var i = 0; i < s.length; i++) {
	                if (s[i] != charVal)
	                    break;
	                pos++;
	            }
	            s = s.substring(pos);
	        }
	        return s;
	    };
	    StringWrapper.stripRight = function (s, charVal) {
	        if (s && s.length) {
	            var pos = s.length;
	            for (var i = s.length - 1; i >= 0; i--) {
	                if (s[i] != charVal)
	                    break;
	                pos--;
	            }
	            s = s.substring(0, pos);
	        }
	        return s;
	    };
	    StringWrapper.replace = function (s, from, replace) {
	        return s.replace(from, replace);
	    };
	    StringWrapper.replaceAll = function (s, from, replace) {
	        return s.replace(from, replace);
	    };
	    StringWrapper.slice = function (s, from, to) {
	        if (from === void 0) { from = 0; }
	        if (to === void 0) { to = null; }
	        return s.slice(from, to === null ? undefined : to);
	    };
	    StringWrapper.replaceAllMapped = function (s, from, cb) {
	        return s.replace(from, function () {
	            var matches = [];
	            for (var _i = 0; _i < arguments.length; _i++) {
	                matches[_i - 0] = arguments[_i];
	            }
	            // Remove offset & string from the result array
	            matches.splice(-2, 2);
	            // The callback receives match, p1, ..., pn
	            return cb(matches);
	        });
	    };
	    StringWrapper.contains = function (s, substr) { return s.indexOf(substr) != -1; };
	    StringWrapper.compare = function (a, b) {
	        if (a < b) {
	            return -1;
	        }
	        else if (a > b) {
	            return 1;
	        }
	        else {
	            return 0;
	        }
	    };
	    return StringWrapper;
	}());
	exports.StringWrapper = StringWrapper;
	var StringJoiner = (function () {
	    function StringJoiner(parts) {
	        if (parts === void 0) { parts = []; }
	        this.parts = parts;
	    }
	    StringJoiner.prototype.add = function (part) { this.parts.push(part); };
	    StringJoiner.prototype.toString = function () { return this.parts.join(""); };
	    return StringJoiner;
	}());
	exports.StringJoiner = StringJoiner;
	var NumberParseError = (function (_super) {
	    __extends(NumberParseError, _super);
	    function NumberParseError(message) {
	        _super.call(this);
	        this.message = message;
	    }
	    NumberParseError.prototype.toString = function () { return this.message; };
	    return NumberParseError;
	}(Error));
	exports.NumberParseError = NumberParseError;
	var NumberWrapper = (function () {
	    function NumberWrapper() {
	    }
	    NumberWrapper.toFixed = function (n, fractionDigits) { return n.toFixed(fractionDigits); };
	    NumberWrapper.equal = function (a, b) { return a === b; };
	    NumberWrapper.parseIntAutoRadix = function (text) {
	        var result = parseInt(text);
	        if (isNaN(result)) {
	            throw new NumberParseError("Invalid integer literal when parsing " + text);
	        }
	        return result;
	    };
	    NumberWrapper.parseInt = function (text, radix) {
	        if (radix == 10) {
	            if (/^(\-|\+)?[0-9]+$/.test(text)) {
	                return parseInt(text, radix);
	            }
	        }
	        else if (radix == 16) {
	            if (/^(\-|\+)?[0-9ABCDEFabcdef]+$/.test(text)) {
	                return parseInt(text, radix);
	            }
	        }
	        else {
	            var result = parseInt(text, radix);
	            if (!isNaN(result)) {
	                return result;
	            }
	        }
	        throw new NumberParseError("Invalid integer literal when parsing " + text + " in base " +
	            radix);
	    };
	    // TODO: NaN is a valid literal but is returned by parseFloat to indicate an error.
	    NumberWrapper.parseFloat = function (text) { return parseFloat(text); };
	    Object.defineProperty(NumberWrapper, "NaN", {
	        get: function () { return NaN; },
	        enumerable: true,
	        configurable: true
	    });
	    NumberWrapper.isNaN = function (value) { return isNaN(value); };
	    NumberWrapper.isInteger = function (value) { return Number.isInteger(value); };
	    return NumberWrapper;
	}());
	exports.NumberWrapper = NumberWrapper;
	exports.RegExp = _global.RegExp;
	var RegExpWrapper = (function () {
	    function RegExpWrapper() {
	    }
	    RegExpWrapper.create = function (regExpStr, flags) {
	        if (flags === void 0) { flags = ''; }
	        flags = flags.replace(/g/g, '');
	        return new _global.RegExp(regExpStr, flags + 'g');
	    };
	    RegExpWrapper.firstMatch = function (regExp, input) {
	        // Reset multimatch regex state
	        regExp.lastIndex = 0;
	        return regExp.exec(input);
	    };
	    RegExpWrapper.test = function (regExp, input) {
	        regExp.lastIndex = 0;
	        return regExp.test(input);
	    };
	    RegExpWrapper.matcher = function (regExp, input) {
	        // Reset regex state for the case
	        // someone did not loop over all matches
	        // last time.
	        regExp.lastIndex = 0;
	        return { re: regExp, input: input };
	    };
	    RegExpWrapper.replaceAll = function (regExp, input, replace) {
	        var c = regExp.exec(input);
	        var res = '';
	        regExp.lastIndex = 0;
	        var prev = 0;
	        while (c) {
	            res += input.substring(prev, c.index);
	            res += replace(c);
	            prev = c.index + c[0].length;
	            regExp.lastIndex = prev;
	            c = regExp.exec(input);
	        }
	        res += input.substring(prev);
	        return res;
	    };
	    return RegExpWrapper;
	}());
	exports.RegExpWrapper = RegExpWrapper;
	var RegExpMatcherWrapper = (function () {
	    function RegExpMatcherWrapper() {
	    }
	    RegExpMatcherWrapper.next = function (matcher) {
	        return matcher.re.exec(matcher.input);
	    };
	    return RegExpMatcherWrapper;
	}());
	exports.RegExpMatcherWrapper = RegExpMatcherWrapper;
	var FunctionWrapper = (function () {
	    function FunctionWrapper() {
	    }
	    FunctionWrapper.apply = function (fn, posArgs) { return fn.apply(null, posArgs); };
	    return FunctionWrapper;
	}());
	exports.FunctionWrapper = FunctionWrapper;
	// JS has NaN !== NaN
	function looseIdentical(a, b) {
	    return a === b || typeof a === "number" && typeof b === "number" && isNaN(a) && isNaN(b);
	}
	exports.looseIdentical = looseIdentical;
	// JS considers NaN is the same as NaN for map Key (while NaN !== NaN otherwise)
	// see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
	function getMapKey(value) {
	    return value;
	}
	exports.getMapKey = getMapKey;
	function normalizeBlank(obj) {
	    return isBlank(obj) ? null : obj;
	}
	exports.normalizeBlank = normalizeBlank;
	function normalizeBool(obj) {
	    return isBlank(obj) ? false : obj;
	}
	exports.normalizeBool = normalizeBool;
	function isJsObject(o) {
	    return o !== null && (typeof o === "function" || typeof o === "object");
	}
	exports.isJsObject = isJsObject;
	function print(obj) {
	    console.log(obj);
	}
	exports.print = print;
	function warn(obj) {
	    console.warn(obj);
	}
	exports.warn = warn;
	// Can't be all uppercase as our transpiler would think it is a special directive...
	var Json = (function () {
	    function Json() {
	    }
	    Json.parse = function (s) { return _global.JSON.parse(s); };
	    Json.stringify = function (data) {
	        // Dart doesn't take 3 arguments
	        return _global.JSON.stringify(data, null, 2);
	    };
	    return Json;
	}());
	exports.Json = Json;
	var DateWrapper = (function () {
	    function DateWrapper() {
	    }
	    DateWrapper.create = function (year, month, day, hour, minutes, seconds, milliseconds) {
	        if (month === void 0) { month = 1; }
	        if (day === void 0) { day = 1; }
	        if (hour === void 0) { hour = 0; }
	        if (minutes === void 0) { minutes = 0; }
	        if (seconds === void 0) { seconds = 0; }
	        if (milliseconds === void 0) { milliseconds = 0; }
	        return new exports.Date(year, month - 1, day, hour, minutes, seconds, milliseconds);
	    };
	    DateWrapper.fromISOString = function (str) { return new exports.Date(str); };
	    DateWrapper.fromMillis = function (ms) { return new exports.Date(ms); };
	    DateWrapper.toMillis = function (date) { return date.getTime(); };
	    DateWrapper.now = function () { return new exports.Date(); };
	    DateWrapper.toJson = function (date) { return date.toJSON(); };
	    return DateWrapper;
	}());
	exports.DateWrapper = DateWrapper;
	function setValueOnPath(global, path, value) {
	    var parts = path.split('.');
	    var obj = global;
	    while (parts.length > 1) {
	        var name = parts.shift();
	        if (obj.hasOwnProperty(name) && isPresent(obj[name])) {
	            obj = obj[name];
	        }
	        else {
	            obj = obj[name] = {};
	        }
	    }
	    if (obj === undefined || obj === null) {
	        obj = {};
	    }
	    obj[parts.shift()] = value;
	}
	exports.setValueOnPath = setValueOnPath;
	var _symbolIterator = null;
	function getSymbolIterator() {
	    if (isBlank(_symbolIterator)) {
	        if (isPresent(globalScope.Symbol) && isPresent(Symbol.iterator)) {
	            _symbolIterator = Symbol.iterator;
	        }
	        else {
	            // es6-shim specific logic
	            var keys = Object.getOwnPropertyNames(Map.prototype);
	            for (var i = 0; i < keys.length; ++i) {
	                var key = keys[i];
	                if (key !== 'entries' && key !== 'size' &&
	                    Map.prototype[key] === Map.prototype['entries']) {
	                    _symbolIterator = key;
	                }
	            }
	        }
	    }
	    return _symbolIterator;
	}
	exports.getSymbolIterator = getSymbolIterator;
	function evalExpression(sourceUrl, expr, declarations, vars) {
	    var fnBody = declarations + "\nreturn " + expr + "\n//# sourceURL=" + sourceUrl;
	    var fnArgNames = [];
	    var fnArgValues = [];
	    for (var argName in vars) {
	        fnArgNames.push(argName);
	        fnArgValues.push(vars[argName]);
	    }
	    return new (Function.bind.apply(Function, [void 0].concat(fnArgNames.concat(fnBody))))().apply(void 0, fnArgValues);
	}
	exports.evalExpression = evalExpression;
	function isPrimitive(obj) {
	    return !isJsObject(obj);
	}
	exports.isPrimitive = isPrimitive;
	function hasConstructor(value, type) {
	    return value.constructor === type;
	}
	exports.hasConstructor = hasConstructor;
	function bitWiseOr(values) {
	    return values.reduce(function (a, b) { return a | b; });
	}
	exports.bitWiseOr = bitWiseOr;
	function bitWiseAnd(values) {
	    return values.reduce(function (a, b) { return a & b; });
	}
	exports.bitWiseAnd = bitWiseAnd;
	function escape(s) {
	    return _global.encodeURI(s);
	}
	exports.escape = escape;

	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * @module
	 * @description
	 * The `di` module provides dependency injection container services.
	 */
	"use strict";
	function __export(m) {
	    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
	}
	var metadata_1 = __webpack_require__(7);
	exports.InjectMetadata = metadata_1.InjectMetadata;
	exports.OptionalMetadata = metadata_1.OptionalMetadata;
	exports.InjectableMetadata = metadata_1.InjectableMetadata;
	exports.SelfMetadata = metadata_1.SelfMetadata;
	exports.HostMetadata = metadata_1.HostMetadata;
	exports.SkipSelfMetadata = metadata_1.SkipSelfMetadata;
	exports.DependencyMetadata = metadata_1.DependencyMetadata;
	// we have to reexport * because Dart and TS export two different sets of types
	__export(__webpack_require__(8));
	var forward_ref_1 = __webpack_require__(10);
	exports.forwardRef = forward_ref_1.forwardRef;
	exports.resolveForwardRef = forward_ref_1.resolveForwardRef;
	var injector_1 = __webpack_require__(11);
	exports.Injector = injector_1.Injector;
	var reflective_injector_1 = __webpack_require__(16);
	exports.ReflectiveInjector = reflective_injector_1.ReflectiveInjector;
	var provider_1 = __webpack_require__(24);
	exports.Binding = provider_1.Binding;
	exports.ProviderBuilder = provider_1.ProviderBuilder;
	exports.bind = provider_1.bind;
	exports.Provider = provider_1.Provider;
	exports.provide = provider_1.provide;
	var reflective_provider_1 = __webpack_require__(17);
	exports.ResolvedReflectiveFactory = reflective_provider_1.ResolvedReflectiveFactory;
	exports.ReflectiveDependency = reflective_provider_1.ReflectiveDependency;
	var reflective_key_1 = __webpack_require__(22);
	exports.ReflectiveKey = reflective_key_1.ReflectiveKey;
	var reflective_exceptions_1 = __webpack_require__(23);
	exports.NoProviderError = reflective_exceptions_1.NoProviderError;
	exports.AbstractProviderError = reflective_exceptions_1.AbstractProviderError;
	exports.CyclicDependencyError = reflective_exceptions_1.CyclicDependencyError;
	exports.InstantiationError = reflective_exceptions_1.InstantiationError;
	exports.InvalidProviderError = reflective_exceptions_1.InvalidProviderError;
	exports.NoAnnotationError = reflective_exceptions_1.NoAnnotationError;
	exports.OutOfBoundsError = reflective_exceptions_1.OutOfBoundsError;
	var opaque_token_1 = __webpack_require__(26);
	exports.OpaqueToken = opaque_token_1.OpaqueToken;


/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	/**
	 * A parameter metadata that specifies a dependency.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/6uHYJK?p=preview))
	 *
	 * ```typescript
	 * class Engine {}
	 *
	 * @Injectable()
	 * class Car {
	 *   engine;
	 *   constructor(@Inject("MyEngine") engine:Engine) {
	 *     this.engine = engine;
	 *   }
	 * }
	 *
	 * var injector = Injector.resolveAndCreate([
	 *  provide("MyEngine", {useClass: Engine}),
	 *  Car
	 * ]);
	 *
	 * expect(injector.get(Car).engine instanceof Engine).toBe(true);
	 * ```
	 *
	 * When `@Inject()` is not present, {@link Injector} will use the type annotation of the parameter.
	 *
	 * ### Example
	 *
	 * ```typescript
	 * class Engine {}
	 *
	 * @Injectable()
	 * class Car {
	 *   constructor(public engine: Engine) {} //same as constructor(@Inject(Engine) engine:Engine)
	 * }
	 *
	 * var injector = Injector.resolveAndCreate([Engine, Car]);
	 * expect(injector.get(Car).engine instanceof Engine).toBe(true);
	 * ```
	 * @ts2dart_const
	 */
	var InjectMetadata = (function () {
	    function InjectMetadata(token) {
	        this.token = token;
	    }
	    InjectMetadata.prototype.toString = function () { return "@Inject(" + lang_1.stringify(this.token) + ")"; };
	    return InjectMetadata;
	}());
	exports.InjectMetadata = InjectMetadata;
	/**
	 * A parameter metadata that marks a dependency as optional. {@link Injector} provides `null` if
	 * the dependency is not found.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/AsryOm?p=preview))
	 *
	 * ```typescript
	 * class Engine {}
	 *
	 * @Injectable()
	 * class Car {
	 *   engine;
	 *   constructor(@Optional() engine:Engine) {
	 *     this.engine = engine;
	 *   }
	 * }
	 *
	 * var injector = Injector.resolveAndCreate([Car]);
	 * expect(injector.get(Car).engine).toBeNull();
	 * ```
	 * @ts2dart_const
	 */
	var OptionalMetadata = (function () {
	    function OptionalMetadata() {
	    }
	    OptionalMetadata.prototype.toString = function () { return "@Optional()"; };
	    return OptionalMetadata;
	}());
	exports.OptionalMetadata = OptionalMetadata;
	/**
	 * `DependencyMetadata` is used by the framework to extend DI.
	 * This is internal to Angular and should not be used directly.
	 * @ts2dart_const
	 */
	var DependencyMetadata = (function () {
	    function DependencyMetadata() {
	    }
	    Object.defineProperty(DependencyMetadata.prototype, "token", {
	        get: function () { return null; },
	        enumerable: true,
	        configurable: true
	    });
	    return DependencyMetadata;
	}());
	exports.DependencyMetadata = DependencyMetadata;
	/**
	 * A marker metadata that marks a class as available to {@link Injector} for creation.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/Wk4DMQ?p=preview))
	 *
	 * ```typescript
	 * @Injectable()
	 * class UsefulService {}
	 *
	 * @Injectable()
	 * class NeedsService {
	 *   constructor(public service:UsefulService) {}
	 * }
	 *
	 * var injector = Injector.resolveAndCreate([NeedsService, UsefulService]);
	 * expect(injector.get(NeedsService).service instanceof UsefulService).toBe(true);
	 * ```
	 * {@link Injector} will throw {@link NoAnnotationError} when trying to instantiate a class that
	 * does not have `@Injectable` marker, as shown in the example below.
	 *
	 * ```typescript
	 * class UsefulService {}
	 *
	 * class NeedsService {
	 *   constructor(public service:UsefulService) {}
	 * }
	 *
	 * var injector = Injector.resolveAndCreate([NeedsService, UsefulService]);
	 * expect(() => injector.get(NeedsService)).toThrowError();
	 * ```
	 * @ts2dart_const
	 */
	var InjectableMetadata = (function () {
	    function InjectableMetadata() {
	    }
	    return InjectableMetadata;
	}());
	exports.InjectableMetadata = InjectableMetadata;
	/**
	 * Specifies that an {@link Injector} should retrieve a dependency only from itself.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/NeagAg?p=preview))
	 *
	 * ```typescript
	 * class Dependency {
	 * }
	 *
	 * @Injectable()
	 * class NeedsDependency {
	 *   dependency;
	 *   constructor(@Self() dependency:Dependency) {
	 *     this.dependency = dependency;
	 *   }
	 * }
	 *
	 * var inj = Injector.resolveAndCreate([Dependency, NeedsDependency]);
	 * var nd = inj.get(NeedsDependency);
	 *
	 * expect(nd.dependency instanceof Dependency).toBe(true);
	 *
	 * var inj = Injector.resolveAndCreate([Dependency]);
	 * var child = inj.resolveAndCreateChild([NeedsDependency]);
	 * expect(() => child.get(NeedsDependency)).toThrowError();
	 * ```
	 * @ts2dart_const
	 */
	var SelfMetadata = (function () {
	    function SelfMetadata() {
	    }
	    SelfMetadata.prototype.toString = function () { return "@Self()"; };
	    return SelfMetadata;
	}());
	exports.SelfMetadata = SelfMetadata;
	/**
	 * Specifies that the dependency resolution should start from the parent injector.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/Wchdzb?p=preview))
	 *
	 * ```typescript
	 * class Dependency {
	 * }
	 *
	 * @Injectable()
	 * class NeedsDependency {
	 *   dependency;
	 *   constructor(@SkipSelf() dependency:Dependency) {
	 *     this.dependency = dependency;
	 *   }
	 * }
	 *
	 * var parent = Injector.resolveAndCreate([Dependency]);
	 * var child = parent.resolveAndCreateChild([NeedsDependency]);
	 * expect(child.get(NeedsDependency).dependency instanceof Depedency).toBe(true);
	 *
	 * var inj = Injector.resolveAndCreate([Dependency, NeedsDependency]);
	 * expect(() => inj.get(NeedsDependency)).toThrowError();
	 * ```
	 * @ts2dart_const
	 */
	var SkipSelfMetadata = (function () {
	    function SkipSelfMetadata() {
	    }
	    SkipSelfMetadata.prototype.toString = function () { return "@SkipSelf()"; };
	    return SkipSelfMetadata;
	}());
	exports.SkipSelfMetadata = SkipSelfMetadata;
	/**
	 * Specifies that an injector should retrieve a dependency from any injector until reaching the
	 * closest host.
	 *
	 * In Angular, a component element is automatically declared as a host for all the injectors in
	 * its view.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/GX79pV?p=preview))
	 *
	 * In the following example `App` contains `ParentCmp`, which contains `ChildDirective`.
	 * So `ParentCmp` is the host of `ChildDirective`.
	 *
	 * `ChildDirective` depends on two services: `HostService` and `OtherService`.
	 * `HostService` is defined at `ParentCmp`, and `OtherService` is defined at `App`.
	 *
	 *```typescript
	 * class OtherService {}
	 * class HostService {}
	 *
	 * @Directive({
	 *   selector: 'child-directive'
	 * })
	 * class ChildDirective {
	 *   constructor(@Optional() @Host() os:OtherService, @Optional() @Host() hs:HostService){
	 *     console.log("os is null", os);
	 *     console.log("hs is NOT null", hs);
	 *   }
	 * }
	 *
	 * @Component({
	 *   selector: 'parent-cmp',
	 *   providers: [HostService],
	 *   template: `
	 *     Dir: <child-directive></child-directive>
	 *   `,
	 *   directives: [ChildDirective]
	 * })
	 * class ParentCmp {
	 * }
	 *
	 * @Component({
	 *   selector: 'app',
	 *   providers: [OtherService],
	 *   template: `
	 *     Parent: <parent-cmp></parent-cmp>
	 *   `,
	 *   directives: [ParentCmp]
	 * })
	 * class App {
	 * }
	 *
	 * bootstrap(App);
	 *```
	 * @ts2dart_const
	 */
	var HostMetadata = (function () {
	    function HostMetadata() {
	    }
	    HostMetadata.prototype.toString = function () { return "@Host()"; };
	    return HostMetadata;
	}());
	exports.HostMetadata = HostMetadata;


/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var metadata_1 = __webpack_require__(7);
	var decorators_1 = __webpack_require__(9);
	/**
	 * Factory for creating {@link InjectMetadata}.
	 */
	exports.Inject = decorators_1.makeParamDecorator(metadata_1.InjectMetadata);
	/**
	 * Factory for creating {@link OptionalMetadata}.
	 */
	exports.Optional = decorators_1.makeParamDecorator(metadata_1.OptionalMetadata);
	/**
	 * Factory for creating {@link InjectableMetadata}.
	 */
	exports.Injectable = decorators_1.makeDecorator(metadata_1.InjectableMetadata);
	/**
	 * Factory for creating {@link SelfMetadata}.
	 */
	exports.Self = decorators_1.makeParamDecorator(metadata_1.SelfMetadata);
	/**
	 * Factory for creating {@link HostMetadata}.
	 */
	exports.Host = decorators_1.makeParamDecorator(metadata_1.HostMetadata);
	/**
	 * Factory for creating {@link SkipSelfMetadata}.
	 */
	exports.SkipSelf = decorators_1.makeParamDecorator(metadata_1.SkipSelfMetadata);


/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var _nextClassId = 0;
	function extractAnnotation(annotation) {
	    if (lang_1.isFunction(annotation) && annotation.hasOwnProperty('annotation')) {
	        // it is a decorator, extract annotation
	        annotation = annotation.annotation;
	    }
	    return annotation;
	}
	function applyParams(fnOrArray, key) {
	    if (fnOrArray === Object || fnOrArray === String || fnOrArray === Function ||
	        fnOrArray === Number || fnOrArray === Array) {
	        throw new Error("Can not use native " + lang_1.stringify(fnOrArray) + " as constructor");
	    }
	    if (lang_1.isFunction(fnOrArray)) {
	        return fnOrArray;
	    }
	    else if (fnOrArray instanceof Array) {
	        var annotations = fnOrArray;
	        var fn = fnOrArray[fnOrArray.length - 1];
	        if (!lang_1.isFunction(fn)) {
	            throw new Error("Last position of Class method array must be Function in key " + key + " was '" + lang_1.stringify(fn) + "'");
	        }
	        var annoLength = annotations.length - 1;
	        if (annoLength != fn.length) {
	            throw new Error("Number of annotations (" + annoLength + ") does not match number of arguments (" + fn.length + ") in the function: " + lang_1.stringify(fn));
	        }
	        var paramsAnnotations = [];
	        for (var i = 0, ii = annotations.length - 1; i < ii; i++) {
	            var paramAnnotations = [];
	            paramsAnnotations.push(paramAnnotations);
	            var annotation = annotations[i];
	            if (annotation instanceof Array) {
	                for (var j = 0; j < annotation.length; j++) {
	                    paramAnnotations.push(extractAnnotation(annotation[j]));
	                }
	            }
	            else if (lang_1.isFunction(annotation)) {
	                paramAnnotations.push(extractAnnotation(annotation));
	            }
	            else {
	                paramAnnotations.push(annotation);
	            }
	        }
	        Reflect.defineMetadata('parameters', paramsAnnotations, fn);
	        return fn;
	    }
	    else {
	        throw new Error("Only Function or Array is supported in Class definition for key '" + key + "' is '" + lang_1.stringify(fnOrArray) + "'");
	    }
	}
	/**
	 * Provides a way for expressing ES6 classes with parameter annotations in ES5.
	 *
	 * ## Basic Example
	 *
	 * ```
	 * var Greeter = ng.Class({
	 *   constructor: function(name) {
	 *     this.name = name;
	 *   },
	 *
	 *   greet: function() {
	 *     alert('Hello ' + this.name + '!');
	 *   }
	 * });
	 * ```
	 *
	 * is equivalent to ES6:
	 *
	 * ```
	 * class Greeter {
	 *   constructor(name) {
	 *     this.name = name;
	 *   }
	 *
	 *   greet() {
	 *     alert('Hello ' + this.name + '!');
	 *   }
	 * }
	 * ```
	 *
	 * or equivalent to ES5:
	 *
	 * ```
	 * var Greeter = function (name) {
	 *   this.name = name;
	 * }
	 *
	 * Greeter.prototype.greet = function () {
	 *   alert('Hello ' + this.name + '!');
	 * }
	 * ```
	 *
	 * ### Example with parameter annotations
	 *
	 * ```
	 * var MyService = ng.Class({
	 *   constructor: [String, [new Query(), QueryList], function(name, queryList) {
	 *     ...
	 *   }]
	 * });
	 * ```
	 *
	 * is equivalent to ES6:
	 *
	 * ```
	 * class MyService {
	 *   constructor(name: string, @Query() queryList: QueryList) {
	 *     ...
	 *   }
	 * }
	 * ```
	 *
	 * ### Example with inheritance
	 *
	 * ```
	 * var Shape = ng.Class({
	 *   constructor: (color) {
	 *     this.color = color;
	 *   }
	 * });
	 *
	 * var Square = ng.Class({
	 *   extends: Shape,
	 *   constructor: function(color, size) {
	 *     Shape.call(this, color);
	 *     this.size = size;
	 *   }
	 * });
	 * ```
	 */
	function Class(clsDef) {
	    var constructor = applyParams(clsDef.hasOwnProperty('constructor') ? clsDef.constructor : undefined, 'constructor');
	    var proto = constructor.prototype;
	    if (clsDef.hasOwnProperty('extends')) {
	        if (lang_1.isFunction(clsDef.extends)) {
	            constructor.prototype = proto =
	                Object.create(clsDef.extends.prototype);
	        }
	        else {
	            throw new Error("Class definition 'extends' property must be a constructor function was: " + lang_1.stringify(clsDef.extends));
	        }
	    }
	    for (var key in clsDef) {
	        if (key != 'extends' && key != 'prototype' && clsDef.hasOwnProperty(key)) {
	            proto[key] = applyParams(clsDef[key], key);
	        }
	    }
	    if (this && this.annotations instanceof Array) {
	        Reflect.defineMetadata('annotations', this.annotations, constructor);
	    }
	    if (!constructor['name']) {
	        constructor['overriddenName'] = "class" + _nextClassId++;
	    }
	    return constructor;
	}
	exports.Class = Class;
	var Reflect = lang_1.global.Reflect;
	// Throw statement at top-level is disallowed by closure compiler in ES6 input.
	// Wrap in an IIFE as a work-around.
	(function checkReflect() {
	    if (!(Reflect && Reflect.getMetadata)) {
	        throw 'reflect-metadata shim is required when using class decorators';
	    }
	})();
	function makeDecorator(annotationCls, chainFn) {
	    if (chainFn === void 0) { chainFn = null; }
	    function DecoratorFactory(objOrType) {
	        var annotationInstance = new annotationCls(objOrType);
	        if (this instanceof annotationCls) {
	            return annotationInstance;
	        }
	        else {
	            var chainAnnotation = lang_1.isFunction(this) && this.annotations instanceof Array ? this.annotations : [];
	            chainAnnotation.push(annotationInstance);
	            var TypeDecorator = function TypeDecorator(cls) {
	                var annotations = Reflect.getOwnMetadata('annotations', cls);
	                annotations = annotations || [];
	                annotations.push(annotationInstance);
	                Reflect.defineMetadata('annotations', annotations, cls);
	                return cls;
	            };
	            TypeDecorator.annotations = chainAnnotation;
	            TypeDecorator.Class = Class;
	            if (chainFn)
	                chainFn(TypeDecorator);
	            return TypeDecorator;
	        }
	    }
	    DecoratorFactory.prototype = Object.create(annotationCls.prototype);
	    return DecoratorFactory;
	}
	exports.makeDecorator = makeDecorator;
	function makeParamDecorator(annotationCls) {
	    function ParamDecoratorFactory() {
	        var args = [];
	        for (var _i = 0; _i < arguments.length; _i++) {
	            args[_i - 0] = arguments[_i];
	        }
	        var annotationInstance = Object.create(annotationCls.prototype);
	        annotationCls.apply(annotationInstance, args);
	        if (this instanceof annotationCls) {
	            return annotationInstance;
	        }
	        else {
	            ParamDecorator.annotation = annotationInstance;
	            return ParamDecorator;
	        }
	        function ParamDecorator(cls, unusedKey, index) {
	            var parameters = Reflect.getMetadata('parameters', cls);
	            parameters = parameters || [];
	            // there might be gaps if some in between parameters do not have annotations.
	            // we pad with nulls.
	            while (parameters.length <= index) {
	                parameters.push(null);
	            }
	            parameters[index] = parameters[index] || [];
	            var annotationsForParam = parameters[index];
	            annotationsForParam.push(annotationInstance);
	            Reflect.defineMetadata('parameters', parameters, cls);
	            return cls;
	        }
	    }
	    ParamDecoratorFactory.prototype = Object.create(annotationCls.prototype);
	    return ParamDecoratorFactory;
	}
	exports.makeParamDecorator = makeParamDecorator;
	function makePropDecorator(decoratorCls) {
	    function PropDecoratorFactory() {
	        var args = [];
	        for (var _i = 0; _i < arguments.length; _i++) {
	            args[_i - 0] = arguments[_i];
	        }
	        var decoratorInstance = Object.create(decoratorCls.prototype);
	        decoratorCls.apply(decoratorInstance, args);
	        if (this instanceof decoratorCls) {
	            return decoratorInstance;
	        }
	        else {
	            return function PropDecorator(target, name) {
	                var meta = Reflect.getOwnMetadata('propMetadata', target.constructor);
	                meta = meta || {};
	                meta[name] = meta[name] || [];
	                meta[name].unshift(decoratorInstance);
	                Reflect.defineMetadata('propMetadata', meta, target.constructor);
	            };
	        }
	    }
	    PropDecoratorFactory.prototype = Object.create(decoratorCls.prototype);
	    return PropDecoratorFactory;
	}
	exports.makePropDecorator = makePropDecorator;


/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	/**
	 * Allows to refer to references which are not yet defined.
	 *
	 * For instance, `forwardRef` is used when the `token` which we need to refer to for the purposes of
	 * DI is declared,
	 * but not yet defined. It is also used when the `token` which we use when creating a query is not
	 * yet defined.
	 *
	 * ### Example
	 * {@example core/di/ts/forward_ref/forward_ref.ts region='forward_ref'}
	 */
	function forwardRef(forwardRefFn) {
	    forwardRefFn.__forward_ref__ = forwardRef;
	    forwardRefFn.toString = function () { return lang_1.stringify(this()); };
	    return forwardRefFn;
	}
	exports.forwardRef = forwardRef;
	/**
	 * Lazily retrieves the reference value from a forwardRef.
	 *
	 * Acts as the identity function when given a non-forward-ref value.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/GU72mJrk1fiodChcmiDR?p=preview))
	 *
	 * ```typescript
	 * var ref = forwardRef(() => "refValue");
	 * expect(resolveForwardRef(ref)).toEqual("refValue");
	 * expect(resolveForwardRef("regularValue")).toEqual("regularValue");
	 * ```
	 *
	 * See: {@link forwardRef}
	 */
	function resolveForwardRef(type) {
	    if (lang_1.isFunction(type) && type.hasOwnProperty('__forward_ref__') &&
	        type.__forward_ref__ === forwardRef) {
	        return type();
	    }
	    else {
	        return type;
	    }
	}
	exports.resolveForwardRef = resolveForwardRef;


/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var exceptions_1 = __webpack_require__(12);
	var _THROW_IF_NOT_FOUND = new Object();
	exports.THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
	var Injector = (function () {
	    function Injector() {
	    }
	    /**
	     * Retrieves an instance from the injector based on the provided token.
	     * If not found:
	     * - Throws {@link NoProviderError} if no `notFoundValue` that is not equal to
	     * Injector.THROW_IF_NOT_FOUND is given
	     * - Returns the `notFoundValue` otherwise
	     *
	     * ### Example ([live demo](http://plnkr.co/edit/HeXSHg?p=preview))
	     *
	     * ```typescript
	     * var injector = ReflectiveInjector.resolveAndCreate([
	     *   provide("validToken", {useValue: "Value"})
	     * ]);
	     * expect(injector.get("validToken")).toEqual("Value");
	     * expect(() => injector.get("invalidToken")).toThrowError();
	     * ```
	     *
	     * `Injector` returns itself when given `Injector` as a token.
	     *
	     * ```typescript
	     * var injector = ReflectiveInjector.resolveAndCreate([]);
	     * expect(injector.get(Injector)).toBe(injector);
	     * ```
	     */
	    Injector.prototype.get = function (token, notFoundValue) { return exceptions_1.unimplemented(); };
	    Injector.THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
	    return Injector;
	}());
	exports.Injector = Injector;


/***/ },
/* 12 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var base_wrapped_exception_1 = __webpack_require__(13);
	var exception_handler_1 = __webpack_require__(14);
	var exception_handler_2 = __webpack_require__(14);
	exports.ExceptionHandler = exception_handler_2.ExceptionHandler;
	var BaseException = (function (_super) {
	    __extends(BaseException, _super);
	    function BaseException(message) {
	        if (message === void 0) { message = "--"; }
	        _super.call(this, message);
	        this.message = message;
	        this.stack = (new Error(message)).stack;
	    }
	    BaseException.prototype.toString = function () { return this.message; };
	    return BaseException;
	}(Error));
	exports.BaseException = BaseException;
	/**
	 * Wraps an exception and provides additional context or information.
	 */
	var WrappedException = (function (_super) {
	    __extends(WrappedException, _super);
	    function WrappedException(_wrapperMessage, _originalException, _originalStack, _context) {
	        _super.call(this, _wrapperMessage);
	        this._wrapperMessage = _wrapperMessage;
	        this._originalException = _originalException;
	        this._originalStack = _originalStack;
	        this._context = _context;
	        this._wrapperStack = (new Error(_wrapperMessage)).stack;
	    }
	    Object.defineProperty(WrappedException.prototype, "wrapperMessage", {
	        get: function () { return this._wrapperMessage; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(WrappedException.prototype, "wrapperStack", {
	        get: function () { return this._wrapperStack; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(WrappedException.prototype, "originalException", {
	        get: function () { return this._originalException; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(WrappedException.prototype, "originalStack", {
	        get: function () { return this._originalStack; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(WrappedException.prototype, "context", {
	        get: function () { return this._context; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(WrappedException.prototype, "message", {
	        get: function () { return exception_handler_1.ExceptionHandler.exceptionToString(this); },
	        enumerable: true,
	        configurable: true
	    });
	    WrappedException.prototype.toString = function () { return this.message; };
	    return WrappedException;
	}(base_wrapped_exception_1.BaseWrappedException));
	exports.WrappedException = WrappedException;
	function makeTypeError(message) {
	    return new TypeError(message);
	}
	exports.makeTypeError = makeTypeError;
	function unimplemented() {
	    throw new BaseException('unimplemented');
	}
	exports.unimplemented = unimplemented;


/***/ },
/* 13 */
/***/ function(module, exports) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	/**
	 * A base class for the WrappedException that can be used to identify
	 * a WrappedException from ExceptionHandler without adding circular
	 * dependency.
	 */
	var BaseWrappedException = (function (_super) {
	    __extends(BaseWrappedException, _super);
	    function BaseWrappedException(message) {
	        _super.call(this, message);
	    }
	    Object.defineProperty(BaseWrappedException.prototype, "wrapperMessage", {
	        get: function () { return ''; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(BaseWrappedException.prototype, "wrapperStack", {
	        get: function () { return null; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(BaseWrappedException.prototype, "originalException", {
	        get: function () { return null; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(BaseWrappedException.prototype, "originalStack", {
	        get: function () { return null; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(BaseWrappedException.prototype, "context", {
	        get: function () { return null; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(BaseWrappedException.prototype, "message", {
	        get: function () { return ''; },
	        enumerable: true,
	        configurable: true
	    });
	    return BaseWrappedException;
	}(Error));
	exports.BaseWrappedException = BaseWrappedException;


/***/ },
/* 14 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var base_wrapped_exception_1 = __webpack_require__(13);
	var collection_1 = __webpack_require__(15);
	var _ArrayLogger = (function () {
	    function _ArrayLogger() {
	        this.res = [];
	    }
	    _ArrayLogger.prototype.log = function (s) { this.res.push(s); };
	    _ArrayLogger.prototype.logError = function (s) { this.res.push(s); };
	    _ArrayLogger.prototype.logGroup = function (s) { this.res.push(s); };
	    _ArrayLogger.prototype.logGroupEnd = function () { };
	    ;
	    return _ArrayLogger;
	}());
	/**
	 * Provides a hook for centralized exception handling.
	 *
	 * The default implementation of `ExceptionHandler` prints error messages to the `Console`. To
	 * intercept error handling,
	 * write a custom exception handler that replaces this default as appropriate for your app.
	 *
	 * ### Example
	 *
	 * ```javascript
	 *
	 * class MyExceptionHandler implements ExceptionHandler {
	 *   call(error, stackTrace = null, reason = null) {
	 *     // do something with the exception
	 *   }
	 * }
	 *
	 * bootstrap(MyApp, [provide(ExceptionHandler, {useClass: MyExceptionHandler})])
	 *
	 * ```
	 */
	var ExceptionHandler = (function () {
	    function ExceptionHandler(_logger, _rethrowException) {
	        if (_rethrowException === void 0) { _rethrowException = true; }
	        this._logger = _logger;
	        this._rethrowException = _rethrowException;
	    }
	    ExceptionHandler.exceptionToString = function (exception, stackTrace, reason) {
	        if (stackTrace === void 0) { stackTrace = null; }
	        if (reason === void 0) { reason = null; }
	        var l = new _ArrayLogger();
	        var e = new ExceptionHandler(l, false);
	        e.call(exception, stackTrace, reason);
	        return l.res.join("\n");
	    };
	    ExceptionHandler.prototype.call = function (exception, stackTrace, reason) {
	        if (stackTrace === void 0) { stackTrace = null; }
	        if (reason === void 0) { reason = null; }
	        var originalException = this._findOriginalException(exception);
	        var originalStack = this._findOriginalStack(exception);
	        var context = this._findContext(exception);
	        this._logger.logGroup("EXCEPTION: " + this._extractMessage(exception));
	        if (lang_1.isPresent(stackTrace) && lang_1.isBlank(originalStack)) {
	            this._logger.logError("STACKTRACE:");
	            this._logger.logError(this._longStackTrace(stackTrace));
	        }
	        if (lang_1.isPresent(reason)) {
	            this._logger.logError("REASON: " + reason);
	        }
	        if (lang_1.isPresent(originalException)) {
	            this._logger.logError("ORIGINAL EXCEPTION: " + this._extractMessage(originalException));
	        }
	        if (lang_1.isPresent(originalStack)) {
	            this._logger.logError("ORIGINAL STACKTRACE:");
	            this._logger.logError(this._longStackTrace(originalStack));
	        }
	        if (lang_1.isPresent(context)) {
	            this._logger.logError("ERROR CONTEXT:");
	            this._logger.logError(context);
	        }
	        this._logger.logGroupEnd();
	        // We rethrow exceptions, so operations like 'bootstrap' will result in an error
	        // when an exception happens. If we do not rethrow, bootstrap will always succeed.
	        if (this._rethrowException)
	            throw exception;
	    };
	    /** @internal */
	    ExceptionHandler.prototype._extractMessage = function (exception) {
	        return exception instanceof base_wrapped_exception_1.BaseWrappedException ? exception.wrapperMessage :
	            exception.toString();
	    };
	    /** @internal */
	    ExceptionHandler.prototype._longStackTrace = function (stackTrace) {
	        return collection_1.isListLikeIterable(stackTrace) ? stackTrace.join("\n\n-----async gap-----\n") :
	            stackTrace.toString();
	    };
	    /** @internal */
	    ExceptionHandler.prototype._findContext = function (exception) {
	        try {
	            if (!(exception instanceof base_wrapped_exception_1.BaseWrappedException))
	                return null;
	            return lang_1.isPresent(exception.context) ? exception.context :
	                this._findContext(exception.originalException);
	        }
	        catch (e) {
	            // exception.context can throw an exception. if it happens, we ignore the context.
	            return null;
	        }
	    };
	    /** @internal */
	    ExceptionHandler.prototype._findOriginalException = function (exception) {
	        if (!(exception instanceof base_wrapped_exception_1.BaseWrappedException))
	            return null;
	        var e = exception.originalException;
	        while (e instanceof base_wrapped_exception_1.BaseWrappedException && lang_1.isPresent(e.originalException)) {
	            e = e.originalException;
	        }
	        return e;
	    };
	    /** @internal */
	    ExceptionHandler.prototype._findOriginalStack = function (exception) {
	        if (!(exception instanceof base_wrapped_exception_1.BaseWrappedException))
	            return null;
	        var e = exception;
	        var stack = exception.originalStack;
	        while (e instanceof base_wrapped_exception_1.BaseWrappedException && lang_1.isPresent(e.originalException)) {
	            e = e.originalException;
	            if (e instanceof base_wrapped_exception_1.BaseWrappedException && lang_1.isPresent(e.originalException)) {
	                stack = e.originalStack;
	            }
	        }
	        return stack;
	    };
	    return ExceptionHandler;
	}());
	exports.ExceptionHandler = ExceptionHandler;


/***/ },
/* 15 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	exports.Map = lang_1.global.Map;
	exports.Set = lang_1.global.Set;
	// Safari and Internet Explorer do not support the iterable parameter to the
	// Map constructor.  We work around that by manually adding the items.
	var createMapFromPairs = (function () {
	    try {
	        if (new exports.Map([[1, 2]]).size === 1) {
	            return function createMapFromPairs(pairs) { return new exports.Map(pairs); };
	        }
	    }
	    catch (e) {
	    }
	    return function createMapAndPopulateFromPairs(pairs) {
	        var map = new exports.Map();
	        for (var i = 0; i < pairs.length; i++) {
	            var pair = pairs[i];
	            map.set(pair[0], pair[1]);
	        }
	        return map;
	    };
	})();
	var createMapFromMap = (function () {
	    try {
	        if (new exports.Map(new exports.Map())) {
	            return function createMapFromMap(m) { return new exports.Map(m); };
	        }
	    }
	    catch (e) {
	    }
	    return function createMapAndPopulateFromMap(m) {
	        var map = new exports.Map();
	        m.forEach(function (v, k) { map.set(k, v); });
	        return map;
	    };
	})();
	var _clearValues = (function () {
	    if ((new exports.Map()).keys().next) {
	        return function _clearValues(m) {
	            var keyIterator = m.keys();
	            var k;
	            while (!((k = keyIterator.next()).done)) {
	                m.set(k.value, null);
	            }
	        };
	    }
	    else {
	        return function _clearValuesWithForeEach(m) {
	            m.forEach(function (v, k) { m.set(k, null); });
	        };
	    }
	})();
	// Safari doesn't implement MapIterator.next(), which is used is Traceur's polyfill of Array.from
	// TODO(mlaval): remove the work around once we have a working polyfill of Array.from
	var _arrayFromMap = (function () {
	    try {
	        if ((new exports.Map()).values().next) {
	            return function createArrayFromMap(m, getValues) {
	                return getValues ? Array.from(m.values()) : Array.from(m.keys());
	            };
	        }
	    }
	    catch (e) {
	    }
	    return function createArrayFromMapWithForeach(m, getValues) {
	        var res = ListWrapper.createFixedSize(m.size), i = 0;
	        m.forEach(function (v, k) {
	            res[i] = getValues ? v : k;
	            i++;
	        });
	        return res;
	    };
	})();
	var MapWrapper = (function () {
	    function MapWrapper() {
	    }
	    MapWrapper.clone = function (m) { return createMapFromMap(m); };
	    MapWrapper.createFromStringMap = function (stringMap) {
	        var result = new exports.Map();
	        for (var prop in stringMap) {
	            result.set(prop, stringMap[prop]);
	        }
	        return result;
	    };
	    MapWrapper.toStringMap = function (m) {
	        var r = {};
	        m.forEach(function (v, k) { return r[k] = v; });
	        return r;
	    };
	    MapWrapper.createFromPairs = function (pairs) { return createMapFromPairs(pairs); };
	    MapWrapper.clearValues = function (m) { _clearValues(m); };
	    MapWrapper.iterable = function (m) { return m; };
	    MapWrapper.keys = function (m) { return _arrayFromMap(m, false); };
	    MapWrapper.values = function (m) { return _arrayFromMap(m, true); };
	    return MapWrapper;
	}());
	exports.MapWrapper = MapWrapper;
	/**
	 * Wraps Javascript Objects
	 */
	var StringMapWrapper = (function () {
	    function StringMapWrapper() {
	    }
	    StringMapWrapper.create = function () {
	        // Note: We are not using Object.create(null) here due to
	        // performance!
	        // http://jsperf.com/ng2-object-create-null
	        return {};
	    };
	    StringMapWrapper.contains = function (map, key) {
	        return map.hasOwnProperty(key);
	    };
	    StringMapWrapper.get = function (map, key) {
	        return map.hasOwnProperty(key) ? map[key] : undefined;
	    };
	    StringMapWrapper.set = function (map, key, value) { map[key] = value; };
	    StringMapWrapper.keys = function (map) { return Object.keys(map); };
	    StringMapWrapper.values = function (map) {
	        return Object.keys(map).reduce(function (r, a) {
	            r.push(map[a]);
	            return r;
	        }, []);
	    };
	    StringMapWrapper.isEmpty = function (map) {
	        for (var prop in map) {
	            return false;
	        }
	        return true;
	    };
	    StringMapWrapper.delete = function (map, key) { delete map[key]; };
	    StringMapWrapper.forEach = function (map, callback) {
	        for (var prop in map) {
	            if (map.hasOwnProperty(prop)) {
	                callback(map[prop], prop);
	            }
	        }
	    };
	    StringMapWrapper.merge = function (m1, m2) {
	        var m = {};
	        for (var attr in m1) {
	            if (m1.hasOwnProperty(attr)) {
	                m[attr] = m1[attr];
	            }
	        }
	        for (var attr in m2) {
	            if (m2.hasOwnProperty(attr)) {
	                m[attr] = m2[attr];
	            }
	        }
	        return m;
	    };
	    StringMapWrapper.equals = function (m1, m2) {
	        var k1 = Object.keys(m1);
	        var k2 = Object.keys(m2);
	        if (k1.length != k2.length) {
	            return false;
	        }
	        var key;
	        for (var i = 0; i < k1.length; i++) {
	            key = k1[i];
	            if (m1[key] !== m2[key]) {
	                return false;
	            }
	        }
	        return true;
	    };
	    return StringMapWrapper;
	}());
	exports.StringMapWrapper = StringMapWrapper;
	var ListWrapper = (function () {
	    function ListWrapper() {
	    }
	    // JS has no way to express a statically fixed size list, but dart does so we
	    // keep both methods.
	    ListWrapper.createFixedSize = function (size) { return new Array(size); };
	    ListWrapper.createGrowableSize = function (size) { return new Array(size); };
	    ListWrapper.clone = function (array) { return array.slice(0); };
	    ListWrapper.forEachWithIndex = function (array, fn) {
	        for (var i = 0; i < array.length; i++) {
	            fn(array[i], i);
	        }
	    };
	    ListWrapper.first = function (array) {
	        if (!array)
	            return null;
	        return array[0];
	    };
	    ListWrapper.last = function (array) {
	        if (!array || array.length == 0)
	            return null;
	        return array[array.length - 1];
	    };
	    ListWrapper.indexOf = function (array, value, startIndex) {
	        if (startIndex === void 0) { startIndex = 0; }
	        return array.indexOf(value, startIndex);
	    };
	    ListWrapper.contains = function (list, el) { return list.indexOf(el) !== -1; };
	    ListWrapper.reversed = function (array) {
	        var a = ListWrapper.clone(array);
	        return a.reverse();
	    };
	    ListWrapper.concat = function (a, b) { return a.concat(b); };
	    ListWrapper.insert = function (list, index, value) { list.splice(index, 0, value); };
	    ListWrapper.removeAt = function (list, index) {
	        var res = list[index];
	        list.splice(index, 1);
	        return res;
	    };
	    ListWrapper.removeAll = function (list, items) {
	        for (var i = 0; i < items.length; ++i) {
	            var index = list.indexOf(items[i]);
	            list.splice(index, 1);
	        }
	    };
	    ListWrapper.remove = function (list, el) {
	        var index = list.indexOf(el);
	        if (index > -1) {
	            list.splice(index, 1);
	            return true;
	        }
	        return false;
	    };
	    ListWrapper.clear = function (list) { list.length = 0; };
	    ListWrapper.isEmpty = function (list) { return list.length == 0; };
	    ListWrapper.fill = function (list, value, start, end) {
	        if (start === void 0) { start = 0; }
	        if (end === void 0) { end = null; }
	        list.fill(value, start, end === null ? list.length : end);
	    };
	    ListWrapper.equals = function (a, b) {
	        if (a.length != b.length)
	            return false;
	        for (var i = 0; i < a.length; ++i) {
	            if (a[i] !== b[i])
	                return false;
	        }
	        return true;
	    };
	    ListWrapper.slice = function (l, from, to) {
	        if (from === void 0) { from = 0; }
	        if (to === void 0) { to = null; }
	        return l.slice(from, to === null ? undefined : to);
	    };
	    ListWrapper.splice = function (l, from, length) { return l.splice(from, length); };
	    ListWrapper.sort = function (l, compareFn) {
	        if (lang_1.isPresent(compareFn)) {
	            l.sort(compareFn);
	        }
	        else {
	            l.sort();
	        }
	    };
	    ListWrapper.toString = function (l) { return l.toString(); };
	    ListWrapper.toJSON = function (l) { return JSON.stringify(l); };
	    ListWrapper.maximum = function (list, predicate) {
	        if (list.length == 0) {
	            return null;
	        }
	        var solution = null;
	        var maxValue = -Infinity;
	        for (var index = 0; index < list.length; index++) {
	            var candidate = list[index];
	            if (lang_1.isBlank(candidate)) {
	                continue;
	            }
	            var candidateValue = predicate(candidate);
	            if (candidateValue > maxValue) {
	                solution = candidate;
	                maxValue = candidateValue;
	            }
	        }
	        return solution;
	    };
	    ListWrapper.flatten = function (list) {
	        var target = [];
	        _flattenArray(list, target);
	        return target;
	    };
	    ListWrapper.addAll = function (list, source) {
	        for (var i = 0; i < source.length; i++) {
	            list.push(source[i]);
	        }
	    };
	    return ListWrapper;
	}());
	exports.ListWrapper = ListWrapper;
	function _flattenArray(source, target) {
	    if (lang_1.isPresent(source)) {
	        for (var i = 0; i < source.length; i++) {
	            var item = source[i];
	            if (lang_1.isArray(item)) {
	                _flattenArray(item, target);
	            }
	            else {
	                target.push(item);
	            }
	        }
	    }
	    return target;
	}
	function isListLikeIterable(obj) {
	    if (!lang_1.isJsObject(obj))
	        return false;
	    return lang_1.isArray(obj) ||
	        (!(obj instanceof exports.Map) &&
	            lang_1.getSymbolIterator() in obj); // JS Iterable have a Symbol.iterator prop
	}
	exports.isListLikeIterable = isListLikeIterable;
	function areIterablesEqual(a, b, comparator) {
	    var iterator1 = a[lang_1.getSymbolIterator()]();
	    var iterator2 = b[lang_1.getSymbolIterator()]();
	    while (true) {
	        var item1 = iterator1.next();
	        var item2 = iterator2.next();
	        if (item1.done && item2.done)
	            return true;
	        if (item1.done || item2.done)
	            return false;
	        if (!comparator(item1.value, item2.value))
	            return false;
	    }
	}
	exports.areIterablesEqual = areIterablesEqual;
	function iterateListLike(obj, fn) {
	    if (lang_1.isArray(obj)) {
	        for (var i = 0; i < obj.length; i++) {
	            fn(obj[i]);
	        }
	    }
	    else {
	        var iterator = obj[lang_1.getSymbolIterator()]();
	        var item;
	        while (!((item = iterator.next()).done)) {
	            fn(item.value);
	        }
	    }
	}
	exports.iterateListLike = iterateListLike;
	// Safari and Internet Explorer do not support the iterable parameter to the
	// Set constructor.  We work around that by manually adding the items.
	var createSetFromList = (function () {
	    var test = new exports.Set([1, 2, 3]);
	    if (test.size === 3) {
	        return function createSetFromList(lst) { return new exports.Set(lst); };
	    }
	    else {
	        return function createSetAndPopulateFromList(lst) {
	            var res = new exports.Set(lst);
	            if (res.size !== lst.length) {
	                for (var i = 0; i < lst.length; i++) {
	                    res.add(lst[i]);
	                }
	            }
	            return res;
	        };
	    }
	})();
	var SetWrapper = (function () {
	    function SetWrapper() {
	    }
	    SetWrapper.createFromList = function (lst) { return createSetFromList(lst); };
	    SetWrapper.has = function (s, key) { return s.has(key); };
	    SetWrapper.delete = function (m, k) { m.delete(k); };
	    return SetWrapper;
	}());
	exports.SetWrapper = SetWrapper;


/***/ },
/* 16 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var collection_1 = __webpack_require__(15);
	var reflective_provider_1 = __webpack_require__(17);
	var reflective_exceptions_1 = __webpack_require__(23);
	var exceptions_1 = __webpack_require__(12);
	var reflective_key_1 = __webpack_require__(22);
	var metadata_1 = __webpack_require__(7);
	var injector_1 = __webpack_require__(11);
	var __unused; // avoid unused import when Type union types are erased
	// Threshold for the dynamic version
	var _MAX_CONSTRUCTION_COUNTER = 10;
	var UNDEFINED = new Object();
	var ReflectiveProtoInjectorInlineStrategy = (function () {
	    function ReflectiveProtoInjectorInlineStrategy(protoEI, providers) {
	        this.provider0 = null;
	        this.provider1 = null;
	        this.provider2 = null;
	        this.provider3 = null;
	        this.provider4 = null;
	        this.provider5 = null;
	        this.provider6 = null;
	        this.provider7 = null;
	        this.provider8 = null;
	        this.provider9 = null;
	        this.keyId0 = null;
	        this.keyId1 = null;
	        this.keyId2 = null;
	        this.keyId3 = null;
	        this.keyId4 = null;
	        this.keyId5 = null;
	        this.keyId6 = null;
	        this.keyId7 = null;
	        this.keyId8 = null;
	        this.keyId9 = null;
	        var length = providers.length;
	        if (length > 0) {
	            this.provider0 = providers[0];
	            this.keyId0 = providers[0].key.id;
	        }
	        if (length > 1) {
	            this.provider1 = providers[1];
	            this.keyId1 = providers[1].key.id;
	        }
	        if (length > 2) {
	            this.provider2 = providers[2];
	            this.keyId2 = providers[2].key.id;
	        }
	        if (length > 3) {
	            this.provider3 = providers[3];
	            this.keyId3 = providers[3].key.id;
	        }
	        if (length > 4) {
	            this.provider4 = providers[4];
	            this.keyId4 = providers[4].key.id;
	        }
	        if (length > 5) {
	            this.provider5 = providers[5];
	            this.keyId5 = providers[5].key.id;
	        }
	        if (length > 6) {
	            this.provider6 = providers[6];
	            this.keyId6 = providers[6].key.id;
	        }
	        if (length > 7) {
	            this.provider7 = providers[7];
	            this.keyId7 = providers[7].key.id;
	        }
	        if (length > 8) {
	            this.provider8 = providers[8];
	            this.keyId8 = providers[8].key.id;
	        }
	        if (length > 9) {
	            this.provider9 = providers[9];
	            this.keyId9 = providers[9].key.id;
	        }
	    }
	    ReflectiveProtoInjectorInlineStrategy.prototype.getProviderAtIndex = function (index) {
	        if (index == 0)
	            return this.provider0;
	        if (index == 1)
	            return this.provider1;
	        if (index == 2)
	            return this.provider2;
	        if (index == 3)
	            return this.provider3;
	        if (index == 4)
	            return this.provider4;
	        if (index == 5)
	            return this.provider5;
	        if (index == 6)
	            return this.provider6;
	        if (index == 7)
	            return this.provider7;
	        if (index == 8)
	            return this.provider8;
	        if (index == 9)
	            return this.provider9;
	        throw new reflective_exceptions_1.OutOfBoundsError(index);
	    };
	    ReflectiveProtoInjectorInlineStrategy.prototype.createInjectorStrategy = function (injector) {
	        return new ReflectiveInjectorInlineStrategy(injector, this);
	    };
	    return ReflectiveProtoInjectorInlineStrategy;
	}());
	exports.ReflectiveProtoInjectorInlineStrategy = ReflectiveProtoInjectorInlineStrategy;
	var ReflectiveProtoInjectorDynamicStrategy = (function () {
	    function ReflectiveProtoInjectorDynamicStrategy(protoInj, providers) {
	        this.providers = providers;
	        var len = providers.length;
	        this.keyIds = collection_1.ListWrapper.createFixedSize(len);
	        for (var i = 0; i < len; i++) {
	            this.keyIds[i] = providers[i].key.id;
	        }
	    }
	    ReflectiveProtoInjectorDynamicStrategy.prototype.getProviderAtIndex = function (index) {
	        if (index < 0 || index >= this.providers.length) {
	            throw new reflective_exceptions_1.OutOfBoundsError(index);
	        }
	        return this.providers[index];
	    };
	    ReflectiveProtoInjectorDynamicStrategy.prototype.createInjectorStrategy = function (ei) {
	        return new ReflectiveInjectorDynamicStrategy(this, ei);
	    };
	    return ReflectiveProtoInjectorDynamicStrategy;
	}());
	exports.ReflectiveProtoInjectorDynamicStrategy = ReflectiveProtoInjectorDynamicStrategy;
	var ReflectiveProtoInjector = (function () {
	    function ReflectiveProtoInjector(providers) {
	        this.numberOfProviders = providers.length;
	        this._strategy = providers.length > _MAX_CONSTRUCTION_COUNTER ?
	            new ReflectiveProtoInjectorDynamicStrategy(this, providers) :
	            new ReflectiveProtoInjectorInlineStrategy(this, providers);
	    }
	    ReflectiveProtoInjector.fromResolvedProviders = function (providers) {
	        return new ReflectiveProtoInjector(providers);
	    };
	    ReflectiveProtoInjector.prototype.getProviderAtIndex = function (index) {
	        return this._strategy.getProviderAtIndex(index);
	    };
	    return ReflectiveProtoInjector;
	}());
	exports.ReflectiveProtoInjector = ReflectiveProtoInjector;
	var ReflectiveInjectorInlineStrategy = (function () {
	    function ReflectiveInjectorInlineStrategy(injector, protoStrategy) {
	        this.injector = injector;
	        this.protoStrategy = protoStrategy;
	        this.obj0 = UNDEFINED;
	        this.obj1 = UNDEFINED;
	        this.obj2 = UNDEFINED;
	        this.obj3 = UNDEFINED;
	        this.obj4 = UNDEFINED;
	        this.obj5 = UNDEFINED;
	        this.obj6 = UNDEFINED;
	        this.obj7 = UNDEFINED;
	        this.obj8 = UNDEFINED;
	        this.obj9 = UNDEFINED;
	    }
	    ReflectiveInjectorInlineStrategy.prototype.resetConstructionCounter = function () { this.injector._constructionCounter = 0; };
	    ReflectiveInjectorInlineStrategy.prototype.instantiateProvider = function (provider) {
	        return this.injector._new(provider);
	    };
	    ReflectiveInjectorInlineStrategy.prototype.getObjByKeyId = function (keyId) {
	        var p = this.protoStrategy;
	        var inj = this.injector;
	        if (p.keyId0 === keyId) {
	            if (this.obj0 === UNDEFINED) {
	                this.obj0 = inj._new(p.provider0);
	            }
	            return this.obj0;
	        }
	        if (p.keyId1 === keyId) {
	            if (this.obj1 === UNDEFINED) {
	                this.obj1 = inj._new(p.provider1);
	            }
	            return this.obj1;
	        }
	        if (p.keyId2 === keyId) {
	            if (this.obj2 === UNDEFINED) {
	                this.obj2 = inj._new(p.provider2);
	            }
	            return this.obj2;
	        }
	        if (p.keyId3 === keyId) {
	            if (this.obj3 === UNDEFINED) {
	                this.obj3 = inj._new(p.provider3);
	            }
	            return this.obj3;
	        }
	        if (p.keyId4 === keyId) {
	            if (this.obj4 === UNDEFINED) {
	                this.obj4 = inj._new(p.provider4);
	            }
	            return this.obj4;
	        }
	        if (p.keyId5 === keyId) {
	            if (this.obj5 === UNDEFINED) {
	                this.obj5 = inj._new(p.provider5);
	            }
	            return this.obj5;
	        }
	        if (p.keyId6 === keyId) {
	            if (this.obj6 === UNDEFINED) {
	                this.obj6 = inj._new(p.provider6);
	            }
	            return this.obj6;
	        }
	        if (p.keyId7 === keyId) {
	            if (this.obj7 === UNDEFINED) {
	                this.obj7 = inj._new(p.provider7);
	            }
	            return this.obj7;
	        }
	        if (p.keyId8 === keyId) {
	            if (this.obj8 === UNDEFINED) {
	                this.obj8 = inj._new(p.provider8);
	            }
	            return this.obj8;
	        }
	        if (p.keyId9 === keyId) {
	            if (this.obj9 === UNDEFINED) {
	                this.obj9 = inj._new(p.provider9);
	            }
	            return this.obj9;
	        }
	        return UNDEFINED;
	    };
	    ReflectiveInjectorInlineStrategy.prototype.getObjAtIndex = function (index) {
	        if (index == 0)
	            return this.obj0;
	        if (index == 1)
	            return this.obj1;
	        if (index == 2)
	            return this.obj2;
	        if (index == 3)
	            return this.obj3;
	        if (index == 4)
	            return this.obj4;
	        if (index == 5)
	            return this.obj5;
	        if (index == 6)
	            return this.obj6;
	        if (index == 7)
	            return this.obj7;
	        if (index == 8)
	            return this.obj8;
	        if (index == 9)
	            return this.obj9;
	        throw new reflective_exceptions_1.OutOfBoundsError(index);
	    };
	    ReflectiveInjectorInlineStrategy.prototype.getMaxNumberOfObjects = function () { return _MAX_CONSTRUCTION_COUNTER; };
	    return ReflectiveInjectorInlineStrategy;
	}());
	exports.ReflectiveInjectorInlineStrategy = ReflectiveInjectorInlineStrategy;
	var ReflectiveInjectorDynamicStrategy = (function () {
	    function ReflectiveInjectorDynamicStrategy(protoStrategy, injector) {
	        this.protoStrategy = protoStrategy;
	        this.injector = injector;
	        this.objs = collection_1.ListWrapper.createFixedSize(protoStrategy.providers.length);
	        collection_1.ListWrapper.fill(this.objs, UNDEFINED);
	    }
	    ReflectiveInjectorDynamicStrategy.prototype.resetConstructionCounter = function () { this.injector._constructionCounter = 0; };
	    ReflectiveInjectorDynamicStrategy.prototype.instantiateProvider = function (provider) {
	        return this.injector._new(provider);
	    };
	    ReflectiveInjectorDynamicStrategy.prototype.getObjByKeyId = function (keyId) {
	        var p = this.protoStrategy;
	        for (var i = 0; i < p.keyIds.length; i++) {
	            if (p.keyIds[i] === keyId) {
	                if (this.objs[i] === UNDEFINED) {
	                    this.objs[i] = this.injector._new(p.providers[i]);
	                }
	                return this.objs[i];
	            }
	        }
	        return UNDEFINED;
	    };
	    ReflectiveInjectorDynamicStrategy.prototype.getObjAtIndex = function (index) {
	        if (index < 0 || index >= this.objs.length) {
	            throw new reflective_exceptions_1.OutOfBoundsError(index);
	        }
	        return this.objs[index];
	    };
	    ReflectiveInjectorDynamicStrategy.prototype.getMaxNumberOfObjects = function () { return this.objs.length; };
	    return ReflectiveInjectorDynamicStrategy;
	}());
	exports.ReflectiveInjectorDynamicStrategy = ReflectiveInjectorDynamicStrategy;
	/**
	 * A ReflectiveDependency injection container used for instantiating objects and resolving
	 * dependencies.
	 *
	 * An `Injector` is a replacement for a `new` operator, which can automatically resolve the
	 * constructor dependencies.
	 *
	 * In typical use, application code asks for the dependencies in the constructor and they are
	 * resolved by the `Injector`.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/jzjec0?p=preview))
	 *
	 * The following example creates an `Injector` configured to create `Engine` and `Car`.
	 *
	 * ```typescript
	 * @Injectable()
	 * class Engine {
	 * }
	 *
	 * @Injectable()
	 * class Car {
	 *   constructor(public engine:Engine) {}
	 * }
	 *
	 * var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
	 * var car = injector.get(Car);
	 * expect(car instanceof Car).toBe(true);
	 * expect(car.engine instanceof Engine).toBe(true);
	 * ```
	 *
	 * Notice, we don't use the `new` operator because we explicitly want to have the `Injector`
	 * resolve all of the object's dependencies automatically.
	 */
	var ReflectiveInjector = (function () {
	    function ReflectiveInjector() {
	    }
	    /**
	     * Turns an array of provider definitions into an array of resolved providers.
	     *
	     * A resolution is a process of flattening multiple nested arrays and converting individual
	     * providers into an array of {@link ResolvedReflectiveProvider}s.
	     *
	     * ### Example ([live demo](http://plnkr.co/edit/AiXTHi?p=preview))
	     *
	     * ```typescript
	     * @Injectable()
	     * class Engine {
	     * }
	     *
	     * @Injectable()
	     * class Car {
	     *   constructor(public engine:Engine) {}
	     * }
	     *
	     * var providers = ReflectiveInjector.resolve([Car, [[Engine]]]);
	     *
	     * expect(providers.length).toEqual(2);
	     *
	     * expect(providers[0] instanceof ResolvedReflectiveProvider).toBe(true);
	     * expect(providers[0].key.displayName).toBe("Car");
	     * expect(providers[0].dependencies.length).toEqual(1);
	     * expect(providers[0].factory).toBeDefined();
	     *
	     * expect(providers[1].key.displayName).toBe("Engine");
	     * });
	     * ```
	     *
	     * See {@link ReflectiveInjector#fromResolvedProviders} for more info.
	     */
	    ReflectiveInjector.resolve = function (providers) {
	        return reflective_provider_1.resolveReflectiveProviders(providers);
	    };
	    /**
	     * Resolves an array of providers and creates an injector from those providers.
	     *
	     * The passed-in providers can be an array of `Type`, {@link Provider},
	     * or a recursive array of more providers.
	     *
	     * ### Example ([live demo](http://plnkr.co/edit/ePOccA?p=preview))
	     *
	     * ```typescript
	     * @Injectable()
	     * class Engine {
	     * }
	     *
	     * @Injectable()
	     * class Car {
	     *   constructor(public engine:Engine) {}
	     * }
	     *
	     * var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
	     * expect(injector.get(Car) instanceof Car).toBe(true);
	     * ```
	     *
	     * This function is slower than the corresponding `fromResolvedProviders`
	     * because it needs to resolve the passed-in providers first.
	     * See {@link Injector#resolve} and {@link Injector#fromResolvedProviders}.
	     */
	    ReflectiveInjector.resolveAndCreate = function (providers, parent) {
	        if (parent === void 0) { parent = null; }
	        var ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
	        return ReflectiveInjector.fromResolvedProviders(ResolvedReflectiveProviders, parent);
	    };
	    /**
	     * Creates an injector from previously resolved providers.
	     *
	     * This API is the recommended way to construct injectors in performance-sensitive parts.
	     *
	     * ### Example ([live demo](http://plnkr.co/edit/KrSMci?p=preview))
	     *
	     * ```typescript
	     * @Injectable()
	     * class Engine {
	     * }
	     *
	     * @Injectable()
	     * class Car {
	     *   constructor(public engine:Engine) {}
	     * }
	     *
	     * var providers = ReflectiveInjector.resolve([Car, Engine]);
	     * var injector = ReflectiveInjector.fromResolvedProviders(providers);
	     * expect(injector.get(Car) instanceof Car).toBe(true);
	     * ```
	     */
	    ReflectiveInjector.fromResolvedProviders = function (providers, parent) {
	        if (parent === void 0) { parent = null; }
	        return new ReflectiveInjector_(ReflectiveProtoInjector.fromResolvedProviders(providers), parent);
	    };
	    /**
	     * @deprecated
	     */
	    ReflectiveInjector.fromResolvedBindings = function (providers) {
	        return ReflectiveInjector.fromResolvedProviders(providers);
	    };
	    Object.defineProperty(ReflectiveInjector.prototype, "parent", {
	        /**
	         * Parent of this injector.
	         *
	         * <!-- TODO: Add a link to the section of the user guide talking about hierarchical injection.
	         * -->
	         *
	         * ### Example ([live demo](http://plnkr.co/edit/eosMGo?p=preview))
	         *
	         * ```typescript
	         * var parent = ReflectiveInjector.resolveAndCreate([]);
	         * var child = parent.resolveAndCreateChild([]);
	         * expect(child.parent).toBe(parent);
	         * ```
	         */
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    /**
	     * @internal
	     */
	    ReflectiveInjector.prototype.debugContext = function () { return null; };
	    /**
	     * Resolves an array of providers and creates a child injector from those providers.
	     *
	     * <!-- TODO: Add a link to the section of the user guide talking about hierarchical injection.
	     * -->
	     *
	     * The passed-in providers can be an array of `Type`, {@link Provider},
	     * or a recursive array of more providers.
	     *
	     * ### Example ([live demo](http://plnkr.co/edit/opB3T4?p=preview))
	     *
	     * ```typescript
	     * class ParentProvider {}
	     * class ChildProvider {}
	     *
	     * var parent = ReflectiveInjector.resolveAndCreate([ParentProvider]);
	     * var child = parent.resolveAndCreateChild([ChildProvider]);
	     *
	     * expect(child.get(ParentProvider) instanceof ParentProvider).toBe(true);
	     * expect(child.get(ChildProvider) instanceof ChildProvider).toBe(true);
	     * expect(child.get(ParentProvider)).toBe(parent.get(ParentProvider));
	     * ```
	     *
	     * This function is slower than the corresponding `createChildFromResolved`
	     * because it needs to resolve the passed-in providers first.
	     * See {@link Injector#resolve} and {@link Injector#createChildFromResolved}.
	     */
	    ReflectiveInjector.prototype.resolveAndCreateChild = function (providers) {
	        return exceptions_1.unimplemented();
	    };
	    /**
	     * Creates a child injector from previously resolved providers.
	     *
	     * <!-- TODO: Add a link to the section of the user guide talking about hierarchical injection.
	     * -->
	     *
	     * This API is the recommended way to construct injectors in performance-sensitive parts.
	     *
	     * ### Example ([live demo](http://plnkr.co/edit/VhyfjN?p=preview))
	     *
	     * ```typescript
	     * class ParentProvider {}
	     * class ChildProvider {}
	     *
	     * var parentProviders = ReflectiveInjector.resolve([ParentProvider]);
	     * var childProviders = ReflectiveInjector.resolve([ChildProvider]);
	     *
	     * var parent = ReflectiveInjector.fromResolvedProviders(parentProviders);
	     * var child = parent.createChildFromResolved(childProviders);
	     *
	     * expect(child.get(ParentProvider) instanceof ParentProvider).toBe(true);
	     * expect(child.get(ChildProvider) instanceof ChildProvider).toBe(true);
	     * expect(child.get(ParentProvider)).toBe(parent.get(ParentProvider));
	     * ```
	     */
	    ReflectiveInjector.prototype.createChildFromResolved = function (providers) {
	        return exceptions_1.unimplemented();
	    };
	    /**
	     * Resolves a provider and instantiates an object in the context of the injector.
	     *
	     * The created object does not get cached by the injector.
	     *
	     * ### Example ([live demo](http://plnkr.co/edit/yvVXoB?p=preview))
	     *
	     * ```typescript
	     * @Injectable()
	     * class Engine {
	     * }
	     *
	     * @Injectable()
	     * class Car {
	     *   constructor(public engine:Engine) {}
	     * }
	     *
	     * var injector = ReflectiveInjector.resolveAndCreate([Engine]);
	     *
	     * var car = injector.resolveAndInstantiate(Car);
	     * expect(car.engine).toBe(injector.get(Engine));
	     * expect(car).not.toBe(injector.resolveAndInstantiate(Car));
	     * ```
	     */
	    ReflectiveInjector.prototype.resolveAndInstantiate = function (provider) { return exceptions_1.unimplemented(); };
	    /**
	     * Instantiates an object using a resolved provider in the context of the injector.
	     *
	     * The created object does not get cached by the injector.
	     *
	     * ### Example ([live demo](http://plnkr.co/edit/ptCImQ?p=preview))
	     *
	     * ```typescript
	     * @Injectable()
	     * class Engine {
	     * }
	     *
	     * @Injectable()
	     * class Car {
	     *   constructor(public engine:Engine) {}
	     * }
	     *
	     * var injector = ReflectiveInjector.resolveAndCreate([Engine]);
	     * var carProvider = ReflectiveInjector.resolve([Car])[0];
	     * var car = injector.instantiateResolved(carProvider);
	     * expect(car.engine).toBe(injector.get(Engine));
	     * expect(car).not.toBe(injector.instantiateResolved(carProvider));
	     * ```
	     */
	    ReflectiveInjector.prototype.instantiateResolved = function (provider) { return exceptions_1.unimplemented(); };
	    return ReflectiveInjector;
	}());
	exports.ReflectiveInjector = ReflectiveInjector;
	var ReflectiveInjector_ = (function () {
	    /**
	     * Private
	     */
	    function ReflectiveInjector_(_proto /* ProtoInjector */, _parent, _debugContext) {
	        if (_parent === void 0) { _parent = null; }
	        if (_debugContext === void 0) { _debugContext = null; }
	        this._debugContext = _debugContext;
	        /** @internal */
	        this._constructionCounter = 0;
	        this._proto = _proto;
	        this._parent = _parent;
	        this._strategy = _proto._strategy.createInjectorStrategy(this);
	    }
	    /**
	     * @internal
	     */
	    ReflectiveInjector_.prototype.debugContext = function () { return this._debugContext(); };
	    ReflectiveInjector_.prototype.get = function (token, notFoundValue) {
	        if (notFoundValue === void 0) { notFoundValue = injector_1.THROW_IF_NOT_FOUND; }
	        return this._getByKey(reflective_key_1.ReflectiveKey.get(token), null, null, notFoundValue);
	    };
	    ReflectiveInjector_.prototype.getAt = function (index) { return this._strategy.getObjAtIndex(index); };
	    Object.defineProperty(ReflectiveInjector_.prototype, "parent", {
	        get: function () { return this._parent; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ReflectiveInjector_.prototype, "internalStrategy", {
	        /**
	         * @internal
	         * Internal. Do not use.
	         * We return `any` not to export the InjectorStrategy type.
	         */
	        get: function () { return this._strategy; },
	        enumerable: true,
	        configurable: true
	    });
	    ReflectiveInjector_.prototype.resolveAndCreateChild = function (providers) {
	        var ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
	        return this.createChildFromResolved(ResolvedReflectiveProviders);
	    };
	    ReflectiveInjector_.prototype.createChildFromResolved = function (providers) {
	        var proto = new ReflectiveProtoInjector(providers);
	        var inj = new ReflectiveInjector_(proto);
	        inj._parent = this;
	        return inj;
	    };
	    ReflectiveInjector_.prototype.resolveAndInstantiate = function (provider) {
	        return this.instantiateResolved(ReflectiveInjector.resolve([provider])[0]);
	    };
	    ReflectiveInjector_.prototype.instantiateResolved = function (provider) {
	        return this._instantiateProvider(provider);
	    };
	    /** @internal */
	    ReflectiveInjector_.prototype._new = function (provider) {
	        if (this._constructionCounter++ > this._strategy.getMaxNumberOfObjects()) {
	            throw new reflective_exceptions_1.CyclicDependencyError(this, provider.key);
	        }
	        return this._instantiateProvider(provider);
	    };
	    ReflectiveInjector_.prototype._instantiateProvider = function (provider) {
	        if (provider.multiProvider) {
	            var res = collection_1.ListWrapper.createFixedSize(provider.resolvedFactories.length);
	            for (var i = 0; i < provider.resolvedFactories.length; ++i) {
	                res[i] = this._instantiate(provider, provider.resolvedFactories[i]);
	            }
	            return res;
	        }
	        else {
	            return this._instantiate(provider, provider.resolvedFactories[0]);
	        }
	    };
	    ReflectiveInjector_.prototype._instantiate = function (provider, ResolvedReflectiveFactory) {
	        var factory = ResolvedReflectiveFactory.factory;
	        var deps = ResolvedReflectiveFactory.dependencies;
	        var length = deps.length;
	        var d0;
	        var d1;
	        var d2;
	        var d3;
	        var d4;
	        var d5;
	        var d6;
	        var d7;
	        var d8;
	        var d9;
	        var d10;
	        var d11;
	        var d12;
	        var d13;
	        var d14;
	        var d15;
	        var d16;
	        var d17;
	        var d18;
	        var d19;
	        try {
	            d0 = length > 0 ? this._getByReflectiveDependency(provider, deps[0]) : null;
	            d1 = length > 1 ? this._getByReflectiveDependency(provider, deps[1]) : null;
	            d2 = length > 2 ? this._getByReflectiveDependency(provider, deps[2]) : null;
	            d3 = length > 3 ? this._getByReflectiveDependency(provider, deps[3]) : null;
	            d4 = length > 4 ? this._getByReflectiveDependency(provider, deps[4]) : null;
	            d5 = length > 5 ? this._getByReflectiveDependency(provider, deps[5]) : null;
	            d6 = length > 6 ? this._getByReflectiveDependency(provider, deps[6]) : null;
	            d7 = length > 7 ? this._getByReflectiveDependency(provider, deps[7]) : null;
	            d8 = length > 8 ? this._getByReflectiveDependency(provider, deps[8]) : null;
	            d9 = length > 9 ? this._getByReflectiveDependency(provider, deps[9]) : null;
	            d10 = length > 10 ? this._getByReflectiveDependency(provider, deps[10]) : null;
	            d11 = length > 11 ? this._getByReflectiveDependency(provider, deps[11]) : null;
	            d12 = length > 12 ? this._getByReflectiveDependency(provider, deps[12]) : null;
	            d13 = length > 13 ? this._getByReflectiveDependency(provider, deps[13]) : null;
	            d14 = length > 14 ? this._getByReflectiveDependency(provider, deps[14]) : null;
	            d15 = length > 15 ? this._getByReflectiveDependency(provider, deps[15]) : null;
	            d16 = length > 16 ? this._getByReflectiveDependency(provider, deps[16]) : null;
	            d17 = length > 17 ? this._getByReflectiveDependency(provider, deps[17]) : null;
	            d18 = length > 18 ? this._getByReflectiveDependency(provider, deps[18]) : null;
	            d19 = length > 19 ? this._getByReflectiveDependency(provider, deps[19]) : null;
	        }
	        catch (e) {
	            if (e instanceof reflective_exceptions_1.AbstractProviderError || e instanceof reflective_exceptions_1.InstantiationError) {
	                e.addKey(this, provider.key);
	            }
	            throw e;
	        }
	        var obj;
	        try {
	            switch (length) {
	                case 0:
	                    obj = factory();
	                    break;
	                case 1:
	                    obj = factory(d0);
	                    break;
	                case 2:
	                    obj = factory(d0, d1);
	                    break;
	                case 3:
	                    obj = factory(d0, d1, d2);
	                    break;
	                case 4:
	                    obj = factory(d0, d1, d2, d3);
	                    break;
	                case 5:
	                    obj = factory(d0, d1, d2, d3, d4);
	                    break;
	                case 6:
	                    obj = factory(d0, d1, d2, d3, d4, d5);
	                    break;
	                case 7:
	                    obj = factory(d0, d1, d2, d3, d4, d5, d6);
	                    break;
	                case 8:
	                    obj = factory(d0, d1, d2, d3, d4, d5, d6, d7);
	                    break;
	                case 9:
	                    obj = factory(d0, d1, d2, d3, d4, d5, d6, d7, d8);
	                    break;
	                case 10:
	                    obj = factory(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9);
	                    break;
	                case 11:
	                    obj = factory(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10);
	                    break;
	                case 12:
	                    obj = factory(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11);
	                    break;
	                case 13:
	                    obj = factory(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12);
	                    break;
	                case 14:
	                    obj = factory(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13);
	                    break;
	                case 15:
	                    obj = factory(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14);
	                    break;
	                case 16:
	                    obj = factory(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15);
	                    break;
	                case 17:
	                    obj = factory(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16);
	                    break;
	                case 18:
	                    obj = factory(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16, d17);
	                    break;
	                case 19:
	                    obj = factory(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16, d17, d18);
	                    break;
	                case 20:
	                    obj = factory(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16, d17, d18, d19);
	                    break;
	                default:
	                    throw new exceptions_1.BaseException("Cannot instantiate '" + provider.key.displayName + "' because it has more than 20 dependencies");
	            }
	        }
	        catch (e) {
	            throw new reflective_exceptions_1.InstantiationError(this, e, e.stack, provider.key);
	        }
	        return obj;
	    };
	    ReflectiveInjector_.prototype._getByReflectiveDependency = function (provider, dep) {
	        return this._getByKey(dep.key, dep.lowerBoundVisibility, dep.upperBoundVisibility, dep.optional ? null : injector_1.THROW_IF_NOT_FOUND);
	    };
	    ReflectiveInjector_.prototype._getByKey = function (key, lowerBoundVisibility, upperBoundVisibility, notFoundValue) {
	        if (key === INJECTOR_KEY) {
	            return this;
	        }
	        if (upperBoundVisibility instanceof metadata_1.SelfMetadata) {
	            return this._getByKeySelf(key, notFoundValue);
	        }
	        else {
	            return this._getByKeyDefault(key, notFoundValue, lowerBoundVisibility);
	        }
	    };
	    /** @internal */
	    ReflectiveInjector_.prototype._throwOrNull = function (key, notFoundValue) {
	        if (notFoundValue !== injector_1.THROW_IF_NOT_FOUND) {
	            return notFoundValue;
	        }
	        else {
	            throw new reflective_exceptions_1.NoProviderError(this, key);
	        }
	    };
	    /** @internal */
	    ReflectiveInjector_.prototype._getByKeySelf = function (key, notFoundValue) {
	        var obj = this._strategy.getObjByKeyId(key.id);
	        return (obj !== UNDEFINED) ? obj : this._throwOrNull(key, notFoundValue);
	    };
	    /** @internal */
	    ReflectiveInjector_.prototype._getByKeyDefault = function (key, notFoundValue, lowerBoundVisibility) {
	        var inj;
	        if (lowerBoundVisibility instanceof metadata_1.SkipSelfMetadata) {
	            inj = this._parent;
	        }
	        else {
	            inj = this;
	        }
	        while (inj instanceof ReflectiveInjector_) {
	            var inj_ = inj;
	            var obj = inj_._strategy.getObjByKeyId(key.id);
	            if (obj !== UNDEFINED)
	                return obj;
	            inj = inj_._parent;
	        }
	        if (inj !== null) {
	            return inj.get(key.token, notFoundValue);
	        }
	        else {
	            return this._throwOrNull(key, notFoundValue);
	        }
	    };
	    Object.defineProperty(ReflectiveInjector_.prototype, "displayName", {
	        get: function () {
	            return "ReflectiveInjector(providers: [" + _mapProviders(this, function (b) { return (" \"" + b.key.displayName + "\" "); }).join(", ") + "])";
	        },
	        enumerable: true,
	        configurable: true
	    });
	    ReflectiveInjector_.prototype.toString = function () { return this.displayName; };
	    return ReflectiveInjector_;
	}());
	exports.ReflectiveInjector_ = ReflectiveInjector_;
	var INJECTOR_KEY = reflective_key_1.ReflectiveKey.get(injector_1.Injector);
	function _mapProviders(injector, fn) {
	    var res = [];
	    for (var i = 0; i < injector._proto.numberOfProviders; ++i) {
	        res.push(fn(injector._proto.getProviderAtIndex(i)));
	    }
	    return res;
	}


/***/ },
/* 17 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var reflection_1 = __webpack_require__(18);
	var reflective_key_1 = __webpack_require__(22);
	var metadata_1 = __webpack_require__(7);
	var reflective_exceptions_1 = __webpack_require__(23);
	var forward_ref_1 = __webpack_require__(10);
	var provider_1 = __webpack_require__(24);
	var provider_util_1 = __webpack_require__(25);
	/**
	 * `Dependency` is used by the framework to extend DI.
	 * This is internal to Angular and should not be used directly.
	 */
	var ReflectiveDependency = (function () {
	    function ReflectiveDependency(key, optional, lowerBoundVisibility, upperBoundVisibility, properties) {
	        this.key = key;
	        this.optional = optional;
	        this.lowerBoundVisibility = lowerBoundVisibility;
	        this.upperBoundVisibility = upperBoundVisibility;
	        this.properties = properties;
	    }
	    ReflectiveDependency.fromKey = function (key) {
	        return new ReflectiveDependency(key, false, null, null, []);
	    };
	    return ReflectiveDependency;
	}());
	exports.ReflectiveDependency = ReflectiveDependency;
	var _EMPTY_LIST = [];
	var ResolvedReflectiveProvider_ = (function () {
	    function ResolvedReflectiveProvider_(key, resolvedFactories, multiProvider) {
	        this.key = key;
	        this.resolvedFactories = resolvedFactories;
	        this.multiProvider = multiProvider;
	    }
	    Object.defineProperty(ResolvedReflectiveProvider_.prototype, "resolvedFactory", {
	        get: function () { return this.resolvedFactories[0]; },
	        enumerable: true,
	        configurable: true
	    });
	    return ResolvedReflectiveProvider_;
	}());
	exports.ResolvedReflectiveProvider_ = ResolvedReflectiveProvider_;
	/**
	 * An internal resolved representation of a factory function created by resolving {@link Provider}.
	 */
	var ResolvedReflectiveFactory = (function () {
	    function ResolvedReflectiveFactory(
	        /**
	         * Factory function which can return an instance of an object represented by a key.
	         */
	        factory, 
	        /**
	         * Arguments (dependencies) to the `factory` function.
	         */
	        dependencies) {
	        this.factory = factory;
	        this.dependencies = dependencies;
	    }
	    return ResolvedReflectiveFactory;
	}());
	exports.ResolvedReflectiveFactory = ResolvedReflectiveFactory;
	/**
	 * Resolve a single provider.
	 */
	function resolveReflectiveFactory(provider) {
	    var factoryFn;
	    var resolvedDeps;
	    if (lang_1.isPresent(provider.useClass)) {
	        var useClass = forward_ref_1.resolveForwardRef(provider.useClass);
	        factoryFn = reflection_1.reflector.factory(useClass);
	        resolvedDeps = _dependenciesFor(useClass);
	    }
	    else if (lang_1.isPresent(provider.useExisting)) {
	        factoryFn = function (aliasInstance) { return aliasInstance; };
	        resolvedDeps = [ReflectiveDependency.fromKey(reflective_key_1.ReflectiveKey.get(provider.useExisting))];
	    }
	    else if (lang_1.isPresent(provider.useFactory)) {
	        factoryFn = provider.useFactory;
	        resolvedDeps = constructDependencies(provider.useFactory, provider.dependencies);
	    }
	    else {
	        factoryFn = function () { return provider.useValue; };
	        resolvedDeps = _EMPTY_LIST;
	    }
	    return new ResolvedReflectiveFactory(factoryFn, resolvedDeps);
	}
	exports.resolveReflectiveFactory = resolveReflectiveFactory;
	/**
	 * Converts the {@link Provider} into {@link ResolvedProvider}.
	 *
	 * {@link Injector} internally only uses {@link ResolvedProvider}, {@link Provider} contains
	 * convenience provider syntax.
	 */
	function resolveReflectiveProvider(provider) {
	    return new ResolvedReflectiveProvider_(reflective_key_1.ReflectiveKey.get(provider.token), [resolveReflectiveFactory(provider)], provider.multi);
	}
	exports.resolveReflectiveProvider = resolveReflectiveProvider;
	/**
	 * Resolve a list of Providers.
	 */
	function resolveReflectiveProviders(providers) {
	    var normalized = _normalizeProviders(providers, []);
	    var resolved = normalized.map(resolveReflectiveProvider);
	    return collection_1.MapWrapper.values(mergeResolvedReflectiveProviders(resolved, new Map()));
	}
	exports.resolveReflectiveProviders = resolveReflectiveProviders;
	/**
	 * Merges a list of ResolvedProviders into a list where
	 * each key is contained exactly once and multi providers
	 * have been merged.
	 */
	function mergeResolvedReflectiveProviders(providers, normalizedProvidersMap) {
	    for (var i = 0; i < providers.length; i++) {
	        var provider = providers[i];
	        var existing = normalizedProvidersMap.get(provider.key.id);
	        if (lang_1.isPresent(existing)) {
	            if (provider.multiProvider !== existing.multiProvider) {
	                throw new reflective_exceptions_1.MixingMultiProvidersWithRegularProvidersError(existing, provider);
	            }
	            if (provider.multiProvider) {
	                for (var j = 0; j < provider.resolvedFactories.length; j++) {
	                    existing.resolvedFactories.push(provider.resolvedFactories[j]);
	                }
	            }
	            else {
	                normalizedProvidersMap.set(provider.key.id, provider);
	            }
	        }
	        else {
	            var resolvedProvider;
	            if (provider.multiProvider) {
	                resolvedProvider = new ResolvedReflectiveProvider_(provider.key, collection_1.ListWrapper.clone(provider.resolvedFactories), provider.multiProvider);
	            }
	            else {
	                resolvedProvider = provider;
	            }
	            normalizedProvidersMap.set(provider.key.id, resolvedProvider);
	        }
	    }
	    return normalizedProvidersMap;
	}
	exports.mergeResolvedReflectiveProviders = mergeResolvedReflectiveProviders;
	function _normalizeProviders(providers, res) {
	    providers.forEach(function (b) {
	        if (b instanceof lang_1.Type) {
	            res.push(provider_1.provide(b, { useClass: b }));
	        }
	        else if (b instanceof provider_1.Provider) {
	            res.push(b);
	        }
	        else if (provider_util_1.isProviderLiteral(b)) {
	            res.push(provider_util_1.createProvider(b));
	        }
	        else if (b instanceof Array) {
	            _normalizeProviders(b, res);
	        }
	        else if (b instanceof provider_1.ProviderBuilder) {
	            throw new reflective_exceptions_1.InvalidProviderError(b.token);
	        }
	        else {
	            throw new reflective_exceptions_1.InvalidProviderError(b);
	        }
	    });
	    return res;
	}
	function constructDependencies(typeOrFunc, dependencies) {
	    if (lang_1.isBlank(dependencies)) {
	        return _dependenciesFor(typeOrFunc);
	    }
	    else {
	        var params = dependencies.map(function (t) { return [t]; });
	        return dependencies.map(function (t) { return _extractToken(typeOrFunc, t, params); });
	    }
	}
	exports.constructDependencies = constructDependencies;
	function _dependenciesFor(typeOrFunc) {
	    var params = reflection_1.reflector.parameters(typeOrFunc);
	    if (lang_1.isBlank(params))
	        return [];
	    if (params.some(lang_1.isBlank)) {
	        throw new reflective_exceptions_1.NoAnnotationError(typeOrFunc, params);
	    }
	    return params.map(function (p) { return _extractToken(typeOrFunc, p, params); });
	}
	function _extractToken(typeOrFunc, metadata /*any[] | any*/, params) {
	    var depProps = [];
	    var token = null;
	    var optional = false;
	    if (!lang_1.isArray(metadata)) {
	        if (metadata instanceof metadata_1.InjectMetadata) {
	            return _createDependency(metadata.token, optional, null, null, depProps);
	        }
	        else {
	            return _createDependency(metadata, optional, null, null, depProps);
	        }
	    }
	    var lowerBoundVisibility = null;
	    var upperBoundVisibility = null;
	    for (var i = 0; i < metadata.length; ++i) {
	        var paramMetadata = metadata[i];
	        if (paramMetadata instanceof lang_1.Type) {
	            token = paramMetadata;
	        }
	        else if (paramMetadata instanceof metadata_1.InjectMetadata) {
	            token = paramMetadata.token;
	        }
	        else if (paramMetadata instanceof metadata_1.OptionalMetadata) {
	            optional = true;
	        }
	        else if (paramMetadata instanceof metadata_1.SelfMetadata) {
	            upperBoundVisibility = paramMetadata;
	        }
	        else if (paramMetadata instanceof metadata_1.HostMetadata) {
	            upperBoundVisibility = paramMetadata;
	        }
	        else if (paramMetadata instanceof metadata_1.SkipSelfMetadata) {
	            lowerBoundVisibility = paramMetadata;
	        }
	        else if (paramMetadata instanceof metadata_1.DependencyMetadata) {
	            if (lang_1.isPresent(paramMetadata.token)) {
	                token = paramMetadata.token;
	            }
	            depProps.push(paramMetadata);
	        }
	    }
	    token = forward_ref_1.resolveForwardRef(token);
	    if (lang_1.isPresent(token)) {
	        return _createDependency(token, optional, lowerBoundVisibility, upperBoundVisibility, depProps);
	    }
	    else {
	        throw new reflective_exceptions_1.NoAnnotationError(typeOrFunc, params);
	    }
	}
	function _createDependency(token, optional, lowerBoundVisibility, upperBoundVisibility, depProps) {
	    return new ReflectiveDependency(reflective_key_1.ReflectiveKey.get(token), optional, lowerBoundVisibility, upperBoundVisibility, depProps);
	}


/***/ },
/* 18 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var reflector_1 = __webpack_require__(19);
	var reflector_2 = __webpack_require__(19);
	exports.Reflector = reflector_2.Reflector;
	exports.ReflectionInfo = reflector_2.ReflectionInfo;
	var reflection_capabilities_1 = __webpack_require__(21);
	/**
	 * The {@link Reflector} used internally in Angular to access metadata
	 * about symbols.
	 */
	exports.reflector = new reflector_1.Reflector(new reflection_capabilities_1.ReflectionCapabilities());


/***/ },
/* 19 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var collection_1 = __webpack_require__(15);
	var reflector_reader_1 = __webpack_require__(20);
	/**
	 * Reflective information about a symbol, including annotations, interfaces, and other metadata.
	 */
	var ReflectionInfo = (function () {
	    function ReflectionInfo(annotations, parameters, factory, interfaces, propMetadata) {
	        this.annotations = annotations;
	        this.parameters = parameters;
	        this.factory = factory;
	        this.interfaces = interfaces;
	        this.propMetadata = propMetadata;
	    }
	    return ReflectionInfo;
	}());
	exports.ReflectionInfo = ReflectionInfo;
	/**
	 * Provides access to reflection data about symbols. Used internally by Angular
	 * to power dependency injection and compilation.
	 */
	var Reflector = (function (_super) {
	    __extends(Reflector, _super);
	    function Reflector(reflectionCapabilities) {
	        _super.call(this);
	        /** @internal */
	        this._injectableInfo = new collection_1.Map();
	        /** @internal */
	        this._getters = new collection_1.Map();
	        /** @internal */
	        this._setters = new collection_1.Map();
	        /** @internal */
	        this._methods = new collection_1.Map();
	        this._usedKeys = null;
	        this.reflectionCapabilities = reflectionCapabilities;
	    }
	    Reflector.prototype.isReflectionEnabled = function () { return this.reflectionCapabilities.isReflectionEnabled(); };
	    /**
	     * Causes `this` reflector to track keys used to access
	     * {@link ReflectionInfo} objects.
	     */
	    Reflector.prototype.trackUsage = function () { this._usedKeys = new collection_1.Set(); };
	    /**
	     * Lists types for which reflection information was not requested since
	     * {@link #trackUsage} was called. This list could later be audited as
	     * potential dead code.
	     */
	    Reflector.prototype.listUnusedKeys = function () {
	        var _this = this;
	        if (this._usedKeys == null) {
	            throw new exceptions_1.BaseException('Usage tracking is disabled');
	        }
	        var allTypes = collection_1.MapWrapper.keys(this._injectableInfo);
	        return allTypes.filter(function (key) { return !collection_1.SetWrapper.has(_this._usedKeys, key); });
	    };
	    Reflector.prototype.registerFunction = function (func, funcInfo) {
	        this._injectableInfo.set(func, funcInfo);
	    };
	    Reflector.prototype.registerType = function (type, typeInfo) {
	        this._injectableInfo.set(type, typeInfo);
	    };
	    Reflector.prototype.registerGetters = function (getters) { _mergeMaps(this._getters, getters); };
	    Reflector.prototype.registerSetters = function (setters) { _mergeMaps(this._setters, setters); };
	    Reflector.prototype.registerMethods = function (methods) { _mergeMaps(this._methods, methods); };
	    Reflector.prototype.factory = function (type) {
	        if (this._containsReflectionInfo(type)) {
	            var res = this._getReflectionInfo(type).factory;
	            return lang_1.isPresent(res) ? res : null;
	        }
	        else {
	            return this.reflectionCapabilities.factory(type);
	        }
	    };
	    Reflector.prototype.parameters = function (typeOrFunc) {
	        if (this._injectableInfo.has(typeOrFunc)) {
	            var res = this._getReflectionInfo(typeOrFunc).parameters;
	            return lang_1.isPresent(res) ? res : [];
	        }
	        else {
	            return this.reflectionCapabilities.parameters(typeOrFunc);
	        }
	    };
	    Reflector.prototype.annotations = function (typeOrFunc) {
	        if (this._injectableInfo.has(typeOrFunc)) {
	            var res = this._getReflectionInfo(typeOrFunc).annotations;
	            return lang_1.isPresent(res) ? res : [];
	        }
	        else {
	            return this.reflectionCapabilities.annotations(typeOrFunc);
	        }
	    };
	    Reflector.prototype.propMetadata = function (typeOrFunc) {
	        if (this._injectableInfo.has(typeOrFunc)) {
	            var res = this._getReflectionInfo(typeOrFunc).propMetadata;
	            return lang_1.isPresent(res) ? res : {};
	        }
	        else {
	            return this.reflectionCapabilities.propMetadata(typeOrFunc);
	        }
	    };
	    Reflector.prototype.interfaces = function (type) {
	        if (this._injectableInfo.has(type)) {
	            var res = this._getReflectionInfo(type).interfaces;
	            return lang_1.isPresent(res) ? res : [];
	        }
	        else {
	            return this.reflectionCapabilities.interfaces(type);
	        }
	    };
	    Reflector.prototype.getter = function (name) {
	        if (this._getters.has(name)) {
	            return this._getters.get(name);
	        }
	        else {
	            return this.reflectionCapabilities.getter(name);
	        }
	    };
	    Reflector.prototype.setter = function (name) {
	        if (this._setters.has(name)) {
	            return this._setters.get(name);
	        }
	        else {
	            return this.reflectionCapabilities.setter(name);
	        }
	    };
	    Reflector.prototype.method = function (name) {
	        if (this._methods.has(name)) {
	            return this._methods.get(name);
	        }
	        else {
	            return this.reflectionCapabilities.method(name);
	        }
	    };
	    /** @internal */
	    Reflector.prototype._getReflectionInfo = function (typeOrFunc) {
	        if (lang_1.isPresent(this._usedKeys)) {
	            this._usedKeys.add(typeOrFunc);
	        }
	        return this._injectableInfo.get(typeOrFunc);
	    };
	    /** @internal */
	    Reflector.prototype._containsReflectionInfo = function (typeOrFunc) { return this._injectableInfo.has(typeOrFunc); };
	    Reflector.prototype.importUri = function (type) { return this.reflectionCapabilities.importUri(type); };
	    return Reflector;
	}(reflector_reader_1.ReflectorReader));
	exports.Reflector = Reflector;
	function _mergeMaps(target, config) {
	    collection_1.StringMapWrapper.forEach(config, function (v, k) { return target.set(k, v); });
	}


/***/ },
/* 20 */
/***/ function(module, exports) {

	"use strict";
	/**
	 * Provides read-only access to reflection data about symbols. Used internally by Angular
	 * to power dependency injection and compilation.
	 */
	var ReflectorReader = (function () {
	    function ReflectorReader() {
	    }
	    return ReflectorReader;
	}());
	exports.ReflectorReader = ReflectorReader;


/***/ },
/* 21 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var ReflectionCapabilities = (function () {
	    function ReflectionCapabilities(reflect) {
	        this._reflect = lang_1.isPresent(reflect) ? reflect : lang_1.global.Reflect;
	    }
	    ReflectionCapabilities.prototype.isReflectionEnabled = function () { return true; };
	    ReflectionCapabilities.prototype.factory = function (t) {
	        switch (t.length) {
	            case 0:
	                return function () { return new t(); };
	            case 1:
	                return function (a1) { return new t(a1); };
	            case 2:
	                return function (a1, a2) { return new t(a1, a2); };
	            case 3:
	                return function (a1, a2, a3) { return new t(a1, a2, a3); };
	            case 4:
	                return function (a1, a2, a3, a4) { return new t(a1, a2, a3, a4); };
	            case 5:
	                return function (a1, a2, a3, a4, a5) { return new t(a1, a2, a3, a4, a5); };
	            case 6:
	                return function (a1, a2, a3, a4, a5, a6) {
	                    return new t(a1, a2, a3, a4, a5, a6);
	                };
	            case 7:
	                return function (a1, a2, a3, a4, a5, a6, a7) {
	                    return new t(a1, a2, a3, a4, a5, a6, a7);
	                };
	            case 8:
	                return function (a1, a2, a3, a4, a5, a6, a7, a8) {
	                    return new t(a1, a2, a3, a4, a5, a6, a7, a8);
	                };
	            case 9:
	                return function (a1, a2, a3, a4, a5, a6, a7, a8, a9) {
	                    return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	                };
	            case 10:
	                return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
	                    return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	                };
	            case 11:
	                return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) {
	                    return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	                };
	            case 12:
	                return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) {
	                    return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	                };
	            case 13:
	                return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) {
	                    return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	                };
	            case 14:
	                return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) {
	                    return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	                };
	            case 15:
	                return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) {
	                    return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	                };
	            case 16:
	                return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) {
	                    return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16);
	                };
	            case 17:
	                return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) {
	                    return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17);
	                };
	            case 18:
	                return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) {
	                    return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18);
	                };
	            case 19:
	                return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) {
	                    return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19);
	                };
	            case 20:
	                return function (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) {
	                    return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
	                };
	        }
	        ;
	        throw new Error("Cannot create a factory for '" + lang_1.stringify(t) + "' because its constructor has more than 20 arguments");
	    };
	    /** @internal */
	    ReflectionCapabilities.prototype._zipTypesAndAnnotations = function (paramTypes, paramAnnotations) {
	        var result;
	        if (typeof paramTypes === 'undefined') {
	            result = new Array(paramAnnotations.length);
	        }
	        else {
	            result = new Array(paramTypes.length);
	        }
	        for (var i = 0; i < result.length; i++) {
	            // TS outputs Object for parameters without types, while Traceur omits
	            // the annotations. For now we preserve the Traceur behavior to aid
	            // migration, but this can be revisited.
	            if (typeof paramTypes === 'undefined') {
	                result[i] = [];
	            }
	            else if (paramTypes[i] != Object) {
	                result[i] = [paramTypes[i]];
	            }
	            else {
	                result[i] = [];
	            }
	            if (lang_1.isPresent(paramAnnotations) && lang_1.isPresent(paramAnnotations[i])) {
	                result[i] = result[i].concat(paramAnnotations[i]);
	            }
	        }
	        return result;
	    };
	    ReflectionCapabilities.prototype.parameters = function (typeOrFunc) {
	        // Prefer the direct API.
	        if (lang_1.isPresent(typeOrFunc.parameters)) {
	            return typeOrFunc.parameters;
	        }
	        if (lang_1.isPresent(this._reflect) && lang_1.isPresent(this._reflect.getMetadata)) {
	            var paramAnnotations = this._reflect.getMetadata('parameters', typeOrFunc);
	            var paramTypes = this._reflect.getMetadata('design:paramtypes', typeOrFunc);
	            if (lang_1.isPresent(paramTypes) || lang_1.isPresent(paramAnnotations)) {
	                return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);
	            }
	        }
	        // The array has to be filled with `undefined` because holes would be skipped by `some`
	        var parameters = new Array(typeOrFunc.length);
	        parameters.fill(undefined);
	        return parameters;
	    };
	    ReflectionCapabilities.prototype.annotations = function (typeOrFunc) {
	        // Prefer the direct API.
	        if (lang_1.isPresent(typeOrFunc.annotations)) {
	            var annotations = typeOrFunc.annotations;
	            if (lang_1.isFunction(annotations) && annotations.annotations) {
	                annotations = annotations.annotations;
	            }
	            return annotations;
	        }
	        if (lang_1.isPresent(this._reflect) && lang_1.isPresent(this._reflect.getMetadata)) {
	            var annotations = this._reflect.getMetadata('annotations', typeOrFunc);
	            if (lang_1.isPresent(annotations))
	                return annotations;
	        }
	        return [];
	    };
	    ReflectionCapabilities.prototype.propMetadata = function (typeOrFunc) {
	        // Prefer the direct API.
	        if (lang_1.isPresent(typeOrFunc.propMetadata)) {
	            var propMetadata = typeOrFunc.propMetadata;
	            if (lang_1.isFunction(propMetadata) && propMetadata.propMetadata) {
	                propMetadata = propMetadata.propMetadata;
	            }
	            return propMetadata;
	        }
	        if (lang_1.isPresent(this._reflect) && lang_1.isPresent(this._reflect.getMetadata)) {
	            var propMetadata = this._reflect.getMetadata('propMetadata', typeOrFunc);
	            if (lang_1.isPresent(propMetadata))
	                return propMetadata;
	        }
	        return {};
	    };
	    ReflectionCapabilities.prototype.interfaces = function (type) {
	        throw new exceptions_1.BaseException("JavaScript does not support interfaces");
	    };
	    ReflectionCapabilities.prototype.getter = function (name) { return new Function('o', 'return o.' + name + ';'); };
	    ReflectionCapabilities.prototype.setter = function (name) {
	        return new Function('o', 'v', 'return o.' + name + ' = v;');
	    };
	    ReflectionCapabilities.prototype.method = function (name) {
	        var functionBody = "if (!o." + name + ") throw new Error('\"" + name + "\" is undefined');\n        return o." + name + ".apply(o, args);";
	        return new Function('o', 'args', functionBody);
	    };
	    // There is not a concept of import uri in Js, but this is useful in developing Dart applications.
	    ReflectionCapabilities.prototype.importUri = function (type) { return "./" + lang_1.stringify(type); };
	    return ReflectionCapabilities;
	}());
	exports.ReflectionCapabilities = ReflectionCapabilities;


/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var forward_ref_1 = __webpack_require__(10);
	/**
	 * A unique object used for retrieving items from the {@link ReflectiveInjector}.
	 *
	 * Keys have:
	 * - a system-wide unique `id`.
	 * - a `token`.
	 *
	 * `Key` is used internally by {@link ReflectiveInjector} because its system-wide unique `id` allows
	 * the
	 * injector to store created objects in a more efficient way.
	 *
	 * `Key` should not be created directly. {@link ReflectiveInjector} creates keys automatically when
	 * resolving
	 * providers.
	 */
	var ReflectiveKey = (function () {
	    /**
	     * Private
	     */
	    function ReflectiveKey(token, id) {
	        this.token = token;
	        this.id = id;
	        if (lang_1.isBlank(token)) {
	            throw new exceptions_1.BaseException('Token must be defined!');
	        }
	    }
	    Object.defineProperty(ReflectiveKey.prototype, "displayName", {
	        /**
	         * Returns a stringified token.
	         */
	        get: function () { return lang_1.stringify(this.token); },
	        enumerable: true,
	        configurable: true
	    });
	    /**
	     * Retrieves a `Key` for a token.
	     */
	    ReflectiveKey.get = function (token) {
	        return _globalKeyRegistry.get(forward_ref_1.resolveForwardRef(token));
	    };
	    Object.defineProperty(ReflectiveKey, "numberOfKeys", {
	        /**
	         * @returns the number of keys registered in the system.
	         */
	        get: function () { return _globalKeyRegistry.numberOfKeys; },
	        enumerable: true,
	        configurable: true
	    });
	    return ReflectiveKey;
	}());
	exports.ReflectiveKey = ReflectiveKey;
	/**
	 * @internal
	 */
	var KeyRegistry = (function () {
	    function KeyRegistry() {
	        this._allKeys = new Map();
	    }
	    KeyRegistry.prototype.get = function (token) {
	        if (token instanceof ReflectiveKey)
	            return token;
	        if (this._allKeys.has(token)) {
	            return this._allKeys.get(token);
	        }
	        var newKey = new ReflectiveKey(token, ReflectiveKey.numberOfKeys);
	        this._allKeys.set(token, newKey);
	        return newKey;
	    };
	    Object.defineProperty(KeyRegistry.prototype, "numberOfKeys", {
	        get: function () { return this._allKeys.size; },
	        enumerable: true,
	        configurable: true
	    });
	    return KeyRegistry;
	}());
	exports.KeyRegistry = KeyRegistry;
	var _globalKeyRegistry = new KeyRegistry();


/***/ },
/* 23 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	function findFirstClosedCycle(keys) {
	    var res = [];
	    for (var i = 0; i < keys.length; ++i) {
	        if (collection_1.ListWrapper.contains(res, keys[i])) {
	            res.push(keys[i]);
	            return res;
	        }
	        else {
	            res.push(keys[i]);
	        }
	    }
	    return res;
	}
	function constructResolvingPath(keys) {
	    if (keys.length > 1) {
	        var reversed = findFirstClosedCycle(collection_1.ListWrapper.reversed(keys));
	        var tokenStrs = reversed.map(function (k) { return lang_1.stringify(k.token); });
	        return " (" + tokenStrs.join(' -> ') + ")";
	    }
	    else {
	        return "";
	    }
	}
	/**
	 * Base class for all errors arising from misconfigured providers.
	 */
	var AbstractProviderError = (function (_super) {
	    __extends(AbstractProviderError, _super);
	    function AbstractProviderError(injector, key, constructResolvingMessage) {
	        _super.call(this, "DI Exception");
	        this.keys = [key];
	        this.injectors = [injector];
	        this.constructResolvingMessage = constructResolvingMessage;
	        this.message = this.constructResolvingMessage(this.keys);
	    }
	    AbstractProviderError.prototype.addKey = function (injector, key) {
	        this.injectors.push(injector);
	        this.keys.push(key);
	        this.message = this.constructResolvingMessage(this.keys);
	    };
	    Object.defineProperty(AbstractProviderError.prototype, "context", {
	        get: function () { return this.injectors[this.injectors.length - 1].debugContext(); },
	        enumerable: true,
	        configurable: true
	    });
	    return AbstractProviderError;
	}(exceptions_1.BaseException));
	exports.AbstractProviderError = AbstractProviderError;
	/**
	 * Thrown when trying to retrieve a dependency by `Key` from {@link Injector}, but the
	 * {@link Injector} does not have a {@link Provider} for {@link Key}.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/vq8D3FRB9aGbnWJqtEPE?p=preview))
	 *
	 * ```typescript
	 * class A {
	 *   constructor(b:B) {}
	 * }
	 *
	 * expect(() => Injector.resolveAndCreate([A])).toThrowError();
	 * ```
	 */
	var NoProviderError = (function (_super) {
	    __extends(NoProviderError, _super);
	    function NoProviderError(injector, key) {
	        _super.call(this, injector, key, function (keys) {
	            var first = lang_1.stringify(collection_1.ListWrapper.first(keys).token);
	            return "No provider for " + first + "!" + constructResolvingPath(keys);
	        });
	    }
	    return NoProviderError;
	}(AbstractProviderError));
	exports.NoProviderError = NoProviderError;
	/**
	 * Thrown when dependencies form a cycle.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/wYQdNos0Tzql3ei1EV9j?p=info))
	 *
	 * ```typescript
	 * var injector = Injector.resolveAndCreate([
	 *   provide("one", {useFactory: (two) => "two", deps: [[new Inject("two")]]}),
	 *   provide("two", {useFactory: (one) => "one", deps: [[new Inject("one")]]})
	 * ]);
	 *
	 * expect(() => injector.get("one")).toThrowError();
	 * ```
	 *
	 * Retrieving `A` or `B` throws a `CyclicDependencyError` as the graph above cannot be constructed.
	 */
	var CyclicDependencyError = (function (_super) {
	    __extends(CyclicDependencyError, _super);
	    function CyclicDependencyError(injector, key) {
	        _super.call(this, injector, key, function (keys) {
	            return "Cannot instantiate cyclic dependency!" + constructResolvingPath(keys);
	        });
	    }
	    return CyclicDependencyError;
	}(AbstractProviderError));
	exports.CyclicDependencyError = CyclicDependencyError;
	/**
	 * Thrown when a constructing type returns with an Error.
	 *
	 * The `InstantiationError` class contains the original error plus the dependency graph which caused
	 * this object to be instantiated.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/7aWYdcqTQsP0eNqEdUAf?p=preview))
	 *
	 * ```typescript
	 * class A {
	 *   constructor() {
	 *     throw new Error('message');
	 *   }
	 * }
	 *
	 * var injector = Injector.resolveAndCreate([A]);

	 * try {
	 *   injector.get(A);
	 * } catch (e) {
	 *   expect(e instanceof InstantiationError).toBe(true);
	 *   expect(e.originalException.message).toEqual("message");
	 *   expect(e.originalStack).toBeDefined();
	 * }
	 * ```
	 */
	var InstantiationError = (function (_super) {
	    __extends(InstantiationError, _super);
	    function InstantiationError(injector, originalException, originalStack, key) {
	        _super.call(this, "DI Exception", originalException, originalStack, null);
	        this.keys = [key];
	        this.injectors = [injector];
	    }
	    InstantiationError.prototype.addKey = function (injector, key) {
	        this.injectors.push(injector);
	        this.keys.push(key);
	    };
	    Object.defineProperty(InstantiationError.prototype, "wrapperMessage", {
	        get: function () {
	            var first = lang_1.stringify(collection_1.ListWrapper.first(this.keys).token);
	            return "Error during instantiation of " + first + "!" + constructResolvingPath(this.keys) + ".";
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(InstantiationError.prototype, "causeKey", {
	        get: function () { return this.keys[0]; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(InstantiationError.prototype, "context", {
	        get: function () { return this.injectors[this.injectors.length - 1].debugContext(); },
	        enumerable: true,
	        configurable: true
	    });
	    return InstantiationError;
	}(exceptions_1.WrappedException));
	exports.InstantiationError = InstantiationError;
	/**
	 * Thrown when an object other then {@link Provider} (or `Type`) is passed to {@link Injector}
	 * creation.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/YatCFbPAMCL0JSSQ4mvH?p=preview))
	 *
	 * ```typescript
	 * expect(() => Injector.resolveAndCreate(["not a type"])).toThrowError();
	 * ```
	 */
	var InvalidProviderError = (function (_super) {
	    __extends(InvalidProviderError, _super);
	    function InvalidProviderError(provider) {
	        _super.call(this, "Invalid provider - only instances of Provider and Type are allowed, got: " +
	            provider.toString());
	    }
	    return InvalidProviderError;
	}(exceptions_1.BaseException));
	exports.InvalidProviderError = InvalidProviderError;
	/**
	 * Thrown when the class has no annotation information.
	 *
	 * Lack of annotation information prevents the {@link Injector} from determining which dependencies
	 * need to be injected into the constructor.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/rHnZtlNS7vJOPQ6pcVkm?p=preview))
	 *
	 * ```typescript
	 * class A {
	 *   constructor(b) {}
	 * }
	 *
	 * expect(() => Injector.resolveAndCreate([A])).toThrowError();
	 * ```
	 *
	 * This error is also thrown when the class not marked with {@link Injectable} has parameter types.
	 *
	 * ```typescript
	 * class B {}
	 *
	 * class A {
	 *   constructor(b:B) {} // no information about the parameter types of A is available at runtime.
	 * }
	 *
	 * expect(() => Injector.resolveAndCreate([A,B])).toThrowError();
	 * ```
	 */
	var NoAnnotationError = (function (_super) {
	    __extends(NoAnnotationError, _super);
	    function NoAnnotationError(typeOrFunc, params) {
	        _super.call(this, NoAnnotationError._genMessage(typeOrFunc, params));
	    }
	    NoAnnotationError._genMessage = function (typeOrFunc, params) {
	        var signature = [];
	        for (var i = 0, ii = params.length; i < ii; i++) {
	            var parameter = params[i];
	            if (lang_1.isBlank(parameter) || parameter.length == 0) {
	                signature.push('?');
	            }
	            else {
	                signature.push(parameter.map(lang_1.stringify).join(' '));
	            }
	        }
	        return "Cannot resolve all parameters for '" + lang_1.stringify(typeOrFunc) + "'(" +
	            signature.join(', ') + "). " +
	            "Make sure that all the parameters are decorated with Inject or have valid type annotations and that '" +
	            lang_1.stringify(typeOrFunc) + "' is decorated with Injectable.";
	    };
	    return NoAnnotationError;
	}(exceptions_1.BaseException));
	exports.NoAnnotationError = NoAnnotationError;
	/**
	 * Thrown when getting an object by index.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/bRs0SX2OTQiJzqvjgl8P?p=preview))
	 *
	 * ```typescript
	 * class A {}
	 *
	 * var injector = Injector.resolveAndCreate([A]);
	 *
	 * expect(() => injector.getAt(100)).toThrowError();
	 * ```
	 */
	var OutOfBoundsError = (function (_super) {
	    __extends(OutOfBoundsError, _super);
	    function OutOfBoundsError(index) {
	        _super.call(this, "Index " + index + " is out-of-bounds.");
	    }
	    return OutOfBoundsError;
	}(exceptions_1.BaseException));
	exports.OutOfBoundsError = OutOfBoundsError;
	// TODO: add a working example after alpha38 is released
	/**
	 * Thrown when a multi provider and a regular provider are bound to the same token.
	 *
	 * ### Example
	 *
	 * ```typescript
	 * expect(() => Injector.resolveAndCreate([
	 *   new Provider("Strings", {useValue: "string1", multi: true}),
	 *   new Provider("Strings", {useValue: "string2", multi: false})
	 * ])).toThrowError();
	 * ```
	 */
	var MixingMultiProvidersWithRegularProvidersError = (function (_super) {
	    __extends(MixingMultiProvidersWithRegularProvidersError, _super);
	    function MixingMultiProvidersWithRegularProvidersError(provider1, provider2) {
	        _super.call(this, "Cannot mix multi providers and regular providers, got: " + provider1.toString() + " " +
	            provider2.toString());
	    }
	    return MixingMultiProvidersWithRegularProvidersError;
	}(exceptions_1.BaseException));
	exports.MixingMultiProvidersWithRegularProvidersError = MixingMultiProvidersWithRegularProvidersError;


/***/ },
/* 24 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	/**
	 * Describes how the {@link Injector} should instantiate a given token.
	 *
	 * See {@link provide}.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/GNAyj6K6PfYg2NBzgwZ5?p%3Dpreview&p=preview))
	 *
	 * ```javascript
	 * var injector = Injector.resolveAndCreate([
	 *   new Provider("message", { useValue: 'Hello' })
	 * ]);
	 *
	 * expect(injector.get("message")).toEqual('Hello');
	 * ```
	 * @ts2dart_const
	 */
	var Provider = (function () {
	    function Provider(token, _a) {
	        var useClass = _a.useClass, useValue = _a.useValue, useExisting = _a.useExisting, useFactory = _a.useFactory, deps = _a.deps, multi = _a.multi;
	        this.token = token;
	        this.useClass = useClass;
	        this.useValue = useValue;
	        this.useExisting = useExisting;
	        this.useFactory = useFactory;
	        this.dependencies = deps;
	        this._multi = multi;
	    }
	    Object.defineProperty(Provider.prototype, "multi", {
	        // TODO: Provide a full working example after alpha38 is released.
	        /**
	         * Creates multiple providers matching the same token (a multi-provider).
	         *
	         * Multi-providers are used for creating pluggable service, where the system comes
	         * with some default providers, and the user can register additional providers.
	         * The combination of the default providers and the additional providers will be
	         * used to drive the behavior of the system.
	         *
	         * ### Example
	         *
	         * ```typescript
	         * var injector = Injector.resolveAndCreate([
	         *   new Provider("Strings", { useValue: "String1", multi: true}),
	         *   new Provider("Strings", { useValue: "String2", multi: true})
	         * ]);
	         *
	         * expect(injector.get("Strings")).toEqual(["String1", "String2"]);
	         * ```
	         *
	         * Multi-providers and regular providers cannot be mixed. The following
	         * will throw an exception:
	         *
	         * ```typescript
	         * var injector = Injector.resolveAndCreate([
	         *   new Provider("Strings", { useValue: "String1", multi: true }),
	         *   new Provider("Strings", { useValue: "String2"})
	         * ]);
	         * ```
	         */
	        get: function () { return lang_1.normalizeBool(this._multi); },
	        enumerable: true,
	        configurable: true
	    });
	    return Provider;
	}());
	exports.Provider = Provider;
	/**
	 * See {@link Provider} instead.
	 *
	 * @deprecated
	 * @ts2dart_const
	 */
	var Binding = (function (_super) {
	    __extends(Binding, _super);
	    function Binding(token, _a) {
	        var toClass = _a.toClass, toValue = _a.toValue, toAlias = _a.toAlias, toFactory = _a.toFactory, deps = _a.deps, multi = _a.multi;
	        _super.call(this, token, {
	            useClass: toClass,
	            useValue: toValue,
	            useExisting: toAlias,
	            useFactory: toFactory,
	            deps: deps,
	            multi: multi
	        });
	    }
	    Object.defineProperty(Binding.prototype, "toClass", {
	        /**
	         * @deprecated
	         */
	        get: function () { return this.useClass; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(Binding.prototype, "toAlias", {
	        /**
	         * @deprecated
	         */
	        get: function () { return this.useExisting; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(Binding.prototype, "toFactory", {
	        /**
	         * @deprecated
	         */
	        get: function () { return this.useFactory; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(Binding.prototype, "toValue", {
	        /**
	         * @deprecated
	         */
	        get: function () { return this.useValue; },
	        enumerable: true,
	        configurable: true
	    });
	    return Binding;
	}(Provider));
	exports.Binding = Binding;
	/**
	 * Creates a {@link Provider}.
	 *
	 * To construct a {@link Provider}, bind a `token` to either a class, a value, a factory function,
	 * or
	 * to an existing `token`.
	 * See {@link ProviderBuilder} for more details.
	 *
	 * The `token` is most commonly a class or {@link OpaqueToken-class.html}.
	 *
	 * @deprecated
	 */
	function bind(token) {
	    return new ProviderBuilder(token);
	}
	exports.bind = bind;
	/**
	 * Helper class for the {@link bind} function.
	 */
	var ProviderBuilder = (function () {
	    function ProviderBuilder(token) {
	        this.token = token;
	    }
	    /**
	     * Binds a DI token to a class.
	     *
	     * ### Example ([live demo](http://plnkr.co/edit/ZpBCSYqv6e2ud5KXLdxQ?p=preview))
	     *
	     * Because `toAlias` and `toClass` are often confused, the example contains
	     * both use cases for easy comparison.
	     *
	     * ```typescript
	     * class Vehicle {}
	     *
	     * class Car extends Vehicle {}
	     *
	     * var injectorClass = Injector.resolveAndCreate([
	     *   Car,
	     *   provide(Vehicle, {useClass: Car})
	     * ]);
	     * var injectorAlias = Injector.resolveAndCreate([
	     *   Car,
	     *   provide(Vehicle, {useExisting: Car})
	     * ]);
	     *
	     * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
	     * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
	     *
	     * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
	     * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
	     * ```
	     */
	    ProviderBuilder.prototype.toClass = function (type) {
	        if (!lang_1.isType(type)) {
	            throw new exceptions_1.BaseException("Trying to create a class provider but \"" + lang_1.stringify(type) + "\" is not a class!");
	        }
	        return new Provider(this.token, { useClass: type });
	    };
	    /**
	     * Binds a DI token to a value.
	     *
	     * ### Example ([live demo](http://plnkr.co/edit/G024PFHmDL0cJFgfZK8O?p=preview))
	     *
	     * ```typescript
	     * var injector = Injector.resolveAndCreate([
	     *   provide('message', {useValue: 'Hello'})
	     * ]);
	     *
	     * expect(injector.get('message')).toEqual('Hello');
	     * ```
	     */
	    ProviderBuilder.prototype.toValue = function (value) { return new Provider(this.token, { useValue: value }); };
	    /**
	     * Binds a DI token to an existing token.
	     *
	     * Angular will return the same instance as if the provided token was used. (This is
	     * in contrast to `useClass` where a separate instance of `useClass` will be returned.)
	     *
	     * ### Example ([live demo](http://plnkr.co/edit/uBaoF2pN5cfc5AfZapNw?p=preview))
	     *
	     * Because `toAlias` and `toClass` are often confused, the example contains
	     * both use cases for easy comparison.
	     *
	     * ```typescript
	     * class Vehicle {}
	     *
	     * class Car extends Vehicle {}
	     *
	     * var injectorAlias = Injector.resolveAndCreate([
	     *   Car,
	     *   provide(Vehicle, {useExisting: Car})
	     * ]);
	     * var injectorClass = Injector.resolveAndCreate([
	     *   Car,
	     *   provide(Vehicle, {useClass: Car})
	     * ]);
	     *
	     * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
	     * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
	     *
	     * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
	     * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
	     * ```
	     */
	    ProviderBuilder.prototype.toAlias = function (aliasToken) {
	        if (lang_1.isBlank(aliasToken)) {
	            throw new exceptions_1.BaseException("Can not alias " + lang_1.stringify(this.token) + " to a blank value!");
	        }
	        return new Provider(this.token, { useExisting: aliasToken });
	    };
	    /**
	     * Binds a DI token to a function which computes the value.
	     *
	     * ### Example ([live demo](http://plnkr.co/edit/OejNIfTT3zb1iBxaIYOb?p=preview))
	     *
	     * ```typescript
	     * var injector = Injector.resolveAndCreate([
	     *   provide(Number, {useFactory: () => { return 1+2; }}),
	     *   provide(String, {useFactory: (v) => { return "Value: " + v; }, deps: [Number]})
	     * ]);
	     *
	     * expect(injector.get(Number)).toEqual(3);
	     * expect(injector.get(String)).toEqual('Value: 3');
	     * ```
	     */
	    ProviderBuilder.prototype.toFactory = function (factory, dependencies) {
	        if (!lang_1.isFunction(factory)) {
	            throw new exceptions_1.BaseException("Trying to create a factory provider but \"" + lang_1.stringify(factory) + "\" is not a function!");
	        }
	        return new Provider(this.token, { useFactory: factory, deps: dependencies });
	    };
	    return ProviderBuilder;
	}());
	exports.ProviderBuilder = ProviderBuilder;
	/**
	 * Creates a {@link Provider}.
	 *
	 * See {@link Provider} for more details.
	 *
	 * <!-- TODO: improve the docs -->
	 */
	function provide(token, _a) {
	    var useClass = _a.useClass, useValue = _a.useValue, useExisting = _a.useExisting, useFactory = _a.useFactory, deps = _a.deps, multi = _a.multi;
	    return new Provider(token, {
	        useClass: useClass,
	        useValue: useValue,
	        useExisting: useExisting,
	        useFactory: useFactory,
	        deps: deps,
	        multi: multi
	    });
	}
	exports.provide = provide;


/***/ },
/* 25 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var provider_1 = __webpack_require__(24);
	function isProviderLiteral(obj) {
	    return obj && typeof obj == 'object' && obj.provide;
	}
	exports.isProviderLiteral = isProviderLiteral;
	function createProvider(obj) {
	    return new provider_1.Provider(obj.provide, obj);
	}
	exports.createProvider = createProvider;


/***/ },
/* 26 */
/***/ function(module, exports) {

	"use strict";
	/**
	 * Creates a token that can be used in a DI Provider.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/Ys9ezXpj2Mnoy3Uc8KBp?p=preview))
	 *
	 * ```typescript
	 * var t = new OpaqueToken("value");
	 *
	 * var injector = Injector.resolveAndCreate([
	 *   provide(t, {useValue: "bindingValue"})
	 * ]);
	 *
	 * expect(injector.get(t)).toEqual("bindingValue");
	 * ```
	 *
	 * Using an `OpaqueToken` is preferable to using strings as tokens because of possible collisions
	 * caused by multiple providers using the same string as two different tokens.
	 *
	 * Using an `OpaqueToken` is preferable to using an `Object` as tokens because it provides better
	 * error messages.
	 * @ts2dart_const
	 */
	var OpaqueToken = (function () {
	    function OpaqueToken(_desc) {
	        this._desc = _desc;
	    }
	    OpaqueToken.prototype.toString = function () { return "Token " + this._desc; };
	    return OpaqueToken;
	}());
	exports.OpaqueToken = OpaqueToken;


/***/ },
/* 27 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var metadata_1 = __webpack_require__(7);
	var change_detection_1 = __webpack_require__(28);
	/**
	 * Directives allow you to attach behavior to elements in the DOM.
	 *
	 * {@link DirectiveMetadata}s with an embedded view are called {@link ComponentMetadata}s.
	 *
	 * A directive consists of a single directive annotation and a controller class. When the
	 * directive's `selector` matches
	 * elements in the DOM, the following steps occur:
	 *
	 * 1. For each directive, the `ElementInjector` attempts to resolve the directive's constructor
	 * arguments.
	 * 2. Angular instantiates directives for each matched element using `ElementInjector` in a
	 * depth-first order,
	 *    as declared in the HTML.
	 *
	 * ## Understanding How Injection Works
	 *
	 * There are three stages of injection resolution.
	 * - *Pre-existing Injectors*:
	 *   - The terminal {@link Injector} cannot resolve dependencies. It either throws an error or, if
	 * the dependency was
	 *     specified as `@Optional`, returns `null`.
	 *   - The platform injector resolves browser singleton resources, such as: cookies, title,
	 * location, and others.
	 * - *Component Injectors*: Each component instance has its own {@link Injector}, and they follow
	 * the same parent-child hierarchy
	 *     as the component instances in the DOM.
	 * - *Element Injectors*: Each component instance has a Shadow DOM. Within the Shadow DOM each
	 * element has an `ElementInjector`
	 *     which follow the same parent-child hierarchy as the DOM elements themselves.
	 *
	 * When a template is instantiated, it also must instantiate the corresponding directives in a
	 * depth-first order. The
	 * current `ElementInjector` resolves the constructor dependencies for each directive.
	 *
	 * Angular then resolves dependencies as follows, according to the order in which they appear in the
	 * {@link ViewMetadata}:
	 *
	 * 1. Dependencies on the current element
	 * 2. Dependencies on element injectors and their parents until it encounters a Shadow DOM boundary
	 * 3. Dependencies on component injectors and their parents until it encounters the root component
	 * 4. Dependencies on pre-existing injectors
	 *
	 *
	 * The `ElementInjector` can inject other directives, element-specific special objects, or it can
	 * delegate to the parent
	 * injector.
	 *
	 * To inject other directives, declare the constructor parameter as:
	 * - `directive:DirectiveType`: a directive on the current element only
	 * - `@Host() directive:DirectiveType`: any directive that matches the type between the current
	 * element and the
	 *    Shadow DOM root.
	 * - `@Query(DirectiveType) query:QueryList<DirectiveType>`: A live collection of direct child
	 * directives.
	 * - `@QueryDescendants(DirectiveType) query:QueryList<DirectiveType>`: A live collection of any
	 * child directives.
	 *
	 * To inject element-specific special objects, declare the constructor parameter as:
	 * - `element: ElementRef` to obtain a reference to logical element in the view.
	 * - `viewContainer: ViewContainerRef` to control child template instantiation, for
	 * {@link DirectiveMetadata} directives only
	 * - `bindingPropagation: BindingPropagation` to control change detection in a more granular way.
	 *
	 * ### Example
	 *
	 * The following example demonstrates how dependency injection resolves constructor arguments in
	 * practice.
	 *
	 *
	 * Assume this HTML template:
	 *
	 * ```
	 * <div dependency="1">
	 *   <div dependency="2">
	 *     <div dependency="3" my-directive>
	 *       <div dependency="4">
	 *         <div dependency="5"></div>
	 *       </div>
	 *       <div dependency="6"></div>
	 *     </div>
	 *   </div>
	 * </div>
	 * ```
	 *
	 * With the following `dependency` decorator and `SomeService` injectable class.
	 *
	 * ```
	 * @Injectable()
	 * class SomeService {
	 * }
	 *
	 * @Directive({
	 *   selector: '[dependency]',
	 *   inputs: [
	 *     'id: dependency'
	 *   ]
	 * })
	 * class Dependency {
	 *   id:string;
	 * }
	 * ```
	 *
	 * Let's step through the different ways in which `MyDirective` could be declared...
	 *
	 *
	 * ### No injection
	 *
	 * Here the constructor is declared with no arguments, therefore nothing is injected into
	 * `MyDirective`.
	 *
	 * ```
	 * @Directive({ selector: '[my-directive]' })
	 * class MyDirective {
	 *   constructor() {
	 *   }
	 * }
	 * ```
	 *
	 * This directive would be instantiated with no dependencies.
	 *
	 *
	 * ### Component-level injection
	 *
	 * Directives can inject any injectable instance from the closest component injector or any of its
	 * parents.
	 *
	 * Here, the constructor declares a parameter, `someService`, and injects the `SomeService` type
	 * from the parent
	 * component's injector.
	 * ```
	 * @Directive({ selector: '[my-directive]' })
	 * class MyDirective {
	 *   constructor(someService: SomeService) {
	 *   }
	 * }
	 * ```
	 *
	 * This directive would be instantiated with a dependency on `SomeService`.
	 *
	 *
	 * ### Injecting a directive from the current element
	 *
	 * Directives can inject other directives declared on the current element.
	 *
	 * ```
	 * @Directive({ selector: '[my-directive]' })
	 * class MyDirective {
	 *   constructor(dependency: Dependency) {
	 *     expect(dependency.id).toEqual(3);
	 *   }
	 * }
	 * ```
	 * This directive would be instantiated with `Dependency` declared at the same element, in this case
	 * `dependency="3"`.
	 *
	 * ### Injecting a directive from any ancestor elements
	 *
	 * Directives can inject other directives declared on any ancestor element (in the current Shadow
	 * DOM), i.e. on the current element, the
	 * parent element, or its parents.
	 * ```
	 * @Directive({ selector: '[my-directive]' })
	 * class MyDirective {
	 *   constructor(@Host() dependency: Dependency) {
	 *     expect(dependency.id).toEqual(2);
	 *   }
	 * }
	 * ```
	 *
	 * `@Host` checks the current element, the parent, as well as its parents recursively. If
	 * `dependency="2"` didn't
	 * exist on the direct parent, this injection would
	 * have returned
	 * `dependency="1"`.
	 *
	 *
	 * ### Injecting a live collection of direct child directives
	 *
	 *
	 * A directive can also query for other child directives. Since parent directives are instantiated
	 * before child directives, a directive can't simply inject the list of child directives. Instead,
	 * the directive injects a {@link QueryList}, which updates its contents as children are added,
	 * removed, or moved by a directive that uses a {@link ViewContainerRef} such as a `ngFor`, an
	 * `ngIf`, or an `ngSwitch`.
	 *
	 * ```
	 * @Directive({ selector: '[my-directive]' })
	 * class MyDirective {
	 *   constructor(@Query(Dependency) dependencies:QueryList<Dependency>) {
	 *   }
	 * }
	 * ```
	 *
	 * This directive would be instantiated with a {@link QueryList} which contains `Dependency` 4 and
	 * `Dependency` 6. Here, `Dependency` 5 would not be included, because it is not a direct child.
	 *
	 * ### Injecting a live collection of descendant directives
	 *
	 * By passing the descendant flag to `@Query` above, we can include the children of the child
	 * elements.
	 *
	 * ```
	 * @Directive({ selector: '[my-directive]' })
	 * class MyDirective {
	 *   constructor(@Query(Dependency, {descendants: true}) dependencies:QueryList<Dependency>) {
	 *   }
	 * }
	 * ```
	 *
	 * This directive would be instantiated with a Query which would contain `Dependency` 4, 5 and 6.
	 *
	 * ### Optional injection
	 *
	 * The normal behavior of directives is to return an error when a specified dependency cannot be
	 * resolved. If you
	 * would like to inject `null` on unresolved dependency instead, you can annotate that dependency
	 * with `@Optional()`.
	 * This explicitly permits the author of a template to treat some of the surrounding directives as
	 * optional.
	 *
	 * ```
	 * @Directive({ selector: '[my-directive]' })
	 * class MyDirective {
	 *   constructor(@Optional() dependency:Dependency) {
	 *   }
	 * }
	 * ```
	 *
	 * This directive would be instantiated with a `Dependency` directive found on the current element.
	 * If none can be
	 * found, the injector supplies `null` instead of throwing an error.
	 *
	 * ### Example
	 *
	 * Here we use a decorator directive to simply define basic tool-tip behavior.
	 *
	 * ```
	 * @Directive({
	 *   selector: '[tooltip]',
	 *   inputs: [
	 *     'text: tooltip'
	 *   ],
	 *   host: {
	 *     '(mouseenter)': 'onMouseEnter()',
	 *     '(mouseleave)': 'onMouseLeave()'
	 *   }
	 * })
	 * class Tooltip{
	 *   text:string;
	 *   overlay:Overlay; // NOT YET IMPLEMENTED
	 *   overlayManager:OverlayManager; // NOT YET IMPLEMENTED
	 *
	 *   constructor(overlayManager:OverlayManager) {
	 *     this.overlay = overlay;
	 *   }
	 *
	 *   onMouseEnter() {
	 *     // exact signature to be determined
	 *     this.overlay = this.overlayManager.open(text, ...);
	 *   }
	 *
	 *   onMouseLeave() {
	 *     this.overlay.close();
	 *     this.overlay = null;
	 *   }
	 * }
	 * ```
	 * In our HTML template, we can then add this behavior to a `<div>` or any other element with the
	 * `tooltip` selector,
	 * like so:
	 *
	 * ```
	 * <div tooltip="some text here"></div>
	 * ```
	 *
	 * Directives can also control the instantiation, destruction, and positioning of inline template
	 * elements:
	 *
	 * A directive uses a {@link ViewContainerRef} to instantiate, insert, move, and destroy views at
	 * runtime.
	 * The {@link ViewContainerRef} is created as a result of `<template>` element, and represents a
	 * location in the current view
	 * where these actions are performed.
	 *
	 * Views are always created as children of the current {@link ViewMetadata}, and as siblings of the
	 * `<template>` element. Thus a
	 * directive in a child view cannot inject the directive that created it.
	 *
	 * Since directives that create views via ViewContainers are common in Angular, and using the full
	 * `<template>` element syntax is wordy, Angular
	 * also supports a shorthand notation: `<li *foo="bar">` and `<li template="foo: bar">` are
	 * equivalent.
	 *
	 * Thus,
	 *
	 * ```
	 * <ul>
	 *   <li *foo="bar" title="text"></li>
	 * </ul>
	 * ```
	 *
	 * Expands in use to:
	 *
	 * ```
	 * <ul>
	 *   <template [foo]="bar">
	 *     <li title="text"></li>
	 *   </template>
	 * </ul>
	 * ```
	 *
	 * Notice that although the shorthand places `*foo="bar"` within the `<li>` element, the binding for
	 * the directive
	 * controller is correctly instantiated on the `<template>` element rather than the `<li>` element.
	 *
	 * ## Lifecycle hooks
	 *
	 * When the directive class implements some {@link ../../guide/lifecycle-hooks.html} the callbacks
	 * are called by the change detection at defined points in time during the life of the directive.
	 *
	 * ### Example
	 *
	 * Let's suppose we want to implement the `unless` behavior, to conditionally include a template.
	 *
	 * Here is a simple directive that triggers on an `unless` selector:
	 *
	 * ```
	 * @Directive({
	 *   selector: '[unless]',
	 *   inputs: ['unless']
	 * })
	 * export class Unless {
	 *   viewContainer: ViewContainerRef;
	 *   templateRef: TemplateRef;
	 *   prevCondition: boolean;
	 *
	 *   constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef) {
	 *     this.viewContainer = viewContainer;
	 *     this.templateRef = templateRef;
	 *     this.prevCondition = null;
	 *   }
	 *
	 *   set unless(newCondition) {
	 *     if (newCondition && (isBlank(this.prevCondition) || !this.prevCondition)) {
	 *       this.prevCondition = true;
	 *       this.viewContainer.clear();
	 *     } else if (!newCondition && (isBlank(this.prevCondition) || this.prevCondition)) {
	 *       this.prevCondition = false;
	 *       this.viewContainer.create(this.templateRef);
	 *     }
	 *   }
	 * }
	 * ```
	 *
	 * We can then use this `unless` selector in a template:
	 * ```
	 * <ul>
	 *   <li *unless="expr"></li>
	 * </ul>
	 * ```
	 *
	 * Once the directive instantiates the child view, the shorthand notation for the template expands
	 * and the result is:
	 *
	 * ```
	 * <ul>
	 *   <template [unless]="exp">
	 *     <li></li>
	 *   </template>
	 *   <li></li>
	 * </ul>
	 * ```
	 *
	 * Note also that although the `<li></li>` template still exists inside the `<template></template>`,
	 * the instantiated
	 * view occurs on the second `<li></li>` which is a sibling to the `<template>` element.
	 * @ts2dart_const
	 */
	var DirectiveMetadata = (function (_super) {
	    __extends(DirectiveMetadata, _super);
	    function DirectiveMetadata(_a) {
	        var _b = _a === void 0 ? {} : _a, selector = _b.selector, inputs = _b.inputs, outputs = _b.outputs, properties = _b.properties, events = _b.events, host = _b.host, bindings = _b.bindings, providers = _b.providers, exportAs = _b.exportAs, queries = _b.queries;
	        _super.call(this);
	        this.selector = selector;
	        this._inputs = inputs;
	        this._properties = properties;
	        this._outputs = outputs;
	        this._events = events;
	        this.host = host;
	        this.exportAs = exportAs;
	        this.queries = queries;
	        this._providers = providers;
	        this._bindings = bindings;
	    }
	    Object.defineProperty(DirectiveMetadata.prototype, "inputs", {
	        /**
	         * Enumerates the set of data-bound input properties for a directive
	         *
	         * Angular automatically updates input properties during change detection.
	         *
	         * The `inputs` property defines a set of `directiveProperty` to `bindingProperty`
	         * configuration:
	         *
	         * - `directiveProperty` specifies the component property where the value is written.
	         * - `bindingProperty` specifies the DOM property where the value is read from.
	         *
	         * When `bindingProperty` is not provided, it is assumed to be equal to `directiveProperty`.
	         *
	         * ### Example ([live demo](http://plnkr.co/edit/ivhfXY?p=preview))
	         *
	         * The following example creates a component with two data-bound properties.
	         *
	         * ```typescript
	         * @Component({
	         *   selector: 'bank-account',
	         *   inputs: ['bankName', 'id: account-id'],
	         *   template: `
	         *     Bank Name: {{bankName}}
	         *     Account Id: {{id}}
	         *   `
	         * })
	         * class BankAccount {
	         *   bankName: string;
	         *   id: string;
	         *
	         *   // this property is not bound, and won't be automatically updated by Angular
	         *   normalizedBankName: string;
	         * }
	         *
	         * @Component({
	         *   selector: 'app',
	         *   template: `
	         *     <bank-account bank-name="RBC" account-id="4747"></bank-account>
	         *   `,
	         *   directives: [BankAccount]
	         * })
	         * class App {}
	         *
	         * bootstrap(App);
	         * ```
	         *
	         */
	        get: function () {
	            return lang_1.isPresent(this._properties) && this._properties.length > 0 ? this._properties :
	                this._inputs;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DirectiveMetadata.prototype, "properties", {
	        get: function () { return this.inputs; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DirectiveMetadata.prototype, "outputs", {
	        /**
	         * Enumerates the set of event-bound output properties.
	         *
	         * When an output property emits an event, an event handler attached to that event
	         * the template is invoked.
	         *
	         * The `outputs` property defines a set of `directiveProperty` to `bindingProperty`
	         * configuration:
	         *
	         * - `directiveProperty` specifies the component property that emits events.
	         * - `bindingProperty` specifies the DOM property the event handler is attached to.
	         *
	         * ### Example ([live demo](http://plnkr.co/edit/d5CNq7?p=preview))
	         *
	         * ```typescript
	         * @Directive({
	         *   selector: 'interval-dir',
	         *   outputs: ['everySecond', 'five5Secs: everyFiveSeconds']
	         * })
	         * class IntervalDir {
	         *   everySecond = new EventEmitter();
	         *   five5Secs = new EventEmitter();
	         *
	         *   constructor() {
	         *     setInterval(() => this.everySecond.emit("event"), 1000);
	         *     setInterval(() => this.five5Secs.emit("event"), 5000);
	         *   }
	         * }
	         *
	         * @Component({
	         *   selector: 'app',
	         *   template: `
	         *     <interval-dir (everySecond)="everySecond()" (everyFiveSeconds)="everyFiveSeconds()">
	         *     </interval-dir>
	         *   `,
	         *   directives: [IntervalDir]
	         * })
	         * class App {
	         *   everySecond() { console.log('second'); }
	         *   everyFiveSeconds() { console.log('five seconds'); }
	         * }
	         * bootstrap(App);
	         * ```
	         *
	         */
	        get: function () {
	            return lang_1.isPresent(this._events) && this._events.length > 0 ? this._events : this._outputs;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DirectiveMetadata.prototype, "events", {
	        get: function () { return this.outputs; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DirectiveMetadata.prototype, "providers", {
	        /**
	         * Defines the set of injectable objects that are visible to a Directive and its light DOM
	         * children.
	         *
	         * ## Simple Example
	         *
	         * Here is an example of a class that can be injected:
	         *
	         * ```
	         * class Greeter {
	         *    greet(name:string) {
	         *      return 'Hello ' + name + '!';
	         *    }
	         * }
	         *
	         * @Directive({
	         *   selector: 'greet',
	         *   bindings: [
	         *     Greeter
	         *   ]
	         * })
	         * class HelloWorld {
	         *   greeter:Greeter;
	         *
	         *   constructor(greeter:Greeter) {
	         *     this.greeter = greeter;
	         *   }
	         * }
	         * ```
	         */
	        get: function () {
	            return lang_1.isPresent(this._bindings) && this._bindings.length > 0 ? this._bindings :
	                this._providers;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DirectiveMetadata.prototype, "bindings", {
	        /** @deprecated */
	        get: function () { return this.providers; },
	        enumerable: true,
	        configurable: true
	    });
	    return DirectiveMetadata;
	}(metadata_1.InjectableMetadata));
	exports.DirectiveMetadata = DirectiveMetadata;
	/**
	 * Declare reusable UI building blocks for an application.
	 *
	 * Each Angular component requires a single `@Component` annotation. The
	 * `@Component`
	 * annotation specifies when a component is instantiated, and which properties and hostListeners it
	 * binds to.
	 *
	 * When a component is instantiated, Angular
	 * - creates a shadow DOM for the component.
	 * - loads the selected template into the shadow DOM.
	 * - creates all the injectable objects configured with `providers` and `viewProviders`.
	 *
	 * All template expressions and statements are then evaluated against the component instance.
	 *
	 * For details on the `@View` annotation, see {@link ViewMetadata}.
	 *
	 * ## Lifecycle hooks
	 *
	 * When the component class implements some {@link ../../guide/lifecycle-hooks.html} the callbacks
	 * are called by the change detection at defined points in time during the life of the component.
	 *
	 * ### Example
	 *
	 * {@example core/ts/metadata/metadata.ts region='component'}
	 * @ts2dart_const
	 */
	var ComponentMetadata = (function (_super) {
	    __extends(ComponentMetadata, _super);
	    function ComponentMetadata(_a) {
	        var _b = _a === void 0 ? {} : _a, selector = _b.selector, inputs = _b.inputs, outputs = _b.outputs, properties = _b.properties, events = _b.events, host = _b.host, exportAs = _b.exportAs, moduleId = _b.moduleId, bindings = _b.bindings, providers = _b.providers, viewBindings = _b.viewBindings, viewProviders = _b.viewProviders, _c = _b.changeDetection, changeDetection = _c === void 0 ? change_detection_1.ChangeDetectionStrategy.Default : _c, queries = _b.queries, templateUrl = _b.templateUrl, template = _b.template, styleUrls = _b.styleUrls, styles = _b.styles, directives = _b.directives, pipes = _b.pipes, encapsulation = _b.encapsulation;
	        _super.call(this, {
	            selector: selector,
	            inputs: inputs,
	            outputs: outputs,
	            properties: properties,
	            events: events,
	            host: host,
	            exportAs: exportAs,
	            bindings: bindings,
	            providers: providers,
	            queries: queries
	        });
	        this.changeDetection = changeDetection;
	        this._viewProviders = viewProviders;
	        this._viewBindings = viewBindings;
	        this.templateUrl = templateUrl;
	        this.template = template;
	        this.styleUrls = styleUrls;
	        this.styles = styles;
	        this.directives = directives;
	        this.pipes = pipes;
	        this.encapsulation = encapsulation;
	        this.moduleId = moduleId;
	    }
	    Object.defineProperty(ComponentMetadata.prototype, "viewProviders", {
	        /**
	         * Defines the set of injectable objects that are visible to its view DOM children.
	         *
	         * ## Simple Example
	         *
	         * Here is an example of a class that can be injected:
	         *
	         * ```
	         * class Greeter {
	         *    greet(name:string) {
	         *      return 'Hello ' + name + '!';
	         *    }
	         * }
	         *
	         * @Directive({
	         *   selector: 'needs-greeter'
	         * })
	         * class NeedsGreeter {
	         *   greeter:Greeter;
	         *
	         *   constructor(greeter:Greeter) {
	         *     this.greeter = greeter;
	         *   }
	         * }
	         *
	         * @Component({
	         *   selector: 'greet',
	         *   viewProviders: [
	         *     Greeter
	         *   ],
	         *   template: `<needs-greeter></needs-greeter>`,
	         *   directives: [NeedsGreeter]
	         * })
	         * class HelloWorld {
	         * }
	         *
	         * ```
	         */
	        get: function () {
	            return lang_1.isPresent(this._viewBindings) && this._viewBindings.length > 0 ? this._viewBindings :
	                this._viewProviders;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ComponentMetadata.prototype, "viewBindings", {
	        get: function () { return this.viewProviders; },
	        enumerable: true,
	        configurable: true
	    });
	    return ComponentMetadata;
	}(DirectiveMetadata));
	exports.ComponentMetadata = ComponentMetadata;
	/**
	 * Declare reusable pipe function.
	 *
	 * A "pure" pipe is only re-evaluated when either the input or any of the arguments change.
	 *
	 * When not specified, pipes default to being pure.
	 *
	 * ### Example
	 *
	 * {@example core/ts/metadata/metadata.ts region='pipe'}
	 * @ts2dart_const
	 */
	var PipeMetadata = (function (_super) {
	    __extends(PipeMetadata, _super);
	    function PipeMetadata(_a) {
	        var name = _a.name, pure = _a.pure;
	        _super.call(this);
	        this.name = name;
	        this._pure = pure;
	    }
	    Object.defineProperty(PipeMetadata.prototype, "pure", {
	        get: function () { return lang_1.isPresent(this._pure) ? this._pure : true; },
	        enumerable: true,
	        configurable: true
	    });
	    return PipeMetadata;
	}(metadata_1.InjectableMetadata));
	exports.PipeMetadata = PipeMetadata;
	/**
	 * Declares a data-bound input property.
	 *
	 * Angular automatically updates data-bound properties during change detection.
	 *
	 * `InputMetadata` takes an optional parameter that specifies the name
	 * used when instantiating a component in the template. When not provided,
	 * the name of the decorated property is used.
	 *
	 * ### Example
	 *
	 * The following example creates a component with two input properties.
	 *
	 * ```typescript
	 * @Component({
	 *   selector: 'bank-account',
	 *   template: `
	 *     Bank Name: {{bankName}}
	 *     Account Id: {{id}}
	 *   `
	 * })
	 * class BankAccount {
	 *   @Input() bankName: string;
	 *   @Input('account-id') id: string;
	 *
	 *   // this property is not bound, and won't be automatically updated by Angular
	 *   normalizedBankName: string;
	 * }
	 *
	 * @Component({
	 *   selector: 'app',
	 *   template: `
	 *     <bank-account bank-name="RBC" account-id="4747"></bank-account>
	 *   `,
	 *   directives: [BankAccount]
	 * })
	 * class App {}
	 *
	 * bootstrap(App);
	 * ```
	 * @ts2dart_const
	 */
	var InputMetadata = (function () {
	    function InputMetadata(
	        /**
	         * Name used when instantiating a component in the template.
	         */
	        bindingPropertyName) {
	        this.bindingPropertyName = bindingPropertyName;
	    }
	    return InputMetadata;
	}());
	exports.InputMetadata = InputMetadata;
	/**
	 * Declares an event-bound output property.
	 *
	 * When an output property emits an event, an event handler attached to that event
	 * the template is invoked.
	 *
	 * `OutputMetadata` takes an optional parameter that specifies the name
	 * used when instantiating a component in the template. When not provided,
	 * the name of the decorated property is used.
	 *
	 * ### Example
	 *
	 * ```typescript
	 * @Directive({
	 *   selector: 'interval-dir',
	 * })
	 * class IntervalDir {
	 *   @Output() everySecond = new EventEmitter();
	 *   @Output('everyFiveSeconds') five5Secs = new EventEmitter();
	 *
	 *   constructor() {
	 *     setInterval(() => this.everySecond.emit("event"), 1000);
	 *     setInterval(() => this.five5Secs.emit("event"), 5000);
	 *   }
	 * }
	 *
	 * @Component({
	 *   selector: 'app',
	 *   template: `
	 *     <interval-dir (everySecond)="everySecond()" (everyFiveSeconds)="everyFiveSeconds()">
	 *     </interval-dir>
	 *   `,
	 *   directives: [IntervalDir]
	 * })
	 * class App {
	 *   everySecond() { console.log('second'); }
	 *   everyFiveSeconds() { console.log('five seconds'); }
	 * }
	 * bootstrap(App);
	 * ```
	 * @ts2dart_const
	 */
	var OutputMetadata = (function () {
	    function OutputMetadata(bindingPropertyName) {
	        this.bindingPropertyName = bindingPropertyName;
	    }
	    return OutputMetadata;
	}());
	exports.OutputMetadata = OutputMetadata;
	/**
	 * Declares a host property binding.
	 *
	 * Angular automatically checks host property bindings during change detection.
	 * If a binding changes, it will update the host element of the directive.
	 *
	 * `HostBindingMetadata` takes an optional parameter that specifies the property
	 * name of the host element that will be updated. When not provided,
	 * the class property name is used.
	 *
	 * ### Example
	 *
	 * The following example creates a directive that sets the `valid` and `invalid` classes
	 * on the DOM element that has ngModel directive on it.
	 *
	 * ```typescript
	 * @Directive({selector: '[ngModel]'})
	 * class NgModelStatus {
	 *   constructor(public control:NgModel) {}
	 *   @HostBinding('class.valid') get valid { return this.control.valid; }
	 *   @HostBinding('class.invalid') get invalid { return this.control.invalid; }
	 * }
	 *
	 * @Component({
	 *   selector: 'app',
	 *   template: `<input [(ngModel)]="prop">`,
	 *   directives: [FORM_DIRECTIVES, NgModelStatus]
	 * })
	 * class App {
	 *   prop;
	 * }
	 *
	 * bootstrap(App);
	 * ```
	 * @ts2dart_const
	 */
	var HostBindingMetadata = (function () {
	    function HostBindingMetadata(hostPropertyName) {
	        this.hostPropertyName = hostPropertyName;
	    }
	    return HostBindingMetadata;
	}());
	exports.HostBindingMetadata = HostBindingMetadata;
	/**
	 * Declares a host listener.
	 *
	 * Angular will invoke the decorated method when the host element emits the specified event.
	 *
	 * If the decorated method returns `false`, then `preventDefault` is applied on the DOM
	 * event.
	 *
	 * ### Example
	 *
	 * The following example declares a directive that attaches a click listener to the button and
	 * counts clicks.
	 *
	 * ```typescript
	 * @Directive({selector: 'button[counting]'})
	 * class CountClicks {
	 *   numberOfClicks = 0;
	 *
	 *   @HostListener('click', ['$event.target'])
	 *   onClick(btn) {
	 *     console.log("button", btn, "number of clicks:", this.numberOfClicks++);
	 *   }
	 * }
	 *
	 * @Component({
	 *   selector: 'app',
	 *   template: `<button counting>Increment</button>`,
	 *   directives: [CountClicks]
	 * })
	 * class App {}
	 *
	 * bootstrap(App);
	 * ```
	 * @ts2dart_const
	 */
	var HostListenerMetadata = (function () {
	    function HostListenerMetadata(eventName, args) {
	        this.eventName = eventName;
	        this.args = args;
	    }
	    return HostListenerMetadata;
	}());
	exports.HostListenerMetadata = HostListenerMetadata;


/***/ },
/* 28 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * @module
	 * @description
	 * Change detection enables data binding in Angular.
	 */
	"use strict";
	var change_detection_1 = __webpack_require__(29);
	exports.ChangeDetectionStrategy = change_detection_1.ChangeDetectionStrategy;
	exports.ChangeDetectorRef = change_detection_1.ChangeDetectorRef;
	exports.WrappedValue = change_detection_1.WrappedValue;
	exports.SimpleChange = change_detection_1.SimpleChange;
	exports.IterableDiffers = change_detection_1.IterableDiffers;
	exports.KeyValueDiffers = change_detection_1.KeyValueDiffers;
	exports.CollectionChangeRecord = change_detection_1.CollectionChangeRecord;
	exports.KeyValueChangeRecord = change_detection_1.KeyValueChangeRecord;


/***/ },
/* 29 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var iterable_differs_1 = __webpack_require__(30);
	var default_iterable_differ_1 = __webpack_require__(31);
	var keyvalue_differs_1 = __webpack_require__(32);
	var default_keyvalue_differ_1 = __webpack_require__(33);
	var default_keyvalue_differ_2 = __webpack_require__(33);
	exports.DefaultKeyValueDifferFactory = default_keyvalue_differ_2.DefaultKeyValueDifferFactory;
	exports.KeyValueChangeRecord = default_keyvalue_differ_2.KeyValueChangeRecord;
	var default_iterable_differ_2 = __webpack_require__(31);
	exports.DefaultIterableDifferFactory = default_iterable_differ_2.DefaultIterableDifferFactory;
	exports.CollectionChangeRecord = default_iterable_differ_2.CollectionChangeRecord;
	var constants_1 = __webpack_require__(34);
	exports.ChangeDetectionStrategy = constants_1.ChangeDetectionStrategy;
	exports.CHANGE_DETECTION_STRATEGY_VALUES = constants_1.CHANGE_DETECTION_STRATEGY_VALUES;
	exports.ChangeDetectorState = constants_1.ChangeDetectorState;
	exports.CHANGE_DETECTOR_STATE_VALUES = constants_1.CHANGE_DETECTOR_STATE_VALUES;
	exports.isDefaultChangeDetectionStrategy = constants_1.isDefaultChangeDetectionStrategy;
	var change_detector_ref_1 = __webpack_require__(35);
	exports.ChangeDetectorRef = change_detector_ref_1.ChangeDetectorRef;
	var iterable_differs_2 = __webpack_require__(30);
	exports.IterableDiffers = iterable_differs_2.IterableDiffers;
	var keyvalue_differs_2 = __webpack_require__(32);
	exports.KeyValueDiffers = keyvalue_differs_2.KeyValueDiffers;
	var change_detection_util_1 = __webpack_require__(36);
	exports.WrappedValue = change_detection_util_1.WrappedValue;
	exports.ValueUnwrapper = change_detection_util_1.ValueUnwrapper;
	exports.SimpleChange = change_detection_util_1.SimpleChange;
	exports.devModeEqual = change_detection_util_1.devModeEqual;
	exports.looseIdentical = change_detection_util_1.looseIdentical;
	exports.uninitialized = change_detection_util_1.uninitialized;
	/**
	 * Structural diffing for `Object`s and `Map`s.
	 */
	exports.keyValDiff = 
	/*@ts2dart_const*/ [new default_keyvalue_differ_1.DefaultKeyValueDifferFactory()];
	/**
	 * Structural diffing for `Iterable` types such as `Array`s.
	 */
	exports.iterableDiff = 
	/*@ts2dart_const*/ [new default_iterable_differ_1.DefaultIterableDifferFactory()];
	exports.defaultIterableDiffers = new iterable_differs_1.IterableDiffers(exports.iterableDiff);
	exports.defaultKeyValueDiffers = new keyvalue_differs_1.KeyValueDiffers(exports.keyValDiff);


/***/ },
/* 30 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var collection_1 = __webpack_require__(15);
	var di_1 = __webpack_require__(6);
	/**
	 * A repository of different iterable diffing strategies used by NgFor, NgClass, and others.
	 * @ts2dart_const
	 */
	var IterableDiffers = (function () {
	    /*@ts2dart_const*/
	    function IterableDiffers(factories) {
	        this.factories = factories;
	    }
	    IterableDiffers.create = function (factories, parent) {
	        if (lang_1.isPresent(parent)) {
	            var copied = collection_1.ListWrapper.clone(parent.factories);
	            factories = factories.concat(copied);
	            return new IterableDiffers(factories);
	        }
	        else {
	            return new IterableDiffers(factories);
	        }
	    };
	    /**
	     * Takes an array of {@link IterableDifferFactory} and returns a provider used to extend the
	     * inherited {@link IterableDiffers} instance with the provided factories and return a new
	     * {@link IterableDiffers} instance.
	     *
	     * The following example shows how to extend an existing list of factories,
	           * which will only be applied to the injector for this component and its children.
	           * This step is all that's required to make a new {@link IterableDiffer} available.
	     *
	     * ### Example
	     *
	     * ```
	     * @Component({
	     *   viewProviders: [
	     *     IterableDiffers.extend([new ImmutableListDiffer()])
	     *   ]
	     * })
	     * ```
	     */
	    IterableDiffers.extend = function (factories) {
	        return new di_1.Provider(IterableDiffers, {
	            useFactory: function (parent) {
	                if (lang_1.isBlank(parent)) {
	                    // Typically would occur when calling IterableDiffers.extend inside of dependencies passed
	                    // to
	                    // bootstrap(), which would override default pipes instead of extending them.
	                    throw new exceptions_1.BaseException('Cannot extend IterableDiffers without a parent injector');
	                }
	                return IterableDiffers.create(factories, parent);
	            },
	            // Dependency technically isn't optional, but we can provide a better error message this way.
	            deps: [[IterableDiffers, new di_1.SkipSelfMetadata(), new di_1.OptionalMetadata()]]
	        });
	    };
	    IterableDiffers.prototype.find = function (iterable) {
	        var factory = this.factories.find(function (f) { return f.supports(iterable); });
	        if (lang_1.isPresent(factory)) {
	            return factory;
	        }
	        else {
	            throw new exceptions_1.BaseException("Cannot find a differ supporting object '" + iterable + "' of type '" + lang_1.getTypeNameForDebugging(iterable) + "'");
	        }
	    };
	    return IterableDiffers;
	}());
	exports.IterableDiffers = IterableDiffers;


/***/ },
/* 31 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var exceptions_1 = __webpack_require__(12);
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	/* @ts2dart_const */
	var DefaultIterableDifferFactory = (function () {
	    function DefaultIterableDifferFactory() {
	    }
	    DefaultIterableDifferFactory.prototype.supports = function (obj) { return collection_1.isListLikeIterable(obj); };
	    DefaultIterableDifferFactory.prototype.create = function (cdRef, trackByFn) {
	        return new DefaultIterableDiffer(trackByFn);
	    };
	    return DefaultIterableDifferFactory;
	}());
	exports.DefaultIterableDifferFactory = DefaultIterableDifferFactory;
	var trackByIdentity = function (index, item) { return item; };
	var DefaultIterableDiffer = (function () {
	    function DefaultIterableDiffer(_trackByFn) {
	        this._trackByFn = _trackByFn;
	        this._length = null;
	        this._collection = null;
	        // Keeps track of the used records at any point in time (during & across `_check()` calls)
	        this._linkedRecords = null;
	        // Keeps track of the removed records at any point in time during `_check()` calls.
	        this._unlinkedRecords = null;
	        this._previousItHead = null;
	        this._itHead = null;
	        this._itTail = null;
	        this._additionsHead = null;
	        this._additionsTail = null;
	        this._movesHead = null;
	        this._movesTail = null;
	        this._removalsHead = null;
	        this._removalsTail = null;
	        // Keeps track of records where custom track by is the same, but item identity has changed
	        this._identityChangesHead = null;
	        this._identityChangesTail = null;
	        this._trackByFn = lang_1.isPresent(this._trackByFn) ? this._trackByFn : trackByIdentity;
	    }
	    Object.defineProperty(DefaultIterableDiffer.prototype, "collection", {
	        get: function () { return this._collection; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DefaultIterableDiffer.prototype, "length", {
	        get: function () { return this._length; },
	        enumerable: true,
	        configurable: true
	    });
	    DefaultIterableDiffer.prototype.forEachItem = function (fn) {
	        var record;
	        for (record = this._itHead; record !== null; record = record._next) {
	            fn(record);
	        }
	    };
	    DefaultIterableDiffer.prototype.forEachPreviousItem = function (fn) {
	        var record;
	        for (record = this._previousItHead; record !== null; record = record._nextPrevious) {
	            fn(record);
	        }
	    };
	    DefaultIterableDiffer.prototype.forEachAddedItem = function (fn) {
	        var record;
	        for (record = this._additionsHead; record !== null; record = record._nextAdded) {
	            fn(record);
	        }
	    };
	    DefaultIterableDiffer.prototype.forEachMovedItem = function (fn) {
	        var record;
	        for (record = this._movesHead; record !== null; record = record._nextMoved) {
	            fn(record);
	        }
	    };
	    DefaultIterableDiffer.prototype.forEachRemovedItem = function (fn) {
	        var record;
	        for (record = this._removalsHead; record !== null; record = record._nextRemoved) {
	            fn(record);
	        }
	    };
	    DefaultIterableDiffer.prototype.forEachIdentityChange = function (fn) {
	        var record;
	        for (record = this._identityChangesHead; record !== null; record = record._nextIdentityChange) {
	            fn(record);
	        }
	    };
	    DefaultIterableDiffer.prototype.diff = function (collection) {
	        if (lang_1.isBlank(collection))
	            collection = [];
	        if (!collection_1.isListLikeIterable(collection)) {
	            throw new exceptions_1.BaseException("Error trying to diff '" + collection + "'");
	        }
	        if (this.check(collection)) {
	            return this;
	        }
	        else {
	            return null;
	        }
	    };
	    DefaultIterableDiffer.prototype.onDestroy = function () { };
	    // todo(vicb): optim for UnmodifiableListView (frozen arrays)
	    DefaultIterableDiffer.prototype.check = function (collection) {
	        var _this = this;
	        this._reset();
	        var record = this._itHead;
	        var mayBeDirty = false;
	        var index;
	        var item;
	        var itemTrackBy;
	        if (lang_1.isArray(collection)) {
	            var list = collection;
	            this._length = collection.length;
	            for (index = 0; index < this._length; index++) {
	                item = list[index];
	                itemTrackBy = this._trackByFn(index, item);
	                if (record === null || !lang_1.looseIdentical(record.trackById, itemTrackBy)) {
	                    record = this._mismatch(record, item, itemTrackBy, index);
	                    mayBeDirty = true;
	                }
	                else {
	                    if (mayBeDirty) {
	                        // TODO(misko): can we limit this to duplicates only?
	                        record = this._verifyReinsertion(record, item, itemTrackBy, index);
	                    }
	                    if (!lang_1.looseIdentical(record.item, item))
	                        this._addIdentityChange(record, item);
	                }
	                record = record._next;
	            }
	        }
	        else {
	            index = 0;
	            collection_1.iterateListLike(collection, function (item) {
	                itemTrackBy = _this._trackByFn(index, item);
	                if (record === null || !lang_1.looseIdentical(record.trackById, itemTrackBy)) {
	                    record = _this._mismatch(record, item, itemTrackBy, index);
	                    mayBeDirty = true;
	                }
	                else {
	                    if (mayBeDirty) {
	                        // TODO(misko): can we limit this to duplicates only?
	                        record = _this._verifyReinsertion(record, item, itemTrackBy, index);
	                    }
	                    if (!lang_1.looseIdentical(record.item, item))
	                        _this._addIdentityChange(record, item);
	                }
	                record = record._next;
	                index++;
	            });
	            this._length = index;
	        }
	        this._truncate(record);
	        this._collection = collection;
	        return this.isDirty;
	    };
	    Object.defineProperty(DefaultIterableDiffer.prototype, "isDirty", {
	        /* CollectionChanges is considered dirty if it has any additions, moves, removals, or identity
	         * changes.
	         */
	        get: function () {
	            return this._additionsHead !== null || this._movesHead !== null ||
	                this._removalsHead !== null || this._identityChangesHead !== null;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    /**
	     * Reset the state of the change objects to show no changes. This means set previousKey to
	     * currentKey, and clear all of the queues (additions, moves, removals).
	     * Set the previousIndexes of moved and added items to their currentIndexes
	     * Reset the list of additions, moves and removals
	     *
	     * @internal
	     */
	    DefaultIterableDiffer.prototype._reset = function () {
	        if (this.isDirty) {
	            var record;
	            var nextRecord;
	            for (record = this._previousItHead = this._itHead; record !== null; record = record._next) {
	                record._nextPrevious = record._next;
	            }
	            for (record = this._additionsHead; record !== null; record = record._nextAdded) {
	                record.previousIndex = record.currentIndex;
	            }
	            this._additionsHead = this._additionsTail = null;
	            for (record = this._movesHead; record !== null; record = nextRecord) {
	                record.previousIndex = record.currentIndex;
	                nextRecord = record._nextMoved;
	            }
	            this._movesHead = this._movesTail = null;
	            this._removalsHead = this._removalsTail = null;
	            this._identityChangesHead = this._identityChangesTail = null;
	        }
	    };
	    /**
	     * This is the core function which handles differences between collections.
	     *
	     * - `record` is the record which we saw at this position last time. If null then it is a new
	     *   item.
	     * - `item` is the current item in the collection
	     * - `index` is the position of the item in the collection
	     *
	     * @internal
	     */
	    DefaultIterableDiffer.prototype._mismatch = function (record, item, itemTrackBy, index) {
	        // The previous record after which we will append the current one.
	        var previousRecord;
	        if (record === null) {
	            previousRecord = this._itTail;
	        }
	        else {
	            previousRecord = record._prev;
	            // Remove the record from the collection since we know it does not match the item.
	            this._remove(record);
	        }
	        // Attempt to see if we have seen the item before.
	        record = this._linkedRecords === null ? null : this._linkedRecords.get(itemTrackBy, index);
	        if (record !== null) {
	            // We have seen this before, we need to move it forward in the collection.
	            // But first we need to check if identity changed, so we can update in view if necessary
	            if (!lang_1.looseIdentical(record.item, item))
	                this._addIdentityChange(record, item);
	            this._moveAfter(record, previousRecord, index);
	        }
	        else {
	            // Never seen it, check evicted list.
	            record = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy);
	            if (record !== null) {
	                // It is an item which we have evicted earlier: reinsert it back into the list.
	                // But first we need to check if identity changed, so we can update in view if necessary
	                if (!lang_1.looseIdentical(record.item, item))
	                    this._addIdentityChange(record, item);
	                this._reinsertAfter(record, previousRecord, index);
	            }
	            else {
	                // It is a new item: add it.
	                record =
	                    this._addAfter(new CollectionChangeRecord(item, itemTrackBy), previousRecord, index);
	            }
	        }
	        return record;
	    };
	    /**
	     * This check is only needed if an array contains duplicates. (Short circuit of nothing dirty)
	     *
	     * Use case: `[a, a]` => `[b, a, a]`
	     *
	     * If we did not have this check then the insertion of `b` would:
	     *   1) evict first `a`
	     *   2) insert `b` at `0` index.
	     *   3) leave `a` at index `1` as is. <-- this is wrong!
	     *   3) reinsert `a` at index 2. <-- this is wrong!
	     *
	     * The correct behavior is:
	     *   1) evict first `a`
	     *   2) insert `b` at `0` index.
	     *   3) reinsert `a` at index 1.
	     *   3) move `a` at from `1` to `2`.
	     *
	     *
	     * Double check that we have not evicted a duplicate item. We need to check if the item type may
	     * have already been removed:
	     * The insertion of b will evict the first 'a'. If we don't reinsert it now it will be reinserted
	     * at the end. Which will show up as the two 'a's switching position. This is incorrect, since a
	     * better way to think of it is as insert of 'b' rather then switch 'a' with 'b' and then add 'a'
	     * at the end.
	     *
	     * @internal
	     */
	    DefaultIterableDiffer.prototype._verifyReinsertion = function (record, item, itemTrackBy, index) {
	        var reinsertRecord = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy);
	        if (reinsertRecord !== null) {
	            record = this._reinsertAfter(reinsertRecord, record._prev, index);
	        }
	        else if (record.currentIndex != index) {
	            record.currentIndex = index;
	            this._addToMoves(record, index);
	        }
	        return record;
	    };
	    /**
	     * Get rid of any excess {@link CollectionChangeRecord}s from the previous collection
	     *
	     * - `record` The first excess {@link CollectionChangeRecord}.
	     *
	     * @internal
	     */
	    DefaultIterableDiffer.prototype._truncate = function (record) {
	        // Anything after that needs to be removed;
	        while (record !== null) {
	            var nextRecord = record._next;
	            this._addToRemovals(this._unlink(record));
	            record = nextRecord;
	        }
	        if (this._unlinkedRecords !== null) {
	            this._unlinkedRecords.clear();
	        }
	        if (this._additionsTail !== null) {
	            this._additionsTail._nextAdded = null;
	        }
	        if (this._movesTail !== null) {
	            this._movesTail._nextMoved = null;
	        }
	        if (this._itTail !== null) {
	            this._itTail._next = null;
	        }
	        if (this._removalsTail !== null) {
	            this._removalsTail._nextRemoved = null;
	        }
	        if (this._identityChangesTail !== null) {
	            this._identityChangesTail._nextIdentityChange = null;
	        }
	    };
	    /** @internal */
	    DefaultIterableDiffer.prototype._reinsertAfter = function (record, prevRecord, index) {
	        if (this._unlinkedRecords !== null) {
	            this._unlinkedRecords.remove(record);
	        }
	        var prev = record._prevRemoved;
	        var next = record._nextRemoved;
	        if (prev === null) {
	            this._removalsHead = next;
	        }
	        else {
	            prev._nextRemoved = next;
	        }
	        if (next === null) {
	            this._removalsTail = prev;
	        }
	        else {
	            next._prevRemoved = prev;
	        }
	        this._insertAfter(record, prevRecord, index);
	        this._addToMoves(record, index);
	        return record;
	    };
	    /** @internal */
	    DefaultIterableDiffer.prototype._moveAfter = function (record, prevRecord, index) {
	        this._unlink(record);
	        this._insertAfter(record, prevRecord, index);
	        this._addToMoves(record, index);
	        return record;
	    };
	    /** @internal */
	    DefaultIterableDiffer.prototype._addAfter = function (record, prevRecord, index) {
	        this._insertAfter(record, prevRecord, index);
	        if (this._additionsTail === null) {
	            // todo(vicb)
	            // assert(this._additionsHead === null);
	            this._additionsTail = this._additionsHead = record;
	        }
	        else {
	            // todo(vicb)
	            // assert(_additionsTail._nextAdded === null);
	            // assert(record._nextAdded === null);
	            this._additionsTail = this._additionsTail._nextAdded = record;
	        }
	        return record;
	    };
	    /** @internal */
	    DefaultIterableDiffer.prototype._insertAfter = function (record, prevRecord, index) {
	        // todo(vicb)
	        // assert(record != prevRecord);
	        // assert(record._next === null);
	        // assert(record._prev === null);
	        var next = prevRecord === null ? this._itHead : prevRecord._next;
	        // todo(vicb)
	        // assert(next != record);
	        // assert(prevRecord != record);
	        record._next = next;
	        record._prev = prevRecord;
	        if (next === null) {
	            this._itTail = record;
	        }
	        else {
	            next._prev = record;
	        }
	        if (prevRecord === null) {
	            this._itHead = record;
	        }
	        else {
	            prevRecord._next = record;
	        }
	        if (this._linkedRecords === null) {
	            this._linkedRecords = new _DuplicateMap();
	        }
	        this._linkedRecords.put(record);
	        record.currentIndex = index;
	        return record;
	    };
	    /** @internal */
	    DefaultIterableDiffer.prototype._remove = function (record) {
	        return this._addToRemovals(this._unlink(record));
	    };
	    /** @internal */
	    DefaultIterableDiffer.prototype._unlink = function (record) {
	        if (this._linkedRecords !== null) {
	            this._linkedRecords.remove(record);
	        }
	        var prev = record._prev;
	        var next = record._next;
	        // todo(vicb)
	        // assert((record._prev = null) === null);
	        // assert((record._next = null) === null);
	        if (prev === null) {
	            this._itHead = next;
	        }
	        else {
	            prev._next = next;
	        }
	        if (next === null) {
	            this._itTail = prev;
	        }
	        else {
	            next._prev = prev;
	        }
	        return record;
	    };
	    /** @internal */
	    DefaultIterableDiffer.prototype._addToMoves = function (record, toIndex) {
	        // todo(vicb)
	        // assert(record._nextMoved === null);
	        if (record.previousIndex === toIndex) {
	            return record;
	        }
	        if (this._movesTail === null) {
	            // todo(vicb)
	            // assert(_movesHead === null);
	            this._movesTail = this._movesHead = record;
	        }
	        else {
	            // todo(vicb)
	            // assert(_movesTail._nextMoved === null);
	            this._movesTail = this._movesTail._nextMoved = record;
	        }
	        return record;
	    };
	    /** @internal */
	    DefaultIterableDiffer.prototype._addToRemovals = function (record) {
	        if (this._unlinkedRecords === null) {
	            this._unlinkedRecords = new _DuplicateMap();
	        }
	        this._unlinkedRecords.put(record);
	        record.currentIndex = null;
	        record._nextRemoved = null;
	        if (this._removalsTail === null) {
	            // todo(vicb)
	            // assert(_removalsHead === null);
	            this._removalsTail = this._removalsHead = record;
	            record._prevRemoved = null;
	        }
	        else {
	            // todo(vicb)
	            // assert(_removalsTail._nextRemoved === null);
	            // assert(record._nextRemoved === null);
	            record._prevRemoved = this._removalsTail;
	            this._removalsTail = this._removalsTail._nextRemoved = record;
	        }
	        return record;
	    };
	    /** @internal */
	    DefaultIterableDiffer.prototype._addIdentityChange = function (record, item) {
	        record.item = item;
	        if (this._identityChangesTail === null) {
	            this._identityChangesTail = this._identityChangesHead = record;
	        }
	        else {
	            this._identityChangesTail = this._identityChangesTail._nextIdentityChange = record;
	        }
	        return record;
	    };
	    DefaultIterableDiffer.prototype.toString = function () {
	        var list = [];
	        this.forEachItem(function (record) { return list.push(record); });
	        var previous = [];
	        this.forEachPreviousItem(function (record) { return previous.push(record); });
	        var additions = [];
	        this.forEachAddedItem(function (record) { return additions.push(record); });
	        var moves = [];
	        this.forEachMovedItem(function (record) { return moves.push(record); });
	        var removals = [];
	        this.forEachRemovedItem(function (record) { return removals.push(record); });
	        var identityChanges = [];
	        this.forEachIdentityChange(function (record) { return identityChanges.push(record); });
	        return "collection: " + list.join(', ') + "\n" + "previous: " + previous.join(', ') + "\n" +
	            "additions: " + additions.join(', ') + "\n" + "moves: " + moves.join(', ') + "\n" +
	            "removals: " + removals.join(', ') + "\n" + "identityChanges: " +
	            identityChanges.join(', ') + "\n";
	    };
	    return DefaultIterableDiffer;
	}());
	exports.DefaultIterableDiffer = DefaultIterableDiffer;
	var CollectionChangeRecord = (function () {
	    function CollectionChangeRecord(item, trackById) {
	        this.item = item;
	        this.trackById = trackById;
	        this.currentIndex = null;
	        this.previousIndex = null;
	        /** @internal */
	        this._nextPrevious = null;
	        /** @internal */
	        this._prev = null;
	        /** @internal */
	        this._next = null;
	        /** @internal */
	        this._prevDup = null;
	        /** @internal */
	        this._nextDup = null;
	        /** @internal */
	        this._prevRemoved = null;
	        /** @internal */
	        this._nextRemoved = null;
	        /** @internal */
	        this._nextAdded = null;
	        /** @internal */
	        this._nextMoved = null;
	        /** @internal */
	        this._nextIdentityChange = null;
	    }
	    CollectionChangeRecord.prototype.toString = function () {
	        return this.previousIndex === this.currentIndex ?
	            lang_1.stringify(this.item) :
	            lang_1.stringify(this.item) + '[' + lang_1.stringify(this.previousIndex) + '->' +
	                lang_1.stringify(this.currentIndex) + ']';
	    };
	    return CollectionChangeRecord;
	}());
	exports.CollectionChangeRecord = CollectionChangeRecord;
	// A linked list of CollectionChangeRecords with the same CollectionChangeRecord.item
	var _DuplicateItemRecordList = (function () {
	    function _DuplicateItemRecordList() {
	        /** @internal */
	        this._head = null;
	        /** @internal */
	        this._tail = null;
	    }
	    /**
	     * Append the record to the list of duplicates.
	     *
	     * Note: by design all records in the list of duplicates hold the same value in record.item.
	     */
	    _DuplicateItemRecordList.prototype.add = function (record) {
	        if (this._head === null) {
	            this._head = this._tail = record;
	            record._nextDup = null;
	            record._prevDup = null;
	        }
	        else {
	            // todo(vicb)
	            // assert(record.item ==  _head.item ||
	            //       record.item is num && record.item.isNaN && _head.item is num && _head.item.isNaN);
	            this._tail._nextDup = record;
	            record._prevDup = this._tail;
	            record._nextDup = null;
	            this._tail = record;
	        }
	    };
	    // Returns a CollectionChangeRecord having CollectionChangeRecord.trackById == trackById and
	    // CollectionChangeRecord.currentIndex >= afterIndex
	    _DuplicateItemRecordList.prototype.get = function (trackById, afterIndex) {
	        var record;
	        for (record = this._head; record !== null; record = record._nextDup) {
	            if ((afterIndex === null || afterIndex < record.currentIndex) &&
	                lang_1.looseIdentical(record.trackById, trackById)) {
	                return record;
	            }
	        }
	        return null;
	    };
	    /**
	     * Remove one {@link CollectionChangeRecord} from the list of duplicates.
	     *
	     * Returns whether the list of duplicates is empty.
	     */
	    _DuplicateItemRecordList.prototype.remove = function (record) {
	        // todo(vicb)
	        // assert(() {
	        //  // verify that the record being removed is in the list.
	        //  for (CollectionChangeRecord cursor = _head; cursor != null; cursor = cursor._nextDup) {
	        //    if (identical(cursor, record)) return true;
	        //  }
	        //  return false;
	        //});
	        var prev = record._prevDup;
	        var next = record._nextDup;
	        if (prev === null) {
	            this._head = next;
	        }
	        else {
	            prev._nextDup = next;
	        }
	        if (next === null) {
	            this._tail = prev;
	        }
	        else {
	            next._prevDup = prev;
	        }
	        return this._head === null;
	    };
	    return _DuplicateItemRecordList;
	}());
	var _DuplicateMap = (function () {
	    function _DuplicateMap() {
	        this.map = new Map();
	    }
	    _DuplicateMap.prototype.put = function (record) {
	        // todo(vicb) handle corner cases
	        var key = lang_1.getMapKey(record.trackById);
	        var duplicates = this.map.get(key);
	        if (!lang_1.isPresent(duplicates)) {
	            duplicates = new _DuplicateItemRecordList();
	            this.map.set(key, duplicates);
	        }
	        duplicates.add(record);
	    };
	    /**
	     * Retrieve the `value` using key. Because the CollectionChangeRecord value may be one which we
	     * have already iterated over, we use the afterIndex to pretend it is not there.
	     *
	     * Use case: `[a, b, c, a, a]` if we are at index `3` which is the second `a` then asking if we
	     * have any more `a`s needs to return the last `a` not the first or second.
	     */
	    _DuplicateMap.prototype.get = function (trackById, afterIndex) {
	        if (afterIndex === void 0) { afterIndex = null; }
	        var key = lang_1.getMapKey(trackById);
	        var recordList = this.map.get(key);
	        return lang_1.isBlank(recordList) ? null : recordList.get(trackById, afterIndex);
	    };
	    /**
	     * Removes a {@link CollectionChangeRecord} from the list of duplicates.
	     *
	     * The list of duplicates also is removed from the map if it gets empty.
	     */
	    _DuplicateMap.prototype.remove = function (record) {
	        var key = lang_1.getMapKey(record.trackById);
	        // todo(vicb)
	        // assert(this.map.containsKey(key));
	        var recordList = this.map.get(key);
	        // Remove the list of duplicates when it gets empty
	        if (recordList.remove(record)) {
	            this.map.delete(key);
	        }
	        return record;
	    };
	    Object.defineProperty(_DuplicateMap.prototype, "isEmpty", {
	        get: function () { return this.map.size === 0; },
	        enumerable: true,
	        configurable: true
	    });
	    _DuplicateMap.prototype.clear = function () { this.map.clear(); };
	    _DuplicateMap.prototype.toString = function () { return '_DuplicateMap(' + lang_1.stringify(this.map) + ')'; };
	    return _DuplicateMap;
	}());


/***/ },
/* 32 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var collection_1 = __webpack_require__(15);
	var di_1 = __webpack_require__(6);
	/**
	 * A repository of different Map diffing strategies used by NgClass, NgStyle, and others.
	 * @ts2dart_const
	 */
	var KeyValueDiffers = (function () {
	    /*@ts2dart_const*/
	    function KeyValueDiffers(factories) {
	        this.factories = factories;
	    }
	    KeyValueDiffers.create = function (factories, parent) {
	        if (lang_1.isPresent(parent)) {
	            var copied = collection_1.ListWrapper.clone(parent.factories);
	            factories = factories.concat(copied);
	            return new KeyValueDiffers(factories);
	        }
	        else {
	            return new KeyValueDiffers(factories);
	        }
	    };
	    /**
	     * Takes an array of {@link KeyValueDifferFactory} and returns a provider used to extend the
	     * inherited {@link KeyValueDiffers} instance with the provided factories and return a new
	     * {@link KeyValueDiffers} instance.
	     *
	     * The following example shows how to extend an existing list of factories,
	           * which will only be applied to the injector for this component and its children.
	           * This step is all that's required to make a new {@link KeyValueDiffer} available.
	     *
	     * ### Example
	     *
	     * ```
	     * @Component({
	     *   viewProviders: [
	     *     KeyValueDiffers.extend([new ImmutableMapDiffer()])
	     *   ]
	     * })
	     * ```
	     */
	    KeyValueDiffers.extend = function (factories) {
	        return new di_1.Provider(KeyValueDiffers, {
	            useFactory: function (parent) {
	                if (lang_1.isBlank(parent)) {
	                    // Typically would occur when calling KeyValueDiffers.extend inside of dependencies passed
	                    // to
	                    // bootstrap(), which would override default pipes instead of extending them.
	                    throw new exceptions_1.BaseException('Cannot extend KeyValueDiffers without a parent injector');
	                }
	                return KeyValueDiffers.create(factories, parent);
	            },
	            // Dependency technically isn't optional, but we can provide a better error message this way.
	            deps: [[KeyValueDiffers, new di_1.SkipSelfMetadata(), new di_1.OptionalMetadata()]]
	        });
	    };
	    KeyValueDiffers.prototype.find = function (kv) {
	        var factory = this.factories.find(function (f) { return f.supports(kv); });
	        if (lang_1.isPresent(factory)) {
	            return factory;
	        }
	        else {
	            throw new exceptions_1.BaseException("Cannot find a differ supporting object '" + kv + "'");
	        }
	    };
	    return KeyValueDiffers;
	}());
	exports.KeyValueDiffers = KeyValueDiffers;


/***/ },
/* 33 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	/* @ts2dart_const */
	var DefaultKeyValueDifferFactory = (function () {
	    function DefaultKeyValueDifferFactory() {
	    }
	    DefaultKeyValueDifferFactory.prototype.supports = function (obj) { return obj instanceof Map || lang_1.isJsObject(obj); };
	    DefaultKeyValueDifferFactory.prototype.create = function (cdRef) { return new DefaultKeyValueDiffer(); };
	    return DefaultKeyValueDifferFactory;
	}());
	exports.DefaultKeyValueDifferFactory = DefaultKeyValueDifferFactory;
	var DefaultKeyValueDiffer = (function () {
	    function DefaultKeyValueDiffer() {
	        this._records = new Map();
	        this._mapHead = null;
	        this._previousMapHead = null;
	        this._changesHead = null;
	        this._changesTail = null;
	        this._additionsHead = null;
	        this._additionsTail = null;
	        this._removalsHead = null;
	        this._removalsTail = null;
	    }
	    Object.defineProperty(DefaultKeyValueDiffer.prototype, "isDirty", {
	        get: function () {
	            return this._additionsHead !== null || this._changesHead !== null ||
	                this._removalsHead !== null;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    DefaultKeyValueDiffer.prototype.forEachItem = function (fn) {
	        var record;
	        for (record = this._mapHead; record !== null; record = record._next) {
	            fn(record);
	        }
	    };
	    DefaultKeyValueDiffer.prototype.forEachPreviousItem = function (fn) {
	        var record;
	        for (record = this._previousMapHead; record !== null; record = record._nextPrevious) {
	            fn(record);
	        }
	    };
	    DefaultKeyValueDiffer.prototype.forEachChangedItem = function (fn) {
	        var record;
	        for (record = this._changesHead; record !== null; record = record._nextChanged) {
	            fn(record);
	        }
	    };
	    DefaultKeyValueDiffer.prototype.forEachAddedItem = function (fn) {
	        var record;
	        for (record = this._additionsHead; record !== null; record = record._nextAdded) {
	            fn(record);
	        }
	    };
	    DefaultKeyValueDiffer.prototype.forEachRemovedItem = function (fn) {
	        var record;
	        for (record = this._removalsHead; record !== null; record = record._nextRemoved) {
	            fn(record);
	        }
	    };
	    DefaultKeyValueDiffer.prototype.diff = function (map) {
	        if (lang_1.isBlank(map))
	            map = collection_1.MapWrapper.createFromPairs([]);
	        if (!(map instanceof Map || lang_1.isJsObject(map))) {
	            throw new exceptions_1.BaseException("Error trying to diff '" + map + "'");
	        }
	        if (this.check(map)) {
	            return this;
	        }
	        else {
	            return null;
	        }
	    };
	    DefaultKeyValueDiffer.prototype.onDestroy = function () { };
	    DefaultKeyValueDiffer.prototype.check = function (map) {
	        var _this = this;
	        this._reset();
	        var records = this._records;
	        var oldSeqRecord = this._mapHead;
	        var lastOldSeqRecord = null;
	        var lastNewSeqRecord = null;
	        var seqChanged = false;
	        this._forEach(map, function (value, key) {
	            var newSeqRecord;
	            if (oldSeqRecord !== null && key === oldSeqRecord.key) {
	                newSeqRecord = oldSeqRecord;
	                if (!lang_1.looseIdentical(value, oldSeqRecord.currentValue)) {
	                    oldSeqRecord.previousValue = oldSeqRecord.currentValue;
	                    oldSeqRecord.currentValue = value;
	                    _this._addToChanges(oldSeqRecord);
	                }
	            }
	            else {
	                seqChanged = true;
	                if (oldSeqRecord !== null) {
	                    oldSeqRecord._next = null;
	                    _this._removeFromSeq(lastOldSeqRecord, oldSeqRecord);
	                    _this._addToRemovals(oldSeqRecord);
	                }
	                if (records.has(key)) {
	                    newSeqRecord = records.get(key);
	                }
	                else {
	                    newSeqRecord = new KeyValueChangeRecord(key);
	                    records.set(key, newSeqRecord);
	                    newSeqRecord.currentValue = value;
	                    _this._addToAdditions(newSeqRecord);
	                }
	            }
	            if (seqChanged) {
	                if (_this._isInRemovals(newSeqRecord)) {
	                    _this._removeFromRemovals(newSeqRecord);
	                }
	                if (lastNewSeqRecord == null) {
	                    _this._mapHead = newSeqRecord;
	                }
	                else {
	                    lastNewSeqRecord._next = newSeqRecord;
	                }
	            }
	            lastOldSeqRecord = oldSeqRecord;
	            lastNewSeqRecord = newSeqRecord;
	            oldSeqRecord = oldSeqRecord === null ? null : oldSeqRecord._next;
	        });
	        this._truncate(lastOldSeqRecord, oldSeqRecord);
	        return this.isDirty;
	    };
	    /** @internal */
	    DefaultKeyValueDiffer.prototype._reset = function () {
	        if (this.isDirty) {
	            var record;
	            // Record the state of the mapping
	            for (record = this._previousMapHead = this._mapHead; record !== null; record = record._next) {
	                record._nextPrevious = record._next;
	            }
	            for (record = this._changesHead; record !== null; record = record._nextChanged) {
	                record.previousValue = record.currentValue;
	            }
	            for (record = this._additionsHead; record != null; record = record._nextAdded) {
	                record.previousValue = record.currentValue;
	            }
	            // todo(vicb) once assert is supported
	            // assert(() {
	            //  var r = _changesHead;
	            //  while (r != null) {
	            //    var nextRecord = r._nextChanged;
	            //    r._nextChanged = null;
	            //    r = nextRecord;
	            //  }
	            //
	            //  r = _additionsHead;
	            //  while (r != null) {
	            //    var nextRecord = r._nextAdded;
	            //    r._nextAdded = null;
	            //    r = nextRecord;
	            //  }
	            //
	            //  r = _removalsHead;
	            //  while (r != null) {
	            //    var nextRecord = r._nextRemoved;
	            //    r._nextRemoved = null;
	            //    r = nextRecord;
	            //  }
	            //
	            //  return true;
	            //});
	            this._changesHead = this._changesTail = null;
	            this._additionsHead = this._additionsTail = null;
	            this._removalsHead = this._removalsTail = null;
	        }
	    };
	    /** @internal */
	    DefaultKeyValueDiffer.prototype._truncate = function (lastRecord, record) {
	        while (record !== null) {
	            if (lastRecord === null) {
	                this._mapHead = null;
	            }
	            else {
	                lastRecord._next = null;
	            }
	            var nextRecord = record._next;
	            // todo(vicb) assert
	            // assert((() {
	            //  record._next = null;
	            //  return true;
	            //}));
	            this._addToRemovals(record);
	            lastRecord = record;
	            record = nextRecord;
	        }
	        for (var rec = this._removalsHead; rec !== null; rec = rec._nextRemoved) {
	            rec.previousValue = rec.currentValue;
	            rec.currentValue = null;
	            this._records.delete(rec.key);
	        }
	    };
	    /** @internal */
	    DefaultKeyValueDiffer.prototype._isInRemovals = function (record) {
	        return record === this._removalsHead || record._nextRemoved !== null ||
	            record._prevRemoved !== null;
	    };
	    /** @internal */
	    DefaultKeyValueDiffer.prototype._addToRemovals = function (record) {
	        // todo(vicb) assert
	        // assert(record._next == null);
	        // assert(record._nextAdded == null);
	        // assert(record._nextChanged == null);
	        // assert(record._nextRemoved == null);
	        // assert(record._prevRemoved == null);
	        if (this._removalsHead === null) {
	            this._removalsHead = this._removalsTail = record;
	        }
	        else {
	            this._removalsTail._nextRemoved = record;
	            record._prevRemoved = this._removalsTail;
	            this._removalsTail = record;
	        }
	    };
	    /** @internal */
	    DefaultKeyValueDiffer.prototype._removeFromSeq = function (prev, record) {
	        var next = record._next;
	        if (prev === null) {
	            this._mapHead = next;
	        }
	        else {
	            prev._next = next;
	        }
	        // todo(vicb) assert
	        // assert((() {
	        //  record._next = null;
	        //  return true;
	        //})());
	    };
	    /** @internal */
	    DefaultKeyValueDiffer.prototype._removeFromRemovals = function (record) {
	        // todo(vicb) assert
	        // assert(record._next == null);
	        // assert(record._nextAdded == null);
	        // assert(record._nextChanged == null);
	        var prev = record._prevRemoved;
	        var next = record._nextRemoved;
	        if (prev === null) {
	            this._removalsHead = next;
	        }
	        else {
	            prev._nextRemoved = next;
	        }
	        if (next === null) {
	            this._removalsTail = prev;
	        }
	        else {
	            next._prevRemoved = prev;
	        }
	        record._prevRemoved = record._nextRemoved = null;
	    };
	    /** @internal */
	    DefaultKeyValueDiffer.prototype._addToAdditions = function (record) {
	        // todo(vicb): assert
	        // assert(record._next == null);
	        // assert(record._nextAdded == null);
	        // assert(record._nextChanged == null);
	        // assert(record._nextRemoved == null);
	        // assert(record._prevRemoved == null);
	        if (this._additionsHead === null) {
	            this._additionsHead = this._additionsTail = record;
	        }
	        else {
	            this._additionsTail._nextAdded = record;
	            this._additionsTail = record;
	        }
	    };
	    /** @internal */
	    DefaultKeyValueDiffer.prototype._addToChanges = function (record) {
	        // todo(vicb) assert
	        // assert(record._nextAdded == null);
	        // assert(record._nextChanged == null);
	        // assert(record._nextRemoved == null);
	        // assert(record._prevRemoved == null);
	        if (this._changesHead === null) {
	            this._changesHead = this._changesTail = record;
	        }
	        else {
	            this._changesTail._nextChanged = record;
	            this._changesTail = record;
	        }
	    };
	    DefaultKeyValueDiffer.prototype.toString = function () {
	        var items = [];
	        var previous = [];
	        var changes = [];
	        var additions = [];
	        var removals = [];
	        var record;
	        for (record = this._mapHead; record !== null; record = record._next) {
	            items.push(lang_1.stringify(record));
	        }
	        for (record = this._previousMapHead; record !== null; record = record._nextPrevious) {
	            previous.push(lang_1.stringify(record));
	        }
	        for (record = this._changesHead; record !== null; record = record._nextChanged) {
	            changes.push(lang_1.stringify(record));
	        }
	        for (record = this._additionsHead; record !== null; record = record._nextAdded) {
	            additions.push(lang_1.stringify(record));
	        }
	        for (record = this._removalsHead; record !== null; record = record._nextRemoved) {
	            removals.push(lang_1.stringify(record));
	        }
	        return "map: " + items.join(', ') + "\n" + "previous: " + previous.join(', ') + "\n" +
	            "additions: " + additions.join(', ') + "\n" + "changes: " + changes.join(', ') + "\n" +
	            "removals: " + removals.join(', ') + "\n";
	    };
	    /** @internal */
	    DefaultKeyValueDiffer.prototype._forEach = function (obj, fn) {
	        if (obj instanceof Map) {
	            obj.forEach(fn);
	        }
	        else {
	            collection_1.StringMapWrapper.forEach(obj, fn);
	        }
	    };
	    return DefaultKeyValueDiffer;
	}());
	exports.DefaultKeyValueDiffer = DefaultKeyValueDiffer;
	var KeyValueChangeRecord = (function () {
	    function KeyValueChangeRecord(key) {
	        this.key = key;
	        this.previousValue = null;
	        this.currentValue = null;
	        /** @internal */
	        this._nextPrevious = null;
	        /** @internal */
	        this._next = null;
	        /** @internal */
	        this._nextAdded = null;
	        /** @internal */
	        this._nextRemoved = null;
	        /** @internal */
	        this._prevRemoved = null;
	        /** @internal */
	        this._nextChanged = null;
	    }
	    KeyValueChangeRecord.prototype.toString = function () {
	        return lang_1.looseIdentical(this.previousValue, this.currentValue) ?
	            lang_1.stringify(this.key) :
	            (lang_1.stringify(this.key) + '[' + lang_1.stringify(this.previousValue) + '->' +
	                lang_1.stringify(this.currentValue) + ']');
	    };
	    return KeyValueChangeRecord;
	}());
	exports.KeyValueChangeRecord = KeyValueChangeRecord;


/***/ },
/* 34 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	/**
	 * Describes the current state of the change detector.
	 */
	(function (ChangeDetectorState) {
	    /**
	     * `NeverChecked` means that the change detector has not been checked yet, and
	     * initialization methods should be called during detection.
	     */
	    ChangeDetectorState[ChangeDetectorState["NeverChecked"] = 0] = "NeverChecked";
	    /**
	     * `CheckedBefore` means that the change detector has successfully completed at least
	     * one detection previously.
	     */
	    ChangeDetectorState[ChangeDetectorState["CheckedBefore"] = 1] = "CheckedBefore";
	    /**
	     * `Errored` means that the change detector encountered an error checking a binding
	     * or calling a directive lifecycle method and is now in an inconsistent state. Change
	     * detectors in this state will no longer detect changes.
	     */
	    ChangeDetectorState[ChangeDetectorState["Errored"] = 2] = "Errored";
	})(exports.ChangeDetectorState || (exports.ChangeDetectorState = {}));
	var ChangeDetectorState = exports.ChangeDetectorState;
	/**
	 * Describes within the change detector which strategy will be used the next time change
	 * detection is triggered.
	 */
	(function (ChangeDetectionStrategy) {
	    /**
	     * `CheckedOnce` means that after calling detectChanges the mode of the change detector
	     * will become `Checked`.
	     */
	    ChangeDetectionStrategy[ChangeDetectionStrategy["CheckOnce"] = 0] = "CheckOnce";
	    /**
	     * `Checked` means that the change detector should be skipped until its mode changes to
	     * `CheckOnce`.
	     */
	    ChangeDetectionStrategy[ChangeDetectionStrategy["Checked"] = 1] = "Checked";
	    /**
	     * `CheckAlways` means that after calling detectChanges the mode of the change detector
	     * will remain `CheckAlways`.
	     */
	    ChangeDetectionStrategy[ChangeDetectionStrategy["CheckAlways"] = 2] = "CheckAlways";
	    /**
	     * `Detached` means that the change detector sub tree is not a part of the main tree and
	     * should be skipped.
	     */
	    ChangeDetectionStrategy[ChangeDetectionStrategy["Detached"] = 3] = "Detached";
	    /**
	     * `OnPush` means that the change detector's mode will be set to `CheckOnce` during hydration.
	     */
	    ChangeDetectionStrategy[ChangeDetectionStrategy["OnPush"] = 4] = "OnPush";
	    /**
	     * `Default` means that the change detector's mode will be set to `CheckAlways` during hydration.
	     */
	    ChangeDetectionStrategy[ChangeDetectionStrategy["Default"] = 5] = "Default";
	})(exports.ChangeDetectionStrategy || (exports.ChangeDetectionStrategy = {}));
	var ChangeDetectionStrategy = exports.ChangeDetectionStrategy;
	/**
	 * List of possible {@link ChangeDetectionStrategy} values.
	 */
	exports.CHANGE_DETECTION_STRATEGY_VALUES = [
	    ChangeDetectionStrategy.CheckOnce,
	    ChangeDetectionStrategy.Checked,
	    ChangeDetectionStrategy.CheckAlways,
	    ChangeDetectionStrategy.Detached,
	    ChangeDetectionStrategy.OnPush,
	    ChangeDetectionStrategy.Default
	];
	/**
	 * List of possible {@link ChangeDetectorState} values.
	 */
	exports.CHANGE_DETECTOR_STATE_VALUES = [
	    ChangeDetectorState.NeverChecked,
	    ChangeDetectorState.CheckedBefore,
	    ChangeDetectorState.Errored
	];
	function isDefaultChangeDetectionStrategy(changeDetectionStrategy) {
	    return lang_1.isBlank(changeDetectionStrategy) ||
	        changeDetectionStrategy === ChangeDetectionStrategy.Default;
	}
	exports.isDefaultChangeDetectionStrategy = isDefaultChangeDetectionStrategy;


/***/ },
/* 35 */
/***/ function(module, exports) {

	"use strict";
	var ChangeDetectorRef = (function () {
	    function ChangeDetectorRef() {
	    }
	    return ChangeDetectorRef;
	}());
	exports.ChangeDetectorRef = ChangeDetectorRef;


/***/ },
/* 36 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var lang_2 = __webpack_require__(5);
	exports.looseIdentical = lang_2.looseIdentical;
	exports.uninitialized = new Object();
	function devModeEqual(a, b) {
	    if (collection_1.isListLikeIterable(a) && collection_1.isListLikeIterable(b)) {
	        return collection_1.areIterablesEqual(a, b, devModeEqual);
	    }
	    else if (!collection_1.isListLikeIterable(a) && !lang_1.isPrimitive(a) && !collection_1.isListLikeIterable(b) &&
	        !lang_1.isPrimitive(b)) {
	        return true;
	    }
	    else {
	        return lang_1.looseIdentical(a, b);
	    }
	}
	exports.devModeEqual = devModeEqual;
	/**
	 * Indicates that the result of a {@link PipeMetadata} transformation has changed even though the
	 * reference
	 * has not changed.
	 *
	 * The wrapped value will be unwrapped by change detection, and the unwrapped value will be stored.
	 *
	 * Example:
	 *
	 * ```
	 * if (this._latestValue === this._latestReturnedValue) {
	 *    return this._latestReturnedValue;
	 *  } else {
	 *    this._latestReturnedValue = this._latestValue;
	 *    return WrappedValue.wrap(this._latestValue); // this will force update
	 *  }
	 * ```
	 */
	var WrappedValue = (function () {
	    function WrappedValue(wrapped) {
	        this.wrapped = wrapped;
	    }
	    WrappedValue.wrap = function (value) { return new WrappedValue(value); };
	    return WrappedValue;
	}());
	exports.WrappedValue = WrappedValue;
	/**
	 * Helper class for unwrapping WrappedValue s
	 */
	var ValueUnwrapper = (function () {
	    function ValueUnwrapper() {
	        this.hasWrappedValue = false;
	    }
	    ValueUnwrapper.prototype.unwrap = function (value) {
	        if (value instanceof WrappedValue) {
	            this.hasWrappedValue = true;
	            return value.wrapped;
	        }
	        return value;
	    };
	    ValueUnwrapper.prototype.reset = function () { this.hasWrappedValue = false; };
	    return ValueUnwrapper;
	}());
	exports.ValueUnwrapper = ValueUnwrapper;
	/**
	 * Represents a basic change from a previous to a new value.
	 */
	var SimpleChange = (function () {
	    function SimpleChange(previousValue, currentValue) {
	        this.previousValue = previousValue;
	        this.currentValue = currentValue;
	    }
	    /**
	     * Check whether the new value is the first value assigned.
	     */
	    SimpleChange.prototype.isFirstChange = function () { return this.previousValue === exports.uninitialized; };
	    return SimpleChange;
	}());
	exports.SimpleChange = SimpleChange;


/***/ },
/* 37 */
/***/ function(module, exports) {

	"use strict";
	/**
	 * Defines template and style encapsulation options available for Component's {@link View}.
	 *
	 * See {@link ViewMetadata#encapsulation}.
	 */
	(function (ViewEncapsulation) {
	    /**
	     * Emulate `Native` scoping of styles by adding an attribute containing surrogate id to the Host
	     * Element and pre-processing the style rules provided via
	     * {@link ViewMetadata#styles} or {@link ViewMetadata#stylesUrls}, and adding the new Host Element
	     * attribute to all selectors.
	     *
	     * This is the default option.
	     */
	    ViewEncapsulation[ViewEncapsulation["Emulated"] = 0] = "Emulated";
	    /**
	     * Use the native encapsulation mechanism of the renderer.
	     *
	     * For the DOM this means using [Shadow DOM](https://w3c.github.io/webcomponents/spec/shadow/) and
	     * creating a ShadowRoot for Component's Host Element.
	     */
	    ViewEncapsulation[ViewEncapsulation["Native"] = 1] = "Native";
	    /**
	     * Don't provide any template or style encapsulation.
	     */
	    ViewEncapsulation[ViewEncapsulation["None"] = 2] = "None";
	})(exports.ViewEncapsulation || (exports.ViewEncapsulation = {}));
	var ViewEncapsulation = exports.ViewEncapsulation;
	exports.VIEW_ENCAPSULATION_VALUES = [ViewEncapsulation.Emulated, ViewEncapsulation.Native, ViewEncapsulation.None];
	/**
	 * Metadata properties available for configuring Views.
	 *
	 * Each Angular component requires a single `@Component` and at least one `@View` annotation. The
	 * `@View` annotation specifies the HTML template to use, and lists the directives that are active
	 * within the template.
	 *
	 * When a component is instantiated, the template is loaded into the component's shadow root, and
	 * the expressions and statements in the template are evaluated against the component.
	 *
	 * For details on the `@Component` annotation, see {@link ComponentMetadata}.
	 *
	 * ### Example
	 *
	 * ```
	 * @Component({
	 *   selector: 'greet',
	 *   template: 'Hello {{name}}!',
	 *   directives: [GreetUser, Bold]
	 * })
	 * class Greet {
	 *   name: string;
	 *
	 *   constructor() {
	 *     this.name = 'World';
	 *   }
	 * }
	 * ```
	 * @ts2dart_const
	 */
	var ViewMetadata = (function () {
	    function ViewMetadata(_a) {
	        var _b = _a === void 0 ? {} : _a, templateUrl = _b.templateUrl, template = _b.template, directives = _b.directives, pipes = _b.pipes, encapsulation = _b.encapsulation, styles = _b.styles, styleUrls = _b.styleUrls;
	        this.templateUrl = templateUrl;
	        this.template = template;
	        this.styleUrls = styleUrls;
	        this.styles = styles;
	        this.directives = directives;
	        this.pipes = pipes;
	        this.encapsulation = encapsulation;
	    }
	    return ViewMetadata;
	}());
	exports.ViewMetadata = ViewMetadata;


/***/ },
/* 38 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	// Public API for util
	var decorators_1 = __webpack_require__(9);
	exports.Class = decorators_1.Class;


/***/ },
/* 39 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	exports.enableProdMode = lang_1.enableProdMode;


/***/ },
/* 40 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	// Public API for Facade
	var lang_1 = __webpack_require__(5);
	exports.Type = lang_1.Type;
	var async_1 = __webpack_require__(41);
	exports.EventEmitter = async_1.EventEmitter;
	var exceptions_1 = __webpack_require__(12);
	exports.WrappedException = exceptions_1.WrappedException;
	var exception_handler_1 = __webpack_require__(14);
	exports.ExceptionHandler = exception_handler_1.ExceptionHandler;


/***/ },
/* 41 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var promise_1 = __webpack_require__(42);
	exports.PromiseWrapper = promise_1.PromiseWrapper;
	exports.PromiseCompleter = promise_1.PromiseCompleter;
	var Subject_1 = __webpack_require__(43);
	var PromiseObservable_1 = __webpack_require__(44);
	var toPromise_1 = __webpack_require__(60);
	var Observable_1 = __webpack_require__(43);
	exports.Observable = Observable_1.Observable;
	var Subject_2 = __webpack_require__(43);
	exports.Subject = Subject_2.Subject;
	var TimerWrapper = (function () {
	    function TimerWrapper() {
	    }
	    TimerWrapper.setTimeout = function (fn, millis) {
	        return lang_1.global.setTimeout(fn, millis);
	    };
	    TimerWrapper.clearTimeout = function (id) { lang_1.global.clearTimeout(id); };
	    TimerWrapper.setInterval = function (fn, millis) {
	        return lang_1.global.setInterval(fn, millis);
	    };
	    TimerWrapper.clearInterval = function (id) { lang_1.global.clearInterval(id); };
	    return TimerWrapper;
	}());
	exports.TimerWrapper = TimerWrapper;
	var ObservableWrapper = (function () {
	    function ObservableWrapper() {
	    }
	    // TODO(vsavkin): when we use rxnext, try inferring the generic type from the first arg
	    ObservableWrapper.subscribe = function (emitter, onNext, onError, onComplete) {
	        if (onComplete === void 0) { onComplete = function () { }; }
	        onError = (typeof onError === "function") && onError || lang_1.noop;
	        onComplete = (typeof onComplete === "function") && onComplete || lang_1.noop;
	        return emitter.subscribe({ next: onNext, error: onError, complete: onComplete });
	    };
	    ObservableWrapper.isObservable = function (obs) { return !!obs.subscribe; };
	    /**
	     * Returns whether `obs` has any subscribers listening to events.
	     */
	    ObservableWrapper.hasSubscribers = function (obs) { return obs.observers.length > 0; };
	    ObservableWrapper.dispose = function (subscription) { subscription.unsubscribe(); };
	    /**
	     * @deprecated - use callEmit() instead
	     */
	    ObservableWrapper.callNext = function (emitter, value) { emitter.next(value); };
	    ObservableWrapper.callEmit = function (emitter, value) { emitter.emit(value); };
	    ObservableWrapper.callError = function (emitter, error) { emitter.error(error); };
	    ObservableWrapper.callComplete = function (emitter) { emitter.complete(); };
	    ObservableWrapper.fromPromise = function (promise) {
	        return PromiseObservable_1.PromiseObservable.create(promise);
	    };
	    ObservableWrapper.toPromise = function (obj) { return toPromise_1.toPromise.call(obj); };
	    return ObservableWrapper;
	}());
	exports.ObservableWrapper = ObservableWrapper;
	/**
	 * Use by directives and components to emit custom Events.
	 *
	 * ### Examples
	 *
	 * In the following example, `Zippy` alternatively emits `open` and `close` events when its
	 * title gets clicked:
	 *
	 * ```
	 * @Component({
	 *   selector: 'zippy',
	 *   template: `
	 *   <div class="zippy">
	 *     <div (click)="toggle()">Toggle</div>
	 *     <div [hidden]="!visible">
	 *       <ng-content></ng-content>
	 *     </div>
	 *  </div>`})
	 * export class Zippy {
	 *   visible: boolean = true;
	 *   @Output() open: EventEmitter<any> = new EventEmitter();
	 *   @Output() close: EventEmitter<any> = new EventEmitter();
	 *
	 *   toggle() {
	 *     this.visible = !this.visible;
	 *     if (this.visible) {
	 *       this.open.emit(null);
	 *     } else {
	 *       this.close.emit(null);
	 *     }
	 *   }
	 * }
	 * ```
	 *
	 * Use Rx.Observable but provides an adapter to make it work as specified here:
	 * https://github.com/jhusain/observable-spec
	 *
	 * Once a reference implementation of the spec is available, switch to it.
	 */
	var EventEmitter = (function (_super) {
	    __extends(EventEmitter, _super);
	    /**
	     * Creates an instance of [EventEmitter], which depending on [isAsync],
	     * delivers events synchronously or asynchronously.
	     */
	    function EventEmitter(isAsync) {
	        if (isAsync === void 0) { isAsync = true; }
	        _super.call(this);
	        this._isAsync = isAsync;
	    }
	    EventEmitter.prototype.emit = function (value) { _super.prototype.next.call(this, value); };
	    /**
	     * @deprecated - use .emit(value) instead
	     */
	    EventEmitter.prototype.next = function (value) { _super.prototype.next.call(this, value); };
	    EventEmitter.prototype.subscribe = function (generatorOrNext, error, complete) {
	        var schedulerFn;
	        var errorFn = function (err) { return null; };
	        var completeFn = function () { return null; };
	        if (generatorOrNext && typeof generatorOrNext === 'object') {
	            schedulerFn = this._isAsync ? function (value) { setTimeout(function () { return generatorOrNext.next(value); }); } :
	                function (value) { generatorOrNext.next(value); };
	            if (generatorOrNext.error) {
	                errorFn = this._isAsync ? function (err) { setTimeout(function () { return generatorOrNext.error(err); }); } :
	                    function (err) { generatorOrNext.error(err); };
	            }
	            if (generatorOrNext.complete) {
	                completeFn = this._isAsync ? function () { setTimeout(function () { return generatorOrNext.complete(); }); } :
	                    function () { generatorOrNext.complete(); };
	            }
	        }
	        else {
	            schedulerFn = this._isAsync ? function (value) { setTimeout(function () { return generatorOrNext(value); }); } :
	                function (value) { generatorOrNext(value); };
	            if (error) {
	                errorFn =
	                    this._isAsync ? function (err) { setTimeout(function () { return error(err); }); } : function (err) { error(err); };
	            }
	            if (complete) {
	                completeFn =
	                    this._isAsync ? function () { setTimeout(function () { return complete(); }); } : function () { complete(); };
	            }
	        }
	        return _super.prototype.subscribe.call(this, schedulerFn, errorFn, completeFn);
	    };
	    return EventEmitter;
	}(Subject_1.Subject));
	exports.EventEmitter = EventEmitter;


/***/ },
/* 42 */
/***/ function(module, exports) {

	"use strict";
	var PromiseCompleter = (function () {
	    function PromiseCompleter() {
	        var _this = this;
	        this.promise = new Promise(function (res, rej) {
	            _this.resolve = res;
	            _this.reject = rej;
	        });
	    }
	    return PromiseCompleter;
	}());
	exports.PromiseCompleter = PromiseCompleter;
	var PromiseWrapper = (function () {
	    function PromiseWrapper() {
	    }
	    PromiseWrapper.resolve = function (obj) { return Promise.resolve(obj); };
	    PromiseWrapper.reject = function (obj, _) { return Promise.reject(obj); };
	    // Note: We can't rename this method into `catch`, as this is not a valid
	    // method name in Dart.
	    PromiseWrapper.catchError = function (promise, onError) {
	        return promise.catch(onError);
	    };
	    PromiseWrapper.all = function (promises) {
	        if (promises.length == 0)
	            return Promise.resolve([]);
	        return Promise.all(promises);
	    };
	    PromiseWrapper.then = function (promise, success, rejection) {
	        return promise.then(success, rejection);
	    };
	    PromiseWrapper.wrap = function (computation) {
	        return new Promise(function (res, rej) {
	            try {
	                res(computation());
	            }
	            catch (e) {
	                rej(e);
	            }
	        });
	    };
	    PromiseWrapper.scheduleMicrotask = function (computation) {
	        PromiseWrapper.then(PromiseWrapper.resolve(null), computation, function (_) { });
	    };
	    PromiseWrapper.isPromise = function (obj) { return obj instanceof Promise; };
	    PromiseWrapper.completer = function () { return new PromiseCompleter(); };
	    return PromiseWrapper;
	}());
	exports.PromiseWrapper = PromiseWrapper;


/***/ },
/* 43 */
/***/ function(module, exports) {

	module.exports = __WEBPACK_EXTERNAL_MODULE_43__;

/***/ },
/* 44 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var root_1 = __webpack_require__(45);
	var Observable_1 = __webpack_require__(47);
	/**
	 * We need this JSDoc comment for affecting ESDoc.
	 * @extends {Ignored}
	 * @hide true
	 */
	var PromiseObservable = (function (_super) {
	    __extends(PromiseObservable, _super);
	    function PromiseObservable(promise, scheduler) {
	        if (scheduler === void 0) { scheduler = null; }
	        _super.call(this);
	        this.promise = promise;
	        this.scheduler = scheduler;
	    }
	    /**
	     * @param promise
	     * @param scheduler
	     * @return {PromiseObservable}
	     * @static true
	     * @name fromPromise
	     * @owner Observable
	     */
	    PromiseObservable.create = function (promise, scheduler) {
	        if (scheduler === void 0) { scheduler = null; }
	        return new PromiseObservable(promise, scheduler);
	    };
	    PromiseObservable.prototype._subscribe = function (subscriber) {
	        var _this = this;
	        var promise = this.promise;
	        var scheduler = this.scheduler;
	        if (scheduler == null) {
	            if (this._isScalar) {
	                if (!subscriber.isUnsubscribed) {
	                    subscriber.next(this.value);
	                    subscriber.complete();
	                }
	            }
	            else {
	                promise.then(function (value) {
	                    _this.value = value;
	                    _this._isScalar = true;
	                    if (!subscriber.isUnsubscribed) {
	                        subscriber.next(value);
	                        subscriber.complete();
	                    }
	                }, function (err) {
	                    if (!subscriber.isUnsubscribed) {
	                        subscriber.error(err);
	                    }
	                })
	                    .then(null, function (err) {
	                    // escape the promise trap, throw unhandled errors
	                    root_1.root.setTimeout(function () { throw err; });
	                });
	            }
	        }
	        else {
	            if (this._isScalar) {
	                if (!subscriber.isUnsubscribed) {
	                    return scheduler.schedule(dispatchNext, 0, { value: this.value, subscriber: subscriber });
	                }
	            }
	            else {
	                promise.then(function (value) {
	                    _this.value = value;
	                    _this._isScalar = true;
	                    if (!subscriber.isUnsubscribed) {
	                        subscriber.add(scheduler.schedule(dispatchNext, 0, { value: value, subscriber: subscriber }));
	                    }
	                }, function (err) {
	                    if (!subscriber.isUnsubscribed) {
	                        subscriber.add(scheduler.schedule(dispatchError, 0, { err: err, subscriber: subscriber }));
	                    }
	                })
	                    .then(null, function (err) {
	                    // escape the promise trap, throw unhandled errors
	                    root_1.root.setTimeout(function () { throw err; });
	                });
	            }
	        }
	    };
	    return PromiseObservable;
	}(Observable_1.Observable));
	exports.PromiseObservable = PromiseObservable;
	function dispatchNext(arg) {
	    var value = arg.value, subscriber = arg.subscriber;
	    if (!subscriber.isUnsubscribed) {
	        subscriber.next(value);
	        subscriber.complete();
	    }
	}
	function dispatchError(arg) {
	    var err = arg.err, subscriber = arg.subscriber;
	    if (!subscriber.isUnsubscribed) {
	        subscriber.error(err);
	    }
	}


/***/ },
/* 45 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(module, global) {"use strict";
	var objectTypes = {
	    'boolean': false,
	    'function': true,
	    'object': true,
	    'number': false,
	    'string': false,
	    'undefined': false
	};
	exports.root = (objectTypes[typeof self] && self) || (objectTypes[typeof window] && window);
	/* tslint:disable:no-unused-variable */
	var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;
	var freeModule = objectTypes[typeof module] && module && !module.nodeType && module;
	var freeGlobal = objectTypes[typeof global] && global;
	if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) {
	    exports.root = freeGlobal;
	}

	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(46)(module), (function() { return this; }())))

/***/ },
/* 46 */
/***/ function(module, exports) {

	module.exports = function(module) {
		if(!module.webpackPolyfill) {
			module.deprecate = function() {};
			module.paths = [];
			// module.parent = undefined by default
			module.children = [];
			module.webpackPolyfill = 1;
		}
		return module;
	}


/***/ },
/* 47 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var root_1 = __webpack_require__(45);
	var observable_1 = __webpack_require__(48);
	var toSubscriber_1 = __webpack_require__(49);
	/**
	 * A representation of any set of values over any amount of time. This the most basic building block
	 * of RxJS.
	 *
	 * @class Observable<T>
	 */
	var Observable = (function () {
	    /**
	     * @constructor
	     * @param {Function} subscribe the function that is  called when the Observable is
	     * initially subscribed to. This function is given a Subscriber, to which new values
	     * can be `next`ed, or an `error` method can be called to raise an error, or
	     * `complete` can be called to notify of a successful completion.
	     */
	    function Observable(subscribe) {
	        this._isScalar = false;
	        if (subscribe) {
	            this._subscribe = subscribe;
	        }
	    }
	    /**
	     * Creates a new Observable, with this Observable as the source, and the passed
	     * operator defined as the new observable's operator.
	     * @method lift
	     * @param {Operator} operator the operator defining the operation to take on the observable
	     * @return {Observable} a new observable with the Operator applied
	     */
	    Observable.prototype.lift = function (operator) {
	        var observable = new Observable();
	        observable.source = this;
	        observable.operator = operator;
	        return observable;
	    };
	    /**
	     * Registers handlers for handling emitted values, error and completions from the observable, and
	     *  executes the observable's subscriber function, which will take action to set up the underlying data stream
	     * @method subscribe
	     * @param {PartialObserver|Function} observerOrNext (optional) either an observer defining all functions to be called,
	     *  or the first of three possible handlers, which is the handler for each value emitted from the observable.
	     * @param {Function} error (optional) a handler for a terminal event resulting from an error. If no error handler is provided,
	     *  the error will be thrown as unhandled
	     * @param {Function} complete (optional) a handler for a terminal event resulting from successful completion.
	     * @return {ISubscription} a subscription reference to the registered handlers
	     */
	    Observable.prototype.subscribe = function (observerOrNext, error, complete) {
	        var operator = this.operator;
	        var sink = toSubscriber_1.toSubscriber(observerOrNext, error, complete);
	        sink.add(operator ? operator.call(sink, this) : this._subscribe(sink));
	        if (sink.syncErrorThrowable) {
	            sink.syncErrorThrowable = false;
	            if (sink.syncErrorThrown) {
	                throw sink.syncErrorValue;
	            }
	        }
	        return sink;
	    };
	    /**
	     * @method forEach
	     * @param {Function} next a handler for each value emitted by the observable
	     * @param {PromiseConstructor} [PromiseCtor] a constructor function used to instantiate the Promise
	     * @return {Promise} a promise that either resolves on observable completion or
	     *  rejects with the handled error
	     */
	    Observable.prototype.forEach = function (next, PromiseCtor) {
	        var _this = this;
	        if (!PromiseCtor) {
	            if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) {
	                PromiseCtor = root_1.root.Rx.config.Promise;
	            }
	            else if (root_1.root.Promise) {
	                PromiseCtor = root_1.root.Promise;
	            }
	        }
	        if (!PromiseCtor) {
	            throw new Error('no Promise impl found');
	        }
	        return new PromiseCtor(function (resolve, reject) {
	            var subscription = _this.subscribe(function (value) {
	                if (subscription) {
	                    // if there is a subscription, then we can surmise
	                    // the next handling is asynchronous. Any errors thrown
	                    // need to be rejected explicitly and unsubscribe must be
	                    // called manually
	                    try {
	                        next(value);
	                    }
	                    catch (err) {
	                        reject(err);
	                        subscription.unsubscribe();
	                    }
	                }
	                else {
	                    // if there is NO subscription, then we're getting a nexted
	                    // value synchronously during subscription. We can just call it.
	                    // If it errors, Observable's `subscribe` imple will ensure the
	                    // unsubscription logic is called, then synchronously rethrow the error.
	                    // After that, Promise will trap the error and send it
	                    // down the rejection path.
	                    next(value);
	                }
	            }, reject, resolve);
	        });
	    };
	    Observable.prototype._subscribe = function (subscriber) {
	        return this.source.subscribe(subscriber);
	    };
	    /**
	     * An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
	     * @method Symbol.observable
	     * @return {Observable} this instance of the observable
	     */
	    Observable.prototype[observable_1.$$observable] = function () {
	        return this;
	    };
	    // HACK: Since TypeScript inherits static properties too, we have to
	    // fight against TypeScript here so Subject can have a different static create signature
	    /**
	     * Creates a new cold Observable by calling the Observable constructor
	     * @static true
	     * @owner Observable
	     * @method create
	     * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor
	     * @return {Observable} a new cold observable
	     */
	    Observable.create = function (subscribe) {
	        return new Observable(subscribe);
	    };
	    return Observable;
	}());
	exports.Observable = Observable;


/***/ },
/* 48 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var root_1 = __webpack_require__(45);
	var Symbol = root_1.root.Symbol;
	if (typeof Symbol === 'function') {
	    if (Symbol.observable) {
	        exports.$$observable = Symbol.observable;
	    }
	    else {
	        if (typeof Symbol.for === 'function') {
	            exports.$$observable = Symbol.for('observable');
	        }
	        else {
	            exports.$$observable = Symbol('observable');
	        }
	        Symbol.observable = exports.$$observable;
	    }
	}
	else {
	    exports.$$observable = '@@observable';
	}


/***/ },
/* 49 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var Subscriber_1 = __webpack_require__(50);
	var rxSubscriber_1 = __webpack_require__(58);
	function toSubscriber(nextOrObserver, error, complete) {
	    if (nextOrObserver && typeof nextOrObserver === 'object') {
	        if (nextOrObserver instanceof Subscriber_1.Subscriber) {
	            return nextOrObserver;
	        }
	        else if (typeof nextOrObserver[rxSubscriber_1.$$rxSubscriber] === 'function') {
	            return nextOrObserver[rxSubscriber_1.$$rxSubscriber]();
	        }
	    }
	    return new Subscriber_1.Subscriber(nextOrObserver, error, complete);
	}
	exports.toSubscriber = toSubscriber;


/***/ },
/* 50 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var isFunction_1 = __webpack_require__(51);
	var Subscription_1 = __webpack_require__(52);
	var rxSubscriber_1 = __webpack_require__(58);
	var Observer_1 = __webpack_require__(59);
	/**
	 * Implements the {@link Observer} interface and extends the
	 * {@link Subscription} class. While the {@link Observer} is the public API for
	 * consuming the values of an {@link Observable}, all Observers get converted to
	 * a Subscriber, in order to provide Subscription-like capabilities such as
	 * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for
	 * implementing operators, but it is rarely used as a public API.
	 *
	 * @class Subscriber<T>
	 */
	var Subscriber = (function (_super) {
	    __extends(Subscriber, _super);
	    /**
	     * @param {Observer|function(value: T): void} [destinationOrNext] A partially
	     * defined Observer or a `next` callback function.
	     * @param {function(e: ?any): void} [error] The `error` callback of an
	     * Observer.
	     * @param {function(): void} [complete] The `complete` callback of an
	     * Observer.
	     */
	    function Subscriber(destinationOrNext, error, complete) {
	        _super.call(this);
	        this.syncErrorValue = null;
	        this.syncErrorThrown = false;
	        this.syncErrorThrowable = false;
	        this.isStopped = false;
	        switch (arguments.length) {
	            case 0:
	                this.destination = Observer_1.empty;
	                break;
	            case 1:
	                if (!destinationOrNext) {
	                    this.destination = Observer_1.empty;
	                    break;
	                }
	                if (typeof destinationOrNext === 'object') {
	                    if (destinationOrNext instanceof Subscriber) {
	                        this.destination = destinationOrNext;
	                        this.destination.add(this);
	                    }
	                    else {
	                        this.syncErrorThrowable = true;
	                        this.destination = new SafeSubscriber(this, destinationOrNext);
	                    }
	                    break;
	                }
	            default:
	                this.syncErrorThrowable = true;
	                this.destination = new SafeSubscriber(this, destinationOrNext, error, complete);
	                break;
	        }
	    }
	    /**
	     * A static factory for a Subscriber, given a (potentially partial) definition
	     * of an Observer.
	     * @param {function(x: ?T): void} [next] The `next` callback of an Observer.
	     * @param {function(e: ?any): void} [error] The `error` callback of an
	     * Observer.
	     * @param {function(): void} [complete] The `complete` callback of an
	     * Observer.
	     * @return {Subscriber<T>} A Subscriber wrapping the (partially defined)
	     * Observer represented by the given arguments.
	     */
	    Subscriber.create = function (next, error, complete) {
	        var subscriber = new Subscriber(next, error, complete);
	        subscriber.syncErrorThrowable = false;
	        return subscriber;
	    };
	    /**
	     * The {@link Observer} callback to receive notifications of type `next` from
	     * the Observable, with a value. The Observable may call this method 0 or more
	     * times.
	     * @param {T} [value] The `next` value.
	     * @return {void}
	     */
	    Subscriber.prototype.next = function (value) {
	        if (!this.isStopped) {
	            this._next(value);
	        }
	    };
	    /**
	     * The {@link Observer} callback to receive notifications of type `error` from
	     * the Observable, with an attached {@link Error}. Notifies the Observer that
	     * the Observable has experienced an error condition.
	     * @param {any} [err] The `error` exception.
	     * @return {void}
	     */
	    Subscriber.prototype.error = function (err) {
	        if (!this.isStopped) {
	            this.isStopped = true;
	            this._error(err);
	        }
	    };
	    /**
	     * The {@link Observer} callback to receive a valueless notification of type
	     * `complete` from the Observable. Notifies the Observer that the Observable
	     * has finished sending push-based notifications.
	     * @return {void}
	     */
	    Subscriber.prototype.complete = function () {
	        if (!this.isStopped) {
	            this.isStopped = true;
	            this._complete();
	        }
	    };
	    Subscriber.prototype.unsubscribe = function () {
	        if (this.isUnsubscribed) {
	            return;
	        }
	        this.isStopped = true;
	        _super.prototype.unsubscribe.call(this);
	    };
	    Subscriber.prototype._next = function (value) {
	        this.destination.next(value);
	    };
	    Subscriber.prototype._error = function (err) {
	        this.destination.error(err);
	        this.unsubscribe();
	    };
	    Subscriber.prototype._complete = function () {
	        this.destination.complete();
	        this.unsubscribe();
	    };
	    Subscriber.prototype[rxSubscriber_1.$$rxSubscriber] = function () {
	        return this;
	    };
	    return Subscriber;
	}(Subscription_1.Subscription));
	exports.Subscriber = Subscriber;
	/**
	 * We need this JSDoc comment for affecting ESDoc.
	 * @ignore
	 * @extends {Ignored}
	 */
	var SafeSubscriber = (function (_super) {
	    __extends(SafeSubscriber, _super);
	    function SafeSubscriber(_parent, observerOrNext, error, complete) {
	        _super.call(this);
	        this._parent = _parent;
	        var next;
	        var context = this;
	        if (isFunction_1.isFunction(observerOrNext)) {
	            next = observerOrNext;
	        }
	        else if (observerOrNext) {
	            context = observerOrNext;
	            next = observerOrNext.next;
	            error = observerOrNext.error;
	            complete = observerOrNext.complete;
	            if (isFunction_1.isFunction(context.unsubscribe)) {
	                this.add(context.unsubscribe.bind(context));
	            }
	            context.unsubscribe = this.unsubscribe.bind(this);
	        }
	        this._context = context;
	        this._next = next;
	        this._error = error;
	        this._complete = complete;
	    }
	    SafeSubscriber.prototype.next = function (value) {
	        if (!this.isStopped && this._next) {
	            var _parent = this._parent;
	            if (!_parent.syncErrorThrowable) {
	                this.__tryOrUnsub(this._next, value);
	            }
	            else if (this.__tryOrSetError(_parent, this._next, value)) {
	                this.unsubscribe();
	            }
	        }
	    };
	    SafeSubscriber.prototype.error = function (err) {
	        if (!this.isStopped) {
	            var _parent = this._parent;
	            if (this._error) {
	                if (!_parent.syncErrorThrowable) {
	                    this.__tryOrUnsub(this._error, err);
	                    this.unsubscribe();
	                }
	                else {
	                    this.__tryOrSetError(_parent, this._error, err);
	                    this.unsubscribe();
	                }
	            }
	            else if (!_parent.syncErrorThrowable) {
	                this.unsubscribe();
	                throw err;
	            }
	            else {
	                _parent.syncErrorValue = err;
	                _parent.syncErrorThrown = true;
	                this.unsubscribe();
	            }
	        }
	    };
	    SafeSubscriber.prototype.complete = function () {
	        if (!this.isStopped) {
	            var _parent = this._parent;
	            if (this._complete) {
	                if (!_parent.syncErrorThrowable) {
	                    this.__tryOrUnsub(this._complete);
	                    this.unsubscribe();
	                }
	                else {
	                    this.__tryOrSetError(_parent, this._complete);
	                    this.unsubscribe();
	                }
	            }
	            else {
	                this.unsubscribe();
	            }
	        }
	    };
	    SafeSubscriber.prototype.__tryOrUnsub = function (fn, value) {
	        try {
	            fn.call(this._context, value);
	        }
	        catch (err) {
	            this.unsubscribe();
	            throw err;
	        }
	    };
	    SafeSubscriber.prototype.__tryOrSetError = function (parent, fn, value) {
	        try {
	            fn.call(this._context, value);
	        }
	        catch (err) {
	            parent.syncErrorValue = err;
	            parent.syncErrorThrown = true;
	            return true;
	        }
	        return false;
	    };
	    SafeSubscriber.prototype._unsubscribe = function () {
	        var _parent = this._parent;
	        this._context = null;
	        this._parent = null;
	        _parent.unsubscribe();
	    };
	    return SafeSubscriber;
	}(Subscriber));


/***/ },
/* 51 */
/***/ function(module, exports) {

	"use strict";
	function isFunction(x) {
	    return typeof x === 'function';
	}
	exports.isFunction = isFunction;


/***/ },
/* 52 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var isArray_1 = __webpack_require__(53);
	var isObject_1 = __webpack_require__(54);
	var isFunction_1 = __webpack_require__(51);
	var tryCatch_1 = __webpack_require__(55);
	var errorObject_1 = __webpack_require__(56);
	var UnsubscriptionError_1 = __webpack_require__(57);
	/**
	 * Represents a disposable resource, such as the execution of an Observable. A
	 * Subscription has one important method, `unsubscribe`, that takes no argument
	 * and just disposes the resource held by the subscription.
	 *
	 * Additionally, subscriptions may be grouped together through the `add()`
	 * method, which will attach a child Subscription to the current Subscription.
	 * When a Subscription is unsubscribed, all its children (and its grandchildren)
	 * will be unsubscribed as well.
	 *
	 * @class Subscription
	 */
	var Subscription = (function () {
	    /**
	     * @param {function(): void} [unsubscribe] A function describing how to
	     * perform the disposal of resources when the `unsubscribe` method is called.
	     */
	    function Subscription(unsubscribe) {
	        /**
	         * A flag to indicate whether this Subscription has already been unsubscribed.
	         * @type {boolean}
	         */
	        this.isUnsubscribed = false;
	        if (unsubscribe) {
	            this._unsubscribe = unsubscribe;
	        }
	    }
	    /**
	     * Disposes the resources held by the subscription. May, for instance, cancel
	     * an ongoing Observable execution or cancel any other type of work that
	     * started when the Subscription was created.
	     * @return {void}
	     */
	    Subscription.prototype.unsubscribe = function () {
	        var hasErrors = false;
	        var errors;
	        if (this.isUnsubscribed) {
	            return;
	        }
	        this.isUnsubscribed = true;
	        var _a = this, _unsubscribe = _a._unsubscribe, _subscriptions = _a._subscriptions;
	        this._subscriptions = null;
	        if (isFunction_1.isFunction(_unsubscribe)) {
	            var trial = tryCatch_1.tryCatch(_unsubscribe).call(this);
	            if (trial === errorObject_1.errorObject) {
	                hasErrors = true;
	                (errors = errors || []).push(errorObject_1.errorObject.e);
	            }
	        }
	        if (isArray_1.isArray(_subscriptions)) {
	            var index = -1;
	            var len = _subscriptions.length;
	            while (++index < len) {
	                var sub = _subscriptions[index];
	                if (isObject_1.isObject(sub)) {
	                    var trial = tryCatch_1.tryCatch(sub.unsubscribe).call(sub);
	                    if (trial === errorObject_1.errorObject) {
	                        hasErrors = true;
	                        errors = errors || [];
	                        var err = errorObject_1.errorObject.e;
	                        if (err instanceof UnsubscriptionError_1.UnsubscriptionError) {
	                            errors = errors.concat(err.errors);
	                        }
	                        else {
	                            errors.push(err);
	                        }
	                    }
	                }
	            }
	        }
	        if (hasErrors) {
	            throw new UnsubscriptionError_1.UnsubscriptionError(errors);
	        }
	    };
	    /**
	     * Adds a tear down to be called during the unsubscribe() of this
	     * Subscription.
	     *
	     * If the tear down being added is a subscription that is already
	     * unsubscribed, is the same reference `add` is being called on, or is
	     * `Subscription.EMPTY`, it will not be added.
	     *
	     * If this subscription is already in an `isUnsubscribed` state, the passed
	     * tear down logic will be executed immediately.
	     *
	     * @param {TeardownLogic} teardown The additional logic to execute on
	     * teardown.
	     * @return {Subscription} Returns the Subscription used or created to be
	     * added to the inner subscriptions list. This Subscription can be used with
	     * `remove()` to remove the passed teardown logic from the inner subscriptions
	     * list.
	     */
	    Subscription.prototype.add = function (teardown) {
	        if (!teardown || (teardown === this) || (teardown === Subscription.EMPTY)) {
	            return;
	        }
	        var sub = teardown;
	        switch (typeof teardown) {
	            case 'function':
	                sub = new Subscription(teardown);
	            case 'object':
	                if (sub.isUnsubscribed || typeof sub.unsubscribe !== 'function') {
	                    break;
	                }
	                else if (this.isUnsubscribed) {
	                    sub.unsubscribe();
	                }
	                else {
	                    (this._subscriptions || (this._subscriptions = [])).push(sub);
	                }
	                break;
	            default:
	                throw new Error('Unrecognized teardown ' + teardown + ' added to Subscription.');
	        }
	        return sub;
	    };
	    /**
	     * Removes a Subscription from the internal list of subscriptions that will
	     * unsubscribe during the unsubscribe process of this Subscription.
	     * @param {Subscription} subscription The subscription to remove.
	     * @return {void}
	     */
	    Subscription.prototype.remove = function (subscription) {
	        // HACK: This might be redundant because of the logic in `add()`
	        if (subscription == null || (subscription === this) || (subscription === Subscription.EMPTY)) {
	            return;
	        }
	        var subscriptions = this._subscriptions;
	        if (subscriptions) {
	            var subscriptionIndex = subscriptions.indexOf(subscription);
	            if (subscriptionIndex !== -1) {
	                subscriptions.splice(subscriptionIndex, 1);
	            }
	        }
	    };
	    Subscription.EMPTY = (function (empty) {
	        empty.isUnsubscribed = true;
	        return empty;
	    }(new Subscription()));
	    return Subscription;
	}());
	exports.Subscription = Subscription;


/***/ },
/* 53 */
/***/ function(module, exports) {

	"use strict";
	exports.isArray = Array.isArray || (function (x) { return x && typeof x.length === 'number'; });


/***/ },
/* 54 */
/***/ function(module, exports) {

	"use strict";
	function isObject(x) {
	    return x != null && typeof x === 'object';
	}
	exports.isObject = isObject;


/***/ },
/* 55 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var errorObject_1 = __webpack_require__(56);
	var tryCatchTarget;
	function tryCatcher() {
	    try {
	        return tryCatchTarget.apply(this, arguments);
	    }
	    catch (e) {
	        errorObject_1.errorObject.e = e;
	        return errorObject_1.errorObject;
	    }
	}
	function tryCatch(fn) {
	    tryCatchTarget = fn;
	    return tryCatcher;
	}
	exports.tryCatch = tryCatch;
	;


/***/ },
/* 56 */
/***/ function(module, exports) {

	"use strict";
	// typeof any so that it we don't have to cast when comparing a result to the error object
	exports.errorObject = { e: {} };


/***/ },
/* 57 */
/***/ function(module, exports) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	/**
	 * An error thrown when one or more errors have occurred during the
	 * `unsubscribe` of a {@link Subscription}.
	 */
	var UnsubscriptionError = (function (_super) {
	    __extends(UnsubscriptionError, _super);
	    function UnsubscriptionError(errors) {
	        _super.call(this);
	        this.errors = errors;
	        this.name = 'UnsubscriptionError';
	        this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) { return ((i + 1) + ") " + err.toString()); }).join('\n') : '';
	    }
	    return UnsubscriptionError;
	}(Error));
	exports.UnsubscriptionError = UnsubscriptionError;


/***/ },
/* 58 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var root_1 = __webpack_require__(45);
	var Symbol = root_1.root.Symbol;
	exports.$$rxSubscriber = (typeof Symbol === 'function' && typeof Symbol.for === 'function') ?
	    Symbol.for('rxSubscriber') : '@@rxSubscriber';


/***/ },
/* 59 */
/***/ function(module, exports) {

	"use strict";
	exports.empty = {
	    isUnsubscribed: true,
	    next: function (value) { },
	    error: function (err) { throw err; },
	    complete: function () { }
	};


/***/ },
/* 60 */
/***/ function(module, exports) {

	module.exports = __WEBPACK_EXTERNAL_MODULE_60__;

/***/ },
/* 61 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var ng_zone_1 = __webpack_require__(62);
	var lang_1 = __webpack_require__(5);
	var di_1 = __webpack_require__(6);
	var application_tokens_1 = __webpack_require__(64);
	var async_1 = __webpack_require__(41);
	var collection_1 = __webpack_require__(15);
	var testability_1 = __webpack_require__(65);
	var component_resolver_1 = __webpack_require__(66);
	var exceptions_1 = __webpack_require__(12);
	var console_1 = __webpack_require__(77);
	var profile_1 = __webpack_require__(73);
	/**
	 * Create an Angular zone.
	 */
	function createNgZone() {
	    return new ng_zone_1.NgZone({ enableLongStackTrace: lang_1.assertionsEnabled() });
	}
	exports.createNgZone = createNgZone;
	var _platform;
	var _inPlatformCreate = false;
	/**
	 * Creates a platform.
	 * Platforms have to be eagerly created via this function.
	 */
	function createPlatform(injector) {
	    if (_inPlatformCreate) {
	        throw new exceptions_1.BaseException('Already creating a platform...');
	    }
	    if (lang_1.isPresent(_platform) && !_platform.disposed) {
	        throw new exceptions_1.BaseException("There can be only one platform. Destroy the previous one to create a new one.");
	    }
	    lang_1.lockMode();
	    _inPlatformCreate = true;
	    try {
	        _platform = injector.get(PlatformRef);
	    }
	    finally {
	        _inPlatformCreate = false;
	    }
	    return _platform;
	}
	exports.createPlatform = createPlatform;
	/**
	 * Checks that there currently is a platform
	 * which contains the given token as a provider.
	 */
	function assertPlatform(requiredToken) {
	    var platform = getPlatform();
	    if (lang_1.isBlank(platform)) {
	        throw new exceptions_1.BaseException('Not platform exists!');
	    }
	    if (lang_1.isPresent(platform) && lang_1.isBlank(platform.injector.get(requiredToken, null))) {
	        throw new exceptions_1.BaseException('A platform with a different configuration has been created. Please destroy it first.');
	    }
	    return platform;
	}
	exports.assertPlatform = assertPlatform;
	/**
	 * Dispose the existing platform.
	 */
	function disposePlatform() {
	    if (lang_1.isPresent(_platform) && !_platform.disposed) {
	        _platform.dispose();
	    }
	}
	exports.disposePlatform = disposePlatform;
	/**
	 * Returns the current platform.
	 */
	function getPlatform() {
	    return lang_1.isPresent(_platform) && !_platform.disposed ? _platform : null;
	}
	exports.getPlatform = getPlatform;
	/**
	 * Shortcut for ApplicationRef.bootstrap.
	 * Requires a platform the be created first.
	 */
	function coreBootstrap(injector, componentFactory) {
	    var appRef = injector.get(ApplicationRef);
	    return appRef.bootstrap(componentFactory);
	}
	exports.coreBootstrap = coreBootstrap;
	/**
	 * Resolves the componentFactory for the given component,
	 * waits for asynchronous initializers and bootstraps the component.
	 * Requires a platform the be created first.
	 */
	function coreLoadAndBootstrap(injector, componentType) {
	    var appRef = injector.get(ApplicationRef);
	    return appRef.run(function () {
	        var componentResolver = injector.get(component_resolver_1.ComponentResolver);
	        return async_1.PromiseWrapper
	            .all([componentResolver.resolveComponent(componentType), appRef.waitForAsyncInitializers()])
	            .then(function (arr) { return appRef.bootstrap(arr[0]); });
	    });
	}
	exports.coreLoadAndBootstrap = coreLoadAndBootstrap;
	/**
	 * The Angular platform is the entry point for Angular on a web page. Each page
	 * has exactly one platform, and services (such as reflection) which are common
	 * to every Angular application running on the page are bound in its scope.
	 *
	 * A page's platform is initialized implicitly when {@link bootstrap}() is called, or
	 * explicitly by calling {@link createPlatform}().
	 */
	var PlatformRef = (function () {
	    function PlatformRef() {
	    }
	    Object.defineProperty(PlatformRef.prototype, "injector", {
	        /**
	         * Retrieve the platform {@link Injector}, which is the parent injector for
	         * every Angular application on the page and provides singleton providers.
	         */
	        get: function () { throw exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    ;
	    Object.defineProperty(PlatformRef.prototype, "disposed", {
	        get: function () { throw exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    return PlatformRef;
	}());
	exports.PlatformRef = PlatformRef;
	var PlatformRef_ = (function (_super) {
	    __extends(PlatformRef_, _super);
	    function PlatformRef_(_injector) {
	        _super.call(this);
	        this._injector = _injector;
	        /** @internal */
	        this._applications = [];
	        /** @internal */
	        this._disposeListeners = [];
	        this._disposed = false;
	        if (!_inPlatformCreate) {
	            throw new exceptions_1.BaseException('Platforms have to be created via `createPlatform`!');
	        }
	        var inits = _injector.get(application_tokens_1.PLATFORM_INITIALIZER, null);
	        if (lang_1.isPresent(inits))
	            inits.forEach(function (init) { return init(); });
	    }
	    PlatformRef_.prototype.registerDisposeListener = function (dispose) { this._disposeListeners.push(dispose); };
	    Object.defineProperty(PlatformRef_.prototype, "injector", {
	        get: function () { return this._injector; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(PlatformRef_.prototype, "disposed", {
	        get: function () { return this._disposed; },
	        enumerable: true,
	        configurable: true
	    });
	    PlatformRef_.prototype.addApplication = function (appRef) { this._applications.push(appRef); };
	    PlatformRef_.prototype.dispose = function () {
	        collection_1.ListWrapper.clone(this._applications).forEach(function (app) { return app.dispose(); });
	        this._disposeListeners.forEach(function (dispose) { return dispose(); });
	        this._disposed = true;
	    };
	    /** @internal */
	    PlatformRef_.prototype._applicationDisposed = function (app) { collection_1.ListWrapper.remove(this._applications, app); };
	    PlatformRef_ = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [di_1.Injector])
	    ], PlatformRef_);
	    return PlatformRef_;
	}(PlatformRef));
	exports.PlatformRef_ = PlatformRef_;
	/**
	 * A reference to an Angular application running on a page.
	 *
	 * For more about Angular applications, see the documentation for {@link bootstrap}.
	 */
	var ApplicationRef = (function () {
	    function ApplicationRef() {
	    }
	    Object.defineProperty(ApplicationRef.prototype, "injector", {
	        /**
	         * Retrieve the application {@link Injector}.
	         */
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    ;
	    Object.defineProperty(ApplicationRef.prototype, "zone", {
	        /**
	         * Retrieve the application {@link NgZone}.
	         */
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    ;
	    Object.defineProperty(ApplicationRef.prototype, "componentTypes", {
	        /**
	         * Get a list of component types registered to this application.
	         */
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    ;
	    return ApplicationRef;
	}());
	exports.ApplicationRef = ApplicationRef;
	var ApplicationRef_ = (function (_super) {
	    __extends(ApplicationRef_, _super);
	    function ApplicationRef_(_platform, _zone, _injector) {
	        var _this = this;
	        _super.call(this);
	        this._platform = _platform;
	        this._zone = _zone;
	        this._injector = _injector;
	        /** @internal */
	        this._bootstrapListeners = [];
	        /** @internal */
	        this._disposeListeners = [];
	        /** @internal */
	        this._rootComponents = [];
	        /** @internal */
	        this._rootComponentTypes = [];
	        /** @internal */
	        this._changeDetectorRefs = [];
	        /** @internal */
	        this._runningTick = false;
	        /** @internal */
	        this._enforceNoNewChanges = false;
	        var zone = _injector.get(ng_zone_1.NgZone);
	        this._enforceNoNewChanges = lang_1.assertionsEnabled();
	        zone.run(function () { _this._exceptionHandler = _injector.get(exceptions_1.ExceptionHandler); });
	        this._asyncInitDonePromise = this.run(function () {
	            var inits = _injector.get(application_tokens_1.APP_INITIALIZER, null);
	            var asyncInitResults = [];
	            var asyncInitDonePromise;
	            if (lang_1.isPresent(inits)) {
	                for (var i = 0; i < inits.length; i++) {
	                    var initResult = inits[i]();
	                    if (lang_1.isPromise(initResult)) {
	                        asyncInitResults.push(initResult);
	                    }
	                }
	            }
	            if (asyncInitResults.length > 0) {
	                asyncInitDonePromise =
	                    async_1.PromiseWrapper.all(asyncInitResults).then(function (_) { return _this._asyncInitDone = true; });
	                _this._asyncInitDone = false;
	            }
	            else {
	                _this._asyncInitDone = true;
	                asyncInitDonePromise = async_1.PromiseWrapper.resolve(true);
	            }
	            return asyncInitDonePromise;
	        });
	        async_1.ObservableWrapper.subscribe(zone.onError, function (error) {
	            _this._exceptionHandler.call(error.error, error.stackTrace);
	        });
	        async_1.ObservableWrapper.subscribe(this._zone.onMicrotaskEmpty, function (_) { _this._zone.run(function () { _this.tick(); }); });
	    }
	    ApplicationRef_.prototype.registerBootstrapListener = function (listener) {
	        this._bootstrapListeners.push(listener);
	    };
	    ApplicationRef_.prototype.registerDisposeListener = function (dispose) { this._disposeListeners.push(dispose); };
	    ApplicationRef_.prototype.registerChangeDetector = function (changeDetector) {
	        this._changeDetectorRefs.push(changeDetector);
	    };
	    ApplicationRef_.prototype.unregisterChangeDetector = function (changeDetector) {
	        collection_1.ListWrapper.remove(this._changeDetectorRefs, changeDetector);
	    };
	    ApplicationRef_.prototype.waitForAsyncInitializers = function () { return this._asyncInitDonePromise; };
	    ApplicationRef_.prototype.run = function (callback) {
	        var _this = this;
	        var zone = this.injector.get(ng_zone_1.NgZone);
	        var result;
	        // Note: Don't use zone.runGuarded as we want to know about
	        // the thrown exception!
	        // Note: the completer needs to be created outside
	        // of `zone.run` as Dart swallows rejected promises
	        // via the onError callback of the promise.
	        var completer = async_1.PromiseWrapper.completer();
	        zone.run(function () {
	            try {
	                result = callback();
	                if (lang_1.isPromise(result)) {
	                    async_1.PromiseWrapper.then(result, function (ref) { completer.resolve(ref); }, function (err, stackTrace) {
	                        completer.reject(err, stackTrace);
	                        _this._exceptionHandler.call(err, stackTrace);
	                    });
	                }
	            }
	            catch (e) {
	                _this._exceptionHandler.call(e, e.stack);
	                throw e;
	            }
	        });
	        return lang_1.isPromise(result) ? completer.promise : result;
	    };
	    ApplicationRef_.prototype.bootstrap = function (componentFactory) {
	        var _this = this;
	        if (!this._asyncInitDone) {
	            throw new exceptions_1.BaseException('Cannot bootstrap as there are still asynchronous initializers running. Wait for them using waitForAsyncInitializers().');
	        }
	        return this.run(function () {
	            _this._rootComponentTypes.push(componentFactory.componentType);
	            var compRef = componentFactory.create(_this._injector, [], componentFactory.selector);
	            compRef.onDestroy(function () { _this._unloadComponent(compRef); });
	            var testability = compRef.injector.get(testability_1.Testability, null);
	            if (lang_1.isPresent(testability)) {
	                compRef.injector.get(testability_1.TestabilityRegistry)
	                    .registerApplication(compRef.location.nativeElement, testability);
	            }
	            _this._loadComponent(compRef);
	            var c = _this._injector.get(console_1.Console);
	            if (lang_1.assertionsEnabled()) {
	                c.log("Angular 2 is running in the development mode. Call enableProdMode() to enable the production mode.");
	            }
	            return compRef;
	        });
	    };
	    /** @internal */
	    ApplicationRef_.prototype._loadComponent = function (componentRef) {
	        this._changeDetectorRefs.push(componentRef.changeDetectorRef);
	        this.tick();
	        this._rootComponents.push(componentRef);
	        this._bootstrapListeners.forEach(function (listener) { return listener(componentRef); });
	    };
	    /** @internal */
	    ApplicationRef_.prototype._unloadComponent = function (componentRef) {
	        if (!collection_1.ListWrapper.contains(this._rootComponents, componentRef)) {
	            return;
	        }
	        this.unregisterChangeDetector(componentRef.changeDetectorRef);
	        collection_1.ListWrapper.remove(this._rootComponents, componentRef);
	    };
	    Object.defineProperty(ApplicationRef_.prototype, "injector", {
	        get: function () { return this._injector; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ApplicationRef_.prototype, "zone", {
	        get: function () { return this._zone; },
	        enumerable: true,
	        configurable: true
	    });
	    ApplicationRef_.prototype.tick = function () {
	        if (this._runningTick) {
	            throw new exceptions_1.BaseException("ApplicationRef.tick is called recursively");
	        }
	        var s = ApplicationRef_._tickScope();
	        try {
	            this._runningTick = true;
	            this._changeDetectorRefs.forEach(function (detector) { return detector.detectChanges(); });
	            if (this._enforceNoNewChanges) {
	                this._changeDetectorRefs.forEach(function (detector) { return detector.checkNoChanges(); });
	            }
	        }
	        finally {
	            this._runningTick = false;
	            profile_1.wtfLeave(s);
	        }
	    };
	    ApplicationRef_.prototype.dispose = function () {
	        // TODO(alxhub): Dispose of the NgZone.
	        collection_1.ListWrapper.clone(this._rootComponents).forEach(function (ref) { return ref.destroy(); });
	        this._disposeListeners.forEach(function (dispose) { return dispose(); });
	        this._platform._applicationDisposed(this);
	    };
	    Object.defineProperty(ApplicationRef_.prototype, "componentTypes", {
	        get: function () { return this._rootComponentTypes; },
	        enumerable: true,
	        configurable: true
	    });
	    /** @internal */
	    ApplicationRef_._tickScope = profile_1.wtfCreateScope('ApplicationRef#tick()');
	    ApplicationRef_ = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [PlatformRef_, ng_zone_1.NgZone, di_1.Injector])
	    ], ApplicationRef_);
	    return ApplicationRef_;
	}(ApplicationRef));
	exports.ApplicationRef_ = ApplicationRef_;
	/**
	 * @internal
	 */
	exports.PLATFORM_CORE_PROVIDERS = 
	/*@ts2dart_const*/ [
	    PlatformRef_,
	    /*@ts2dart_const*/ (
	    /* @ts2dart_Provider */ { provide: PlatformRef, useExisting: PlatformRef_ })
	];
	/**
	 * @internal
	 */
	exports.APPLICATION_CORE_PROVIDERS = [
	    /* @ts2dart_Provider */ { provide: ng_zone_1.NgZone, useFactory: createNgZone, deps: [] },
	    ApplicationRef_,
	    /* @ts2dart_Provider */ { provide: ApplicationRef, useExisting: ApplicationRef_ }
	];


/***/ },
/* 62 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var async_1 = __webpack_require__(41);
	var ng_zone_impl_1 = __webpack_require__(63);
	var exceptions_1 = __webpack_require__(12);
	var ng_zone_impl_2 = __webpack_require__(63);
	exports.NgZoneError = ng_zone_impl_2.NgZoneError;
	/**
	 * An injectable service for executing work inside or outside of the Angular zone.
	 *
	 * The most common use of this service is to optimize performance when starting a work consisting of
	 * one or more asynchronous tasks that don't require UI updates or error handling to be handled by
	 * Angular. Such tasks can be kicked off via {@link #runOutsideAngular} and if needed, these tasks
	 * can reenter the Angular zone via {@link #run}.
	 *
	 * <!-- TODO: add/fix links to:
	 *   - docs explaining zones and the use of zones in Angular and change-detection
	 *   - link to runOutsideAngular/run (throughout this file!)
	 *   -->
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/lY9m8HLy7z06vDoUaSN2?p=preview))
	 * ```
	 * import {Component, View, NgZone} from 'angular2/core';
	 * import {NgIf} from 'angular2/common';
	 *
	 * @Component({
	 *   selector: 'ng-zone-demo'.
	 *   template: `
	 *     <h2>Demo: NgZone</h2>
	 *
	 *     <p>Progress: {{progress}}%</p>
	 *     <p *ngIf="progress >= 100">Done processing {{label}} of Angular zone!</p>
	 *
	 *     <button (click)="processWithinAngularZone()">Process within Angular zone</button>
	 *     <button (click)="processOutsideOfAngularZone()">Process outside of Angular zone</button>
	 *   `,
	 *   directives: [NgIf]
	 * })
	 * export class NgZoneDemo {
	 *   progress: number = 0;
	 *   label: string;
	 *
	 *   constructor(private _ngZone: NgZone) {}
	 *
	 *   // Loop inside the Angular zone
	 *   // so the UI DOES refresh after each setTimeout cycle
	 *   processWithinAngularZone() {
	 *     this.label = 'inside';
	 *     this.progress = 0;
	 *     this._increaseProgress(() => console.log('Inside Done!'));
	 *   }
	 *
	 *   // Loop outside of the Angular zone
	 *   // so the UI DOES NOT refresh after each setTimeout cycle
	 *   processOutsideOfAngularZone() {
	 *     this.label = 'outside';
	 *     this.progress = 0;
	 *     this._ngZone.runOutsideAngular(() => {
	 *       this._increaseProgress(() => {
	 *       // reenter the Angular zone and display done
	 *       this._ngZone.run(() => {console.log('Outside Done!') });
	 *     }}));
	 *   }
	 *
	 *
	 *   _increaseProgress(doneCallback: () => void) {
	 *     this.progress += 1;
	 *     console.log(`Current progress: ${this.progress}%`);
	 *
	 *     if (this.progress < 100) {
	 *       window.setTimeout(() => this._increaseProgress(doneCallback)), 10)
	 *     } else {
	 *       doneCallback();
	 *     }
	 *   }
	 * }
	 * ```
	 */
	var NgZone = (function () {
	    /**
	     * @param {bool} enableLongStackTrace whether to enable long stack trace. They should only be
	     *               enabled in development mode as they significantly impact perf.
	     */
	    function NgZone(_a) {
	        var _this = this;
	        var _b = _a.enableLongStackTrace, enableLongStackTrace = _b === void 0 ? false : _b;
	        this._hasPendingMicrotasks = false;
	        this._hasPendingMacrotasks = false;
	        /** @internal */
	        this._isStable = true;
	        /** @internal */
	        this._nesting = 0;
	        /** @internal */
	        this._onUnstable = new async_1.EventEmitter(false);
	        /** @internal */
	        this._onMicrotaskEmpty = new async_1.EventEmitter(false);
	        /** @internal */
	        this._onStable = new async_1.EventEmitter(false);
	        /** @internal */
	        this._onErrorEvents = new async_1.EventEmitter(false);
	        this._zoneImpl = new ng_zone_impl_1.NgZoneImpl({
	            trace: enableLongStackTrace,
	            onEnter: function () {
	                // console.log('ZONE.enter', this._nesting, this._isStable);
	                _this._nesting++;
	                if (_this._isStable) {
	                    _this._isStable = false;
	                    _this._onUnstable.emit(null);
	                }
	            },
	            onLeave: function () {
	                _this._nesting--;
	                // console.log('ZONE.leave', this._nesting, this._isStable);
	                _this._checkStable();
	            },
	            setMicrotask: function (hasMicrotasks) {
	                _this._hasPendingMicrotasks = hasMicrotasks;
	                _this._checkStable();
	            },
	            setMacrotask: function (hasMacrotasks) { _this._hasPendingMacrotasks = hasMacrotasks; },
	            onError: function (error) { return _this._onErrorEvents.emit(error); }
	        });
	    }
	    NgZone.isInAngularZone = function () { return ng_zone_impl_1.NgZoneImpl.isInAngularZone(); };
	    NgZone.assertInAngularZone = function () {
	        if (!ng_zone_impl_1.NgZoneImpl.isInAngularZone()) {
	            throw new exceptions_1.BaseException('Expected to be in Angular Zone, but it is not!');
	        }
	    };
	    NgZone.assertNotInAngularZone = function () {
	        if (ng_zone_impl_1.NgZoneImpl.isInAngularZone()) {
	            throw new exceptions_1.BaseException('Expected to not be in Angular Zone, but it is!');
	        }
	    };
	    NgZone.prototype._checkStable = function () {
	        var _this = this;
	        if (this._nesting == 0) {
	            if (!this._hasPendingMicrotasks && !this._isStable) {
	                try {
	                    // console.log('ZONE.microtaskEmpty');
	                    this._nesting++;
	                    this._onMicrotaskEmpty.emit(null);
	                }
	                finally {
	                    this._nesting--;
	                    if (!this._hasPendingMicrotasks) {
	                        try {
	                            // console.log('ZONE.stable', this._nesting, this._isStable);
	                            this.runOutsideAngular(function () { return _this._onStable.emit(null); });
	                        }
	                        finally {
	                            this._isStable = true;
	                        }
	                    }
	                }
	            }
	        }
	    };
	    ;
	    Object.defineProperty(NgZone.prototype, "onUnstable", {
	        /**
	         * Notifies when code enters Angular Zone. This gets fired first on VM Turn.
	         */
	        get: function () { return this._onUnstable; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgZone.prototype, "onMicrotaskEmpty", {
	        /**
	         * Notifies when there is no more microtasks enqueue in the current VM Turn.
	         * This is a hint for Angular to do change detection, which may enqueue more microtasks.
	         * For this reason this event can fire multiple times per VM Turn.
	         */
	        get: function () { return this._onMicrotaskEmpty; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgZone.prototype, "onStable", {
	        /**
	         * Notifies when the last `onMicrotaskEmpty` has run and there are no more microtasks, which
	         * implies we are about to relinquish VM turn.
	         * This event gets called just once.
	         */
	        get: function () { return this._onStable; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgZone.prototype, "onError", {
	        /**
	         * Notify that an error has been delivered.
	         */
	        get: function () { return this._onErrorEvents; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgZone.prototype, "hasPendingMicrotasks", {
	        /**
	         * Whether there are any outstanding microtasks.
	         */
	        get: function () { return this._hasPendingMicrotasks; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgZone.prototype, "hasPendingMacrotasks", {
	        /**
	         * Whether there are any outstanding microtasks.
	         */
	        get: function () { return this._hasPendingMacrotasks; },
	        enumerable: true,
	        configurable: true
	    });
	    /**
	     * Executes the `fn` function synchronously within the Angular zone and returns value returned by
	     * the function.
	     *
	     * Running functions via `run` allows you to reenter Angular zone from a task that was executed
	     * outside of the Angular zone (typically started via {@link #runOutsideAngular}).
	     *
	     * Any future tasks or microtasks scheduled from within this function will continue executing from
	     * within the Angular zone.
	     *
	     * If a synchronous error happens it will be rethrown and not reported via `onError`.
	     */
	    NgZone.prototype.run = function (fn) { return this._zoneImpl.runInner(fn); };
	    /**
	     * Same as #run, except that synchronous errors are caught and forwarded
	     * via `onError` and not rethrown.
	     */
	    NgZone.prototype.runGuarded = function (fn) { return this._zoneImpl.runInnerGuarded(fn); };
	    /**
	     * Executes the `fn` function synchronously in Angular's parent zone and returns value returned by
	     * the function.
	     *
	     * Running functions via `runOutsideAngular` allows you to escape Angular's zone and do work that
	     * doesn't trigger Angular change-detection or is subject to Angular's error handling.
	     *
	     * Any future tasks or microtasks scheduled from within this function will continue executing from
	     * outside of the Angular zone.
	     *
	     * Use {@link #run} to reenter the Angular zone and do work that updates the application model.
	     */
	    NgZone.prototype.runOutsideAngular = function (fn) { return this._zoneImpl.runOuter(fn); };
	    return NgZone;
	}());
	exports.NgZone = NgZone;


/***/ },
/* 63 */
/***/ function(module, exports) {

	"use strict";
	/**
	 * Stores error information; delivered via [NgZone.onError] stream.
	 */
	var NgZoneError = (function () {
	    function NgZoneError(error, stackTrace) {
	        this.error = error;
	        this.stackTrace = stackTrace;
	    }
	    return NgZoneError;
	}());
	exports.NgZoneError = NgZoneError;
	var NgZoneImpl = (function () {
	    function NgZoneImpl(_a) {
	        var _this = this;
	        var trace = _a.trace, onEnter = _a.onEnter, onLeave = _a.onLeave, setMicrotask = _a.setMicrotask, setMacrotask = _a.setMacrotask, onError = _a.onError;
	        this.onEnter = onEnter;
	        this.onLeave = onLeave;
	        this.setMicrotask = setMicrotask;
	        this.setMacrotask = setMacrotask;
	        this.onError = onError;
	        if (Zone) {
	            this.outer = this.inner = Zone.current;
	            if (Zone['wtfZoneSpec']) {
	                this.inner = this.inner.fork(Zone['wtfZoneSpec']);
	            }
	            if (trace && Zone['longStackTraceZoneSpec']) {
	                this.inner = this.inner.fork(Zone['longStackTraceZoneSpec']);
	            }
	            this.inner = this.inner.fork({
	                name: 'angular',
	                properties: { 'isAngularZone': true },
	                onInvokeTask: function (delegate, current, target, task, applyThis, applyArgs) {
	                    try {
	                        _this.onEnter();
	                        return delegate.invokeTask(target, task, applyThis, applyArgs);
	                    }
	                    finally {
	                        _this.onLeave();
	                    }
	                },
	                onInvoke: function (delegate, current, target, callback, applyThis, applyArgs, source) {
	                    try {
	                        _this.onEnter();
	                        return delegate.invoke(target, callback, applyThis, applyArgs, source);
	                    }
	                    finally {
	                        _this.onLeave();
	                    }
	                },
	                onHasTask: function (delegate, current, target, hasTaskState) {
	                    delegate.hasTask(target, hasTaskState);
	                    if (current == target) {
	                        // We are only interested in hasTask events which originate from our zone
	                        // (A child hasTask event is not interesting to us)
	                        if (hasTaskState.change == 'microTask') {
	                            _this.setMicrotask(hasTaskState.microTask);
	                        }
	                        else if (hasTaskState.change == 'macroTask') {
	                            _this.setMacrotask(hasTaskState.macroTask);
	                        }
	                    }
	                },
	                onHandleError: function (delegate, current, target, error) {
	                    delegate.handleError(target, error);
	                    _this.onError(new NgZoneError(error, error.stack));
	                    return false;
	                }
	            });
	        }
	        else {
	            throw new Error('Angular2 needs to be run with Zone.js polyfill.');
	        }
	    }
	    NgZoneImpl.isInAngularZone = function () { return Zone.current.get('isAngularZone') === true; };
	    NgZoneImpl.prototype.runInner = function (fn) { return this.inner.run(fn); };
	    ;
	    NgZoneImpl.prototype.runInnerGuarded = function (fn) { return this.inner.runGuarded(fn); };
	    ;
	    NgZoneImpl.prototype.runOuter = function (fn) { return this.outer.run(fn); };
	    ;
	    return NgZoneImpl;
	}());
	exports.NgZoneImpl = NgZoneImpl;


/***/ },
/* 64 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var di_1 = __webpack_require__(6);
	var lang_1 = __webpack_require__(5);
	/**
	 * A DI Token representing a unique string id assigned to the application by Angular and used
	 * primarily for prefixing application attributes and CSS styles when
	 * {@link ViewEncapsulation#Emulated} is being used.
	 *
	 * If you need to avoid randomly generated value to be used as an application id, you can provide
	 * a custom value via a DI provider <!-- TODO: provider --> configuring the root {@link Injector}
	 * using this token.
	 */
	exports.APP_ID = new di_1.OpaqueToken('AppId');
	function _appIdRandomProviderFactory() {
	    return "" + _randomChar() + _randomChar() + _randomChar();
	}
	/**
	 * Providers that will generate a random APP_ID_TOKEN.
	 */
	exports.APP_ID_RANDOM_PROVIDER = 
	/*@ts2dart_const*/ /* @ts2dart_Provider */ {
	    provide: exports.APP_ID,
	    useFactory: _appIdRandomProviderFactory,
	    deps: []
	};
	function _randomChar() {
	    return lang_1.StringWrapper.fromCharCode(97 + lang_1.Math.floor(lang_1.Math.random() * 25));
	}
	/**
	 * A function that will be executed when a platform is initialized.
	 */
	exports.PLATFORM_INITIALIZER = 
	/*@ts2dart_const*/ new di_1.OpaqueToken("Platform Initializer");
	/**
	 * A function that will be executed when an application is initialized.
	 */
	exports.APP_INITIALIZER = 
	/*@ts2dart_const*/ new di_1.OpaqueToken("Application Initializer");
	/**
	 * A token which indicates the root directory of the application
	 */
	exports.PACKAGE_ROOT_URL = 
	/*@ts2dart_const*/ new di_1.OpaqueToken("Application Packages Root URL");


/***/ },
/* 65 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var di_1 = __webpack_require__(6);
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var ng_zone_1 = __webpack_require__(62);
	var async_1 = __webpack_require__(41);
	/**
	 * The Testability service provides testing hooks that can be accessed from
	 * the browser and by services such as Protractor. Each bootstrapped Angular
	 * application on the page will have an instance of Testability.
	 */
	var Testability = (function () {
	    function Testability(_ngZone) {
	        this._ngZone = _ngZone;
	        /** @internal */
	        this._pendingCount = 0;
	        /** @internal */
	        this._isZoneStable = true;
	        /**
	         * Whether any work was done since the last 'whenStable' callback. This is
	         * useful to detect if this could have potentially destabilized another
	         * component while it is stabilizing.
	         * @internal
	         */
	        this._didWork = false;
	        /** @internal */
	        this._callbacks = [];
	        this._watchAngularEvents();
	    }
	    /** @internal */
	    Testability.prototype._watchAngularEvents = function () {
	        var _this = this;
	        async_1.ObservableWrapper.subscribe(this._ngZone.onUnstable, function (_) {
	            _this._didWork = true;
	            _this._isZoneStable = false;
	        });
	        this._ngZone.runOutsideAngular(function () {
	            async_1.ObservableWrapper.subscribe(_this._ngZone.onStable, function (_) {
	                ng_zone_1.NgZone.assertNotInAngularZone();
	                lang_1.scheduleMicroTask(function () {
	                    _this._isZoneStable = true;
	                    _this._runCallbacksIfReady();
	                });
	            });
	        });
	    };
	    Testability.prototype.increasePendingRequestCount = function () {
	        this._pendingCount += 1;
	        this._didWork = true;
	        return this._pendingCount;
	    };
	    Testability.prototype.decreasePendingRequestCount = function () {
	        this._pendingCount -= 1;
	        if (this._pendingCount < 0) {
	            throw new exceptions_1.BaseException('pending async requests below zero');
	        }
	        this._runCallbacksIfReady();
	        return this._pendingCount;
	    };
	    Testability.prototype.isStable = function () {
	        return this._isZoneStable && this._pendingCount == 0 && !this._ngZone.hasPendingMacrotasks;
	    };
	    /** @internal */
	    Testability.prototype._runCallbacksIfReady = function () {
	        var _this = this;
	        if (this.isStable()) {
	            // Schedules the call backs in a new frame so that it is always async.
	            lang_1.scheduleMicroTask(function () {
	                while (_this._callbacks.length !== 0) {
	                    (_this._callbacks.pop())(_this._didWork);
	                }
	                _this._didWork = false;
	            });
	        }
	        else {
	            // Not Ready
	            this._didWork = true;
	        }
	    };
	    Testability.prototype.whenStable = function (callback) {
	        this._callbacks.push(callback);
	        this._runCallbacksIfReady();
	    };
	    Testability.prototype.getPendingRequestCount = function () { return this._pendingCount; };
	    Testability.prototype.findBindings = function (using, provider, exactMatch) {
	        // TODO(juliemr): implement.
	        return [];
	    };
	    Testability.prototype.findProviders = function (using, provider, exactMatch) {
	        // TODO(juliemr): implement.
	        return [];
	    };
	    Testability = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [ng_zone_1.NgZone])
	    ], Testability);
	    return Testability;
	}());
	exports.Testability = Testability;
	/**
	 * A global registry of {@link Testability} instances for specific elements.
	 */
	var TestabilityRegistry = (function () {
	    function TestabilityRegistry() {
	        /** @internal */
	        this._applications = new collection_1.Map();
	        _testabilityGetter.addToWindow(this);
	    }
	    TestabilityRegistry.prototype.registerApplication = function (token, testability) {
	        this._applications.set(token, testability);
	    };
	    TestabilityRegistry.prototype.getTestability = function (elem) { return this._applications.get(elem); };
	    TestabilityRegistry.prototype.getAllTestabilities = function () { return collection_1.MapWrapper.values(this._applications); };
	    TestabilityRegistry.prototype.getAllRootElements = function () { return collection_1.MapWrapper.keys(this._applications); };
	    TestabilityRegistry.prototype.findTestabilityInTree = function (elem, findInAncestors) {
	        if (findInAncestors === void 0) { findInAncestors = true; }
	        return _testabilityGetter.findTestabilityInTree(this, elem, findInAncestors);
	    };
	    TestabilityRegistry = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], TestabilityRegistry);
	    return TestabilityRegistry;
	}());
	exports.TestabilityRegistry = TestabilityRegistry;
	/* @ts2dart_const */
	var _NoopGetTestability = (function () {
	    function _NoopGetTestability() {
	    }
	    _NoopGetTestability.prototype.addToWindow = function (registry) { };
	    _NoopGetTestability.prototype.findTestabilityInTree = function (registry, elem, findInAncestors) {
	        return null;
	    };
	    return _NoopGetTestability;
	}());
	/**
	 * Set the {@link GetTestability} implementation used by the Angular testing framework.
	 */
	function setTestabilityGetter(getter) {
	    _testabilityGetter = getter;
	}
	exports.setTestabilityGetter = setTestabilityGetter;
	var _testabilityGetter = new _NoopGetTestability();


/***/ },
/* 66 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var di_1 = __webpack_require__(6);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var async_1 = __webpack_require__(41);
	var reflection_1 = __webpack_require__(18);
	var component_factory_1 = __webpack_require__(67);
	/**
	 * Low-level service for loading {@link ComponentFactory}s, which
	 * can later be used to create and render a Component instance.
	 */
	var ComponentResolver = (function () {
	    function ComponentResolver() {
	    }
	    return ComponentResolver;
	}());
	exports.ComponentResolver = ComponentResolver;
	function _isComponentFactory(type) {
	    return type instanceof component_factory_1.ComponentFactory;
	}
	var ReflectorComponentResolver = (function (_super) {
	    __extends(ReflectorComponentResolver, _super);
	    function ReflectorComponentResolver() {
	        _super.apply(this, arguments);
	    }
	    ReflectorComponentResolver.prototype.resolveComponent = function (componentType) {
	        var metadatas = reflection_1.reflector.annotations(componentType);
	        var componentFactory = metadatas.find(_isComponentFactory);
	        if (lang_1.isBlank(componentFactory)) {
	            throw new exceptions_1.BaseException("No precompiled component " + lang_1.stringify(componentType) + " found");
	        }
	        return async_1.PromiseWrapper.resolve(componentFactory);
	    };
	    ReflectorComponentResolver.prototype.clearCache = function () { };
	    ReflectorComponentResolver = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], ReflectorComponentResolver);
	    return ReflectorComponentResolver;
	}(ComponentResolver));
	exports.ReflectorComponentResolver = ReflectorComponentResolver;


/***/ },
/* 67 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var view_utils_1 = __webpack_require__(68);
	/**
	 * Represents an instance of a Component created via a {@link ComponentFactory}.
	 *
	 * `ComponentRef` provides access to the Component Instance as well other objects related to this
	 * Component Instance and allows you to destroy the Component Instance via the {@link #destroy}
	 * method.
	 */
	var ComponentRef = (function () {
	    function ComponentRef() {
	    }
	    Object.defineProperty(ComponentRef.prototype, "location", {
	        /**
	         * Location of the Host Element of this Component Instance.
	         */
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ComponentRef.prototype, "injector", {
	        /**
	         * The injector on which the component instance exists.
	         */
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ComponentRef.prototype, "instance", {
	        /**
	         * The instance of the Component.
	         */
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    ;
	    Object.defineProperty(ComponentRef.prototype, "hostView", {
	        /**
	         * The {@link ViewRef} of the Host View of this Component instance.
	         */
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    ;
	    Object.defineProperty(ComponentRef.prototype, "changeDetectorRef", {
	        /**
	         * The {@link ChangeDetectorRef} of the Component instance.
	         */
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ComponentRef.prototype, "componentType", {
	        /**
	         * The component type.
	         */
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    return ComponentRef;
	}());
	exports.ComponentRef = ComponentRef;
	var ComponentRef_ = (function (_super) {
	    __extends(ComponentRef_, _super);
	    function ComponentRef_(_hostElement, _componentType) {
	        _super.call(this);
	        this._hostElement = _hostElement;
	        this._componentType = _componentType;
	    }
	    Object.defineProperty(ComponentRef_.prototype, "location", {
	        get: function () { return this._hostElement.elementRef; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ComponentRef_.prototype, "injector", {
	        get: function () { return this._hostElement.injector; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ComponentRef_.prototype, "instance", {
	        get: function () { return this._hostElement.component; },
	        enumerable: true,
	        configurable: true
	    });
	    ;
	    Object.defineProperty(ComponentRef_.prototype, "hostView", {
	        get: function () { return this._hostElement.parentView.ref; },
	        enumerable: true,
	        configurable: true
	    });
	    ;
	    Object.defineProperty(ComponentRef_.prototype, "changeDetectorRef", {
	        get: function () { return this._hostElement.parentView.ref; },
	        enumerable: true,
	        configurable: true
	    });
	    ;
	    Object.defineProperty(ComponentRef_.prototype, "componentType", {
	        get: function () { return this._componentType; },
	        enumerable: true,
	        configurable: true
	    });
	    ComponentRef_.prototype.destroy = function () { this._hostElement.parentView.destroy(); };
	    ComponentRef_.prototype.onDestroy = function (callback) { this.hostView.onDestroy(callback); };
	    return ComponentRef_;
	}(ComponentRef));
	exports.ComponentRef_ = ComponentRef_;
	var EMPTY_CONTEXT = new Object();
	/*@ts2dart_const*/
	var ComponentFactory = (function () {
	    function ComponentFactory(selector, _viewFactory, _componentType) {
	        this.selector = selector;
	        this._viewFactory = _viewFactory;
	        this._componentType = _componentType;
	    }
	    Object.defineProperty(ComponentFactory.prototype, "componentType", {
	        get: function () { return this._componentType; },
	        enumerable: true,
	        configurable: true
	    });
	    /**
	     * Creates a new component.
	     */
	    ComponentFactory.prototype.create = function (injector, projectableNodes, rootSelectorOrNode) {
	        if (projectableNodes === void 0) { projectableNodes = null; }
	        if (rootSelectorOrNode === void 0) { rootSelectorOrNode = null; }
	        var vu = injector.get(view_utils_1.ViewUtils);
	        if (lang_1.isBlank(projectableNodes)) {
	            projectableNodes = [];
	        }
	        // Note: Host views don't need a declarationAppElement!
	        var hostView = this._viewFactory(vu, injector, null);
	        var hostElement = hostView.create(EMPTY_CONTEXT, projectableNodes, rootSelectorOrNode);
	        return new ComponentRef_(hostElement, this._componentType);
	    };
	    return ComponentFactory;
	}());
	exports.ComponentFactory = ComponentFactory;


/***/ },
/* 68 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var exceptions_1 = __webpack_require__(12);
	var element_1 = __webpack_require__(69);
	var exceptions_2 = __webpack_require__(75);
	var change_detection_1 = __webpack_require__(29);
	var di_1 = __webpack_require__(6);
	var api_1 = __webpack_require__(76);
	var application_tokens_1 = __webpack_require__(64);
	var ViewUtils = (function () {
	    function ViewUtils(_renderer, _appId) {
	        this._renderer = _renderer;
	        this._appId = _appId;
	        this._nextCompTypeId = 0;
	    }
	    /**
	     * Used by the generated code
	     */
	    ViewUtils.prototype.createRenderComponentType = function (templateUrl, slotCount, encapsulation, styles) {
	        return new api_1.RenderComponentType(this._appId + "-" + this._nextCompTypeId++, templateUrl, slotCount, encapsulation, styles);
	    };
	    /** @internal */
	    ViewUtils.prototype.renderComponent = function (renderComponentType) {
	        return this._renderer.renderComponent(renderComponentType);
	    };
	    ViewUtils = __decorate([
	        di_1.Injectable(),
	        __param(1, di_1.Inject(application_tokens_1.APP_ID)), 
	        __metadata('design:paramtypes', [api_1.RootRenderer, String])
	    ], ViewUtils);
	    return ViewUtils;
	}());
	exports.ViewUtils = ViewUtils;
	function flattenNestedViewRenderNodes(nodes) {
	    return _flattenNestedViewRenderNodes(nodes, []);
	}
	exports.flattenNestedViewRenderNodes = flattenNestedViewRenderNodes;
	function _flattenNestedViewRenderNodes(nodes, renderNodes) {
	    for (var i = 0; i < nodes.length; i++) {
	        var node = nodes[i];
	        if (node instanceof element_1.AppElement) {
	            var appEl = node;
	            renderNodes.push(appEl.nativeElement);
	            if (lang_1.isPresent(appEl.nestedViews)) {
	                for (var k = 0; k < appEl.nestedViews.length; k++) {
	                    _flattenNestedViewRenderNodes(appEl.nestedViews[k].rootNodesOrAppElements, renderNodes);
	                }
	            }
	        }
	        else {
	            renderNodes.push(node);
	        }
	    }
	    return renderNodes;
	}
	var EMPTY_ARR = [];
	function ensureSlotCount(projectableNodes, expectedSlotCount) {
	    var res;
	    if (lang_1.isBlank(projectableNodes)) {
	        res = EMPTY_ARR;
	    }
	    else if (projectableNodes.length < expectedSlotCount) {
	        var givenSlotCount = projectableNodes.length;
	        res = collection_1.ListWrapper.createFixedSize(expectedSlotCount);
	        for (var i = 0; i < expectedSlotCount; i++) {
	            res[i] = (i < givenSlotCount) ? projectableNodes[i] : EMPTY_ARR;
	        }
	    }
	    else {
	        res = projectableNodes;
	    }
	    return res;
	}
	exports.ensureSlotCount = ensureSlotCount;
	exports.MAX_INTERPOLATION_VALUES = 9;
	function interpolate(valueCount, c0, a1, c1, a2, c2, a3, c3, a4, c4, a5, c5, a6, c6, a7, c7, a8, c8, a9, c9) {
	    switch (valueCount) {
	        case 1:
	            return c0 + _toStringWithNull(a1) + c1;
	        case 2:
	            return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2;
	        case 3:
	            return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
	                c3;
	        case 4:
	            return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
	                c3 + _toStringWithNull(a4) + c4;
	        case 5:
	            return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
	                c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5;
	        case 6:
	            return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
	                c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) +
	                c6;
	        case 7:
	            return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
	                c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) +
	                c6 + _toStringWithNull(a7) + c7;
	        case 8:
	            return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
	                c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) +
	                c6 + _toStringWithNull(a7) + c7 + _toStringWithNull(a8) + c8;
	        case 9:
	            return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
	                c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) +
	                c6 + _toStringWithNull(a7) + c7 + _toStringWithNull(a8) + c8 + _toStringWithNull(a9) +
	                c9;
	        default:
	            throw new exceptions_1.BaseException("Does not support more than 9 expressions");
	    }
	}
	exports.interpolate = interpolate;
	function _toStringWithNull(v) {
	    return v != null ? v.toString() : '';
	}
	function checkBinding(throwOnChange, oldValue, newValue) {
	    if (throwOnChange) {
	        if (!change_detection_1.devModeEqual(oldValue, newValue)) {
	            throw new exceptions_2.ExpressionChangedAfterItHasBeenCheckedException(oldValue, newValue, null);
	        }
	        return false;
	    }
	    else {
	        return !lang_1.looseIdentical(oldValue, newValue);
	    }
	}
	exports.checkBinding = checkBinding;
	function arrayLooseIdentical(a, b) {
	    if (a.length != b.length)
	        return false;
	    for (var i = 0; i < a.length; ++i) {
	        if (!lang_1.looseIdentical(a[i], b[i]))
	            return false;
	    }
	    return true;
	}
	exports.arrayLooseIdentical = arrayLooseIdentical;
	function mapLooseIdentical(m1, m2) {
	    var k1 = collection_1.StringMapWrapper.keys(m1);
	    var k2 = collection_1.StringMapWrapper.keys(m2);
	    if (k1.length != k2.length) {
	        return false;
	    }
	    var key;
	    for (var i = 0; i < k1.length; i++) {
	        key = k1[i];
	        if (!lang_1.looseIdentical(m1[key], m2[key])) {
	            return false;
	        }
	    }
	    return true;
	}
	exports.mapLooseIdentical = mapLooseIdentical;
	function castByValue(input, value) {
	    return input;
	}
	exports.castByValue = castByValue;
	exports.EMPTY_ARRAY = [];
	exports.EMPTY_MAP = {};
	function pureProxy1(fn) {
	    var result;
	    var v0;
	    v0 = change_detection_1.uninitialized;
	    return function (p0) {
	        if (!lang_1.looseIdentical(v0, p0)) {
	            v0 = p0;
	            result = fn(p0);
	        }
	        return result;
	    };
	}
	exports.pureProxy1 = pureProxy1;
	function pureProxy2(fn) {
	    var result;
	    var v0, v1;
	    v0 = v1 = change_detection_1.uninitialized;
	    return function (p0, p1) {
	        if (!lang_1.looseIdentical(v0, p0) || !lang_1.looseIdentical(v1, p1)) {
	            v0 = p0;
	            v1 = p1;
	            result = fn(p0, p1);
	        }
	        return result;
	    };
	}
	exports.pureProxy2 = pureProxy2;
	function pureProxy3(fn) {
	    var result;
	    var v0, v1, v2;
	    v0 = v1 = v2 = change_detection_1.uninitialized;
	    return function (p0, p1, p2) {
	        if (!lang_1.looseIdentical(v0, p0) || !lang_1.looseIdentical(v1, p1) || !lang_1.looseIdentical(v2, p2)) {
	            v0 = p0;
	            v1 = p1;
	            v2 = p2;
	            result = fn(p0, p1, p2);
	        }
	        return result;
	    };
	}
	exports.pureProxy3 = pureProxy3;
	function pureProxy4(fn) {
	    var result;
	    var v0, v1, v2, v3;
	    v0 = v1 = v2 = v3 = change_detection_1.uninitialized;
	    return function (p0, p1, p2, p3) {
	        if (!lang_1.looseIdentical(v0, p0) || !lang_1.looseIdentical(v1, p1) || !lang_1.looseIdentical(v2, p2) ||
	            !lang_1.looseIdentical(v3, p3)) {
	            v0 = p0;
	            v1 = p1;
	            v2 = p2;
	            v3 = p3;
	            result = fn(p0, p1, p2, p3);
	        }
	        return result;
	    };
	}
	exports.pureProxy4 = pureProxy4;
	function pureProxy5(fn) {
	    var result;
	    var v0, v1, v2, v3, v4;
	    v0 = v1 = v2 = v3 = v4 = change_detection_1.uninitialized;
	    return function (p0, p1, p2, p3, p4) {
	        if (!lang_1.looseIdentical(v0, p0) || !lang_1.looseIdentical(v1, p1) || !lang_1.looseIdentical(v2, p2) ||
	            !lang_1.looseIdentical(v3, p3) || !lang_1.looseIdentical(v4, p4)) {
	            v0 = p0;
	            v1 = p1;
	            v2 = p2;
	            v3 = p3;
	            v4 = p4;
	            result = fn(p0, p1, p2, p3, p4);
	        }
	        return result;
	    };
	}
	exports.pureProxy5 = pureProxy5;
	function pureProxy6(fn) {
	    var result;
	    var v0, v1, v2, v3, v4, v5;
	    v0 = v1 = v2 = v3 = v4 = v5 = change_detection_1.uninitialized;
	    return function (p0, p1, p2, p3, p4, p5) {
	        if (!lang_1.looseIdentical(v0, p0) || !lang_1.looseIdentical(v1, p1) || !lang_1.looseIdentical(v2, p2) ||
	            !lang_1.looseIdentical(v3, p3) || !lang_1.looseIdentical(v4, p4) || !lang_1.looseIdentical(v5, p5)) {
	            v0 = p0;
	            v1 = p1;
	            v2 = p2;
	            v3 = p3;
	            v4 = p4;
	            v5 = p5;
	            result = fn(p0, p1, p2, p3, p4, p5);
	        }
	        return result;
	    };
	}
	exports.pureProxy6 = pureProxy6;
	function pureProxy7(fn) {
	    var result;
	    var v0, v1, v2, v3, v4, v5, v6;
	    v0 = v1 = v2 = v3 = v4 = v5 = v6 = change_detection_1.uninitialized;
	    return function (p0, p1, p2, p3, p4, p5, p6) {
	        if (!lang_1.looseIdentical(v0, p0) || !lang_1.looseIdentical(v1, p1) || !lang_1.looseIdentical(v2, p2) ||
	            !lang_1.looseIdentical(v3, p3) || !lang_1.looseIdentical(v4, p4) || !lang_1.looseIdentical(v5, p5) ||
	            !lang_1.looseIdentical(v6, p6)) {
	            v0 = p0;
	            v1 = p1;
	            v2 = p2;
	            v3 = p3;
	            v4 = p4;
	            v5 = p5;
	            v6 = p6;
	            result = fn(p0, p1, p2, p3, p4, p5, p6);
	        }
	        return result;
	    };
	}
	exports.pureProxy7 = pureProxy7;
	function pureProxy8(fn) {
	    var result;
	    var v0, v1, v2, v3, v4, v5, v6, v7;
	    v0 = v1 = v2 = v3 = v4 = v5 = v6 = v7 = change_detection_1.uninitialized;
	    return function (p0, p1, p2, p3, p4, p5, p6, p7) {
	        if (!lang_1.looseIdentical(v0, p0) || !lang_1.looseIdentical(v1, p1) || !lang_1.looseIdentical(v2, p2) ||
	            !lang_1.looseIdentical(v3, p3) || !lang_1.looseIdentical(v4, p4) || !lang_1.looseIdentical(v5, p5) ||
	            !lang_1.looseIdentical(v6, p6) || !lang_1.looseIdentical(v7, p7)) {
	            v0 = p0;
	            v1 = p1;
	            v2 = p2;
	            v3 = p3;
	            v4 = p4;
	            v5 = p5;
	            v6 = p6;
	            v7 = p7;
	            result = fn(p0, p1, p2, p3, p4, p5, p6, p7);
	        }
	        return result;
	    };
	}
	exports.pureProxy8 = pureProxy8;
	function pureProxy9(fn) {
	    var result;
	    var v0, v1, v2, v3, v4, v5, v6, v7, v8;
	    v0 = v1 = v2 = v3 = v4 = v5 = v6 = v7 = v8 = change_detection_1.uninitialized;
	    return function (p0, p1, p2, p3, p4, p5, p6, p7, p8) {
	        if (!lang_1.looseIdentical(v0, p0) || !lang_1.looseIdentical(v1, p1) || !lang_1.looseIdentical(v2, p2) ||
	            !lang_1.looseIdentical(v3, p3) || !lang_1.looseIdentical(v4, p4) || !lang_1.looseIdentical(v5, p5) ||
	            !lang_1.looseIdentical(v6, p6) || !lang_1.looseIdentical(v7, p7) || !lang_1.looseIdentical(v8, p8)) {
	            v0 = p0;
	            v1 = p1;
	            v2 = p2;
	            v3 = p3;
	            v4 = p4;
	            v5 = p5;
	            v6 = p6;
	            v7 = p7;
	            v8 = p8;
	            result = fn(p0, p1, p2, p3, p4, p5, p6, p7, p8);
	        }
	        return result;
	    };
	}
	exports.pureProxy9 = pureProxy9;
	function pureProxy10(fn) {
	    var result;
	    var v0, v1, v2, v3, v4, v5, v6, v7, v8, v9;
	    v0 = v1 = v2 = v3 = v4 = v5 = v6 = v7 = v8 = v9 = change_detection_1.uninitialized;
	    return function (p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) {
	        if (!lang_1.looseIdentical(v0, p0) || !lang_1.looseIdentical(v1, p1) || !lang_1.looseIdentical(v2, p2) ||
	            !lang_1.looseIdentical(v3, p3) || !lang_1.looseIdentical(v4, p4) || !lang_1.looseIdentical(v5, p5) ||
	            !lang_1.looseIdentical(v6, p6) || !lang_1.looseIdentical(v7, p7) || !lang_1.looseIdentical(v8, p8) ||
	            !lang_1.looseIdentical(v9, p9)) {
	            v0 = p0;
	            v1 = p1;
	            v2 = p2;
	            v3 = p3;
	            v4 = p4;
	            v5 = p5;
	            v6 = p6;
	            v7 = p7;
	            v8 = p8;
	            v9 = p9;
	            result = fn(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
	        }
	        return result;
	    };
	}
	exports.pureProxy10 = pureProxy10;


/***/ },
/* 69 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var exceptions_1 = __webpack_require__(12);
	var view_type_1 = __webpack_require__(70);
	var element_ref_1 = __webpack_require__(71);
	var view_container_ref_1 = __webpack_require__(72);
	/**
	 * An AppElement is created for elements that have a ViewContainerRef,
	 * a nested component or a <template> element to keep data around
	 * that is needed for later instantiations.
	 */
	var AppElement = (function () {
	    function AppElement(index, parentIndex, parentView, nativeElement) {
	        this.index = index;
	        this.parentIndex = parentIndex;
	        this.parentView = parentView;
	        this.nativeElement = nativeElement;
	        this.nestedViews = null;
	        this.componentView = null;
	    }
	    Object.defineProperty(AppElement.prototype, "elementRef", {
	        get: function () { return new element_ref_1.ElementRef(this.nativeElement); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AppElement.prototype, "vcRef", {
	        get: function () { return new view_container_ref_1.ViewContainerRef_(this); },
	        enumerable: true,
	        configurable: true
	    });
	    AppElement.prototype.initComponent = function (component, componentConstructorViewQueries, view) {
	        this.component = component;
	        this.componentConstructorViewQueries = componentConstructorViewQueries;
	        this.componentView = view;
	    };
	    Object.defineProperty(AppElement.prototype, "parentInjector", {
	        get: function () { return this.parentView.injector(this.parentIndex); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AppElement.prototype, "injector", {
	        get: function () { return this.parentView.injector(this.index); },
	        enumerable: true,
	        configurable: true
	    });
	    AppElement.prototype.mapNestedViews = function (nestedViewClass, callback) {
	        var result = [];
	        if (lang_1.isPresent(this.nestedViews)) {
	            this.nestedViews.forEach(function (nestedView) {
	                if (nestedView.clazz === nestedViewClass) {
	                    result.push(callback(nestedView));
	                }
	            });
	        }
	        return result;
	    };
	    AppElement.prototype.attachView = function (view, viewIndex) {
	        if (view.type === view_type_1.ViewType.COMPONENT) {
	            throw new exceptions_1.BaseException("Component views can't be moved!");
	        }
	        var nestedViews = this.nestedViews;
	        if (nestedViews == null) {
	            nestedViews = [];
	            this.nestedViews = nestedViews;
	        }
	        collection_1.ListWrapper.insert(nestedViews, viewIndex, view);
	        var refRenderNode;
	        if (viewIndex > 0) {
	            var prevView = nestedViews[viewIndex - 1];
	            refRenderNode = prevView.lastRootNode;
	        }
	        else {
	            refRenderNode = this.nativeElement;
	        }
	        if (lang_1.isPresent(refRenderNode)) {
	            view.renderer.attachViewAfter(refRenderNode, view.flatRootNodes);
	        }
	        view.addToContentChildren(this);
	    };
	    AppElement.prototype.detachView = function (viewIndex) {
	        var view = collection_1.ListWrapper.removeAt(this.nestedViews, viewIndex);
	        if (view.type === view_type_1.ViewType.COMPONENT) {
	            throw new exceptions_1.BaseException("Component views can't be moved!");
	        }
	        view.renderer.detachView(view.flatRootNodes);
	        view.removeFromContentChildren(this);
	        return view;
	    };
	    return AppElement;
	}());
	exports.AppElement = AppElement;


/***/ },
/* 70 */
/***/ function(module, exports) {

	"use strict";
	(function (ViewType) {
	    // A view that contains the host element with bound component directive.
	    // Contains a COMPONENT view
	    ViewType[ViewType["HOST"] = 0] = "HOST";
	    // The view of the component
	    // Can contain 0 to n EMBEDDED views
	    ViewType[ViewType["COMPONENT"] = 1] = "COMPONENT";
	    // A view that is embedded into another View via a <template> element
	    // inside of a COMPONENT view
	    ViewType[ViewType["EMBEDDED"] = 2] = "EMBEDDED";
	})(exports.ViewType || (exports.ViewType = {}));
	var ViewType = exports.ViewType;


/***/ },
/* 71 */
/***/ function(module, exports) {

	"use strict";
	/**
	 * A wrapper around a native element inside of a View.
	 *
	 * An `ElementRef` is backed by a render-specific element. In the browser, this is usually a DOM
	 * element.
	 */
	// Note: We don't expose things like `Injector`, `ViewContainer`, ... here,
	// i.e. users have to ask for what they need. With that, we can build better analysis tools
	// and could do better codegen in the future.
	var ElementRef = (function () {
	    function ElementRef(nativeElement) {
	        this.nativeElement = nativeElement;
	    }
	    return ElementRef;
	}());
	exports.ElementRef = ElementRef;


/***/ },
/* 72 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var collection_1 = __webpack_require__(15);
	var exceptions_1 = __webpack_require__(12);
	var lang_1 = __webpack_require__(5);
	var profile_1 = __webpack_require__(73);
	/**
	 * Represents a container where one or more Views can be attached.
	 *
	 * The container can contain two kinds of Views. Host Views, created by instantiating a
	 * {@link Component} via {@link #createComponent}, and Embedded Views, created by instantiating an
	 * {@link TemplateRef Embedded Template} via {@link #createEmbeddedView}.
	 *
	 * The location of the View Container within the containing View is specified by the Anchor
	 * `element`. Each View Container can have only one Anchor Element and each Anchor Element can only
	 * have a single View Container.
	 *
	 * Root elements of Views attached to this container become siblings of the Anchor Element in
	 * the Rendered View.
	 *
	 * To access a `ViewContainerRef` of an Element, you can either place a {@link Directive} injected
	 * with `ViewContainerRef` on the Element, or you obtain it via a {@link ViewChild} query.
	 */
	var ViewContainerRef = (function () {
	    function ViewContainerRef() {
	    }
	    Object.defineProperty(ViewContainerRef.prototype, "element", {
	        /**
	         * Anchor element that specifies the location of this container in the containing View.
	         * <!-- TODO: rename to anchorElement -->
	         */
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ViewContainerRef.prototype, "injector", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ViewContainerRef.prototype, "parentInjector", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ViewContainerRef.prototype, "length", {
	        /**
	         * Returns the number of Views currently attached to this container.
	         */
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    ;
	    return ViewContainerRef;
	}());
	exports.ViewContainerRef = ViewContainerRef;
	var ViewContainerRef_ = (function () {
	    function ViewContainerRef_(_element) {
	        this._element = _element;
	        /** @internal */
	        this._createComponentInContainerScope = profile_1.wtfCreateScope('ViewContainerRef#createComponent()');
	        /** @internal */
	        this._insertScope = profile_1.wtfCreateScope('ViewContainerRef#insert()');
	        /** @internal */
	        this._removeScope = profile_1.wtfCreateScope('ViewContainerRef#remove()');
	        /** @internal */
	        this._detachScope = profile_1.wtfCreateScope('ViewContainerRef#detach()');
	    }
	    ViewContainerRef_.prototype.get = function (index) { return this._element.nestedViews[index].ref; };
	    Object.defineProperty(ViewContainerRef_.prototype, "length", {
	        get: function () {
	            var views = this._element.nestedViews;
	            return lang_1.isPresent(views) ? views.length : 0;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ViewContainerRef_.prototype, "element", {
	        get: function () { return this._element.elementRef; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ViewContainerRef_.prototype, "injector", {
	        get: function () { return this._element.injector; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ViewContainerRef_.prototype, "parentInjector", {
	        get: function () { return this._element.parentInjector; },
	        enumerable: true,
	        configurable: true
	    });
	    // TODO(rado): profile and decide whether bounds checks should be added
	    // to the methods below.
	    ViewContainerRef_.prototype.createEmbeddedView = function (templateRef, context, index) {
	        if (context === void 0) { context = null; }
	        if (index === void 0) { index = -1; }
	        var viewRef = templateRef.createEmbeddedView(context);
	        this.insert(viewRef, index);
	        return viewRef;
	    };
	    ViewContainerRef_.prototype.createComponent = function (componentFactory, index, injector, projectableNodes) {
	        if (index === void 0) { index = -1; }
	        if (injector === void 0) { injector = null; }
	        if (projectableNodes === void 0) { projectableNodes = null; }
	        var s = this._createComponentInContainerScope();
	        var contextInjector = lang_1.isPresent(injector) ? injector : this._element.parentInjector;
	        var componentRef = componentFactory.create(contextInjector, projectableNodes);
	        this.insert(componentRef.hostView, index);
	        return profile_1.wtfLeave(s, componentRef);
	    };
	    // TODO(i): refactor insert+remove into move
	    ViewContainerRef_.prototype.insert = function (viewRef, index) {
	        if (index === void 0) { index = -1; }
	        var s = this._insertScope();
	        if (index == -1)
	            index = this.length;
	        var viewRef_ = viewRef;
	        this._element.attachView(viewRef_.internalView, index);
	        return profile_1.wtfLeave(s, viewRef_);
	    };
	    ViewContainerRef_.prototype.indexOf = function (viewRef) {
	        return collection_1.ListWrapper.indexOf(this._element.nestedViews, viewRef.internalView);
	    };
	    // TODO(i): rename to destroy
	    ViewContainerRef_.prototype.remove = function (index) {
	        if (index === void 0) { index = -1; }
	        var s = this._removeScope();
	        if (index == -1)
	            index = this.length - 1;
	        var view = this._element.detachView(index);
	        view.destroy();
	        // view is intentionally not returned to the client.
	        profile_1.wtfLeave(s);
	    };
	    // TODO(i): refactor insert+remove into move
	    ViewContainerRef_.prototype.detach = function (index) {
	        if (index === void 0) { index = -1; }
	        var s = this._detachScope();
	        if (index == -1)
	            index = this.length - 1;
	        var view = this._element.detachView(index);
	        return profile_1.wtfLeave(s, view.ref);
	    };
	    ViewContainerRef_.prototype.clear = function () {
	        for (var i = this.length - 1; i >= 0; i--) {
	            this.remove(i);
	        }
	    };
	    return ViewContainerRef_;
	}());
	exports.ViewContainerRef_ = ViewContainerRef_;


/***/ },
/* 73 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var impl = __webpack_require__(74);
	// Change exports to const once https://github.com/angular/ts2dart/issues/150
	/**
	 * True if WTF is enabled.
	 */
	exports.wtfEnabled = impl.detectWTF();
	function noopScope(arg0, arg1) {
	    return null;
	}
	/**
	 * Create trace scope.
	 *
	 * Scopes must be strictly nested and are analogous to stack frames, but
	 * do not have to follow the stack frames. Instead it is recommended that they follow logical
	 * nesting. You may want to use
	 * [Event
	 * Signatures](http://google.github.io/tracing-framework/instrumenting-code.html#custom-events)
	 * as they are defined in WTF.
	 *
	 * Used to mark scope entry. The return value is used to leave the scope.
	 *
	 *     var myScope = wtfCreateScope('MyClass#myMethod(ascii someVal)');
	 *
	 *     someMethod() {
	 *        var s = myScope('Foo'); // 'Foo' gets stored in tracing UI
	 *        // DO SOME WORK HERE
	 *        return wtfLeave(s, 123); // Return value 123
	 *     }
	 *
	 * Note, adding try-finally block around the work to ensure that `wtfLeave` gets called can
	 * negatively impact the performance of your application. For this reason we recommend that
	 * you don't add them to ensure that `wtfLeave` gets called. In production `wtfLeave` is a noop and
	 * so try-finally block has no value. When debugging perf issues, skipping `wtfLeave`, do to
	 * exception, will produce incorrect trace, but presence of exception signifies logic error which
	 * needs to be fixed before the app should be profiled. Add try-finally only when you expect that
	 * an exception is expected during normal execution while profiling.
	 *
	 */
	exports.wtfCreateScope = exports.wtfEnabled ? impl.createScope : function (signature, flags) { return noopScope; };
	/**
	 * Used to mark end of Scope.
	 *
	 * - `scope` to end.
	 * - `returnValue` (optional) to be passed to the WTF.
	 *
	 * Returns the `returnValue for easy chaining.
	 */
	exports.wtfLeave = exports.wtfEnabled ? impl.leave : function (s, r) { return r; };
	/**
	 * Used to mark Async start. Async are similar to scope but they don't have to be strictly nested.
	 * The return value is used in the call to [endAsync]. Async ranges only work if WTF has been
	 * enabled.
	 *
	 *     someMethod() {
	 *        var s = wtfStartTimeRange('HTTP:GET', 'some.url');
	 *        var future = new Future.delay(5).then((_) {
	 *          wtfEndTimeRange(s);
	 *        });
	 *     }
	 */
	exports.wtfStartTimeRange = exports.wtfEnabled ? impl.startTimeRange : function (rangeType, action) { return null; };
	/**
	 * Ends a async time range operation.
	 * [range] is the return value from [wtfStartTimeRange] Async ranges only work if WTF has been
	 * enabled.
	 */
	exports.wtfEndTimeRange = exports.wtfEnabled ? impl.endTimeRange : function (r) {
	    return null;
	};


/***/ },
/* 74 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var trace;
	var events;
	function detectWTF() {
	    var wtf = lang_1.global['wtf'];
	    if (wtf) {
	        trace = wtf['trace'];
	        if (trace) {
	            events = trace['events'];
	            return true;
	        }
	    }
	    return false;
	}
	exports.detectWTF = detectWTF;
	function createScope(signature, flags) {
	    if (flags === void 0) { flags = null; }
	    return events.createScope(signature, flags);
	}
	exports.createScope = createScope;
	function leave(scope, returnValue) {
	    trace.leaveScope(scope, returnValue);
	    return returnValue;
	}
	exports.leave = leave;
	function startTimeRange(rangeType, action) {
	    return trace.beginTimeRange(rangeType, action);
	}
	exports.startTimeRange = startTimeRange;
	function endTimeRange(range) {
	    trace.endTimeRange(range);
	}
	exports.endTimeRange = endTimeRange;


/***/ },
/* 75 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var exceptions_1 = __webpack_require__(12);
	/**
	 * An error thrown if application changes model breaking the top-down data flow.
	 *
	 * This exception is only thrown in dev mode.
	 *
	 * <!-- TODO: Add a link once the dev mode option is configurable -->
	 *
	 * ### Example
	 *
	 * ```typescript
	 * @Component({
	 *   selector: 'parent',
	 *   template: `
	 *     <child [prop]="parentProp"></child>
	 *   `,
	 *   directives: [forwardRef(() => Child)]
	 * })
	 * class Parent {
	 *   parentProp = "init";
	 * }
	 *
	 * @Directive({selector: 'child', inputs: ['prop']})
	 * class Child {
	 *   constructor(public parent: Parent) {}
	 *
	 *   set prop(v) {
	 *     // this updates the parent property, which is disallowed during change detection
	 *     // this will result in ExpressionChangedAfterItHasBeenCheckedException
	 *     this.parent.parentProp = "updated";
	 *   }
	 * }
	 * ```
	 */
	var ExpressionChangedAfterItHasBeenCheckedException = (function (_super) {
	    __extends(ExpressionChangedAfterItHasBeenCheckedException, _super);
	    function ExpressionChangedAfterItHasBeenCheckedException(oldValue, currValue, context) {
	        _super.call(this, "Expression has changed after it was checked. " +
	            ("Previous value: '" + oldValue + "'. Current value: '" + currValue + "'"));
	    }
	    return ExpressionChangedAfterItHasBeenCheckedException;
	}(exceptions_1.BaseException));
	exports.ExpressionChangedAfterItHasBeenCheckedException = ExpressionChangedAfterItHasBeenCheckedException;
	/**
	 * Thrown when an exception was raised during view creation, change detection or destruction.
	 *
	 * This error wraps the original exception to attach additional contextual information that can
	 * be useful for debugging.
	 */
	var ViewWrappedException = (function (_super) {
	    __extends(ViewWrappedException, _super);
	    function ViewWrappedException(originalException, originalStack, context) {
	        _super.call(this, "Error in " + context.source, originalException, originalStack, context);
	    }
	    return ViewWrappedException;
	}(exceptions_1.WrappedException));
	exports.ViewWrappedException = ViewWrappedException;
	/**
	 * Thrown when a destroyed view is used.
	 *
	 * This error indicates a bug in the framework.
	 *
	 * This is an internal Angular error.
	 */
	var ViewDestroyedException = (function (_super) {
	    __extends(ViewDestroyedException, _super);
	    function ViewDestroyedException(details) {
	        _super.call(this, "Attempt to use a destroyed view: " + details);
	    }
	    return ViewDestroyedException;
	}(exceptions_1.BaseException));
	exports.ViewDestroyedException = ViewDestroyedException;


/***/ },
/* 76 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var exceptions_1 = __webpack_require__(12);
	var RenderComponentType = (function () {
	    function RenderComponentType(id, templateUrl, slotCount, encapsulation, styles) {
	        this.id = id;
	        this.templateUrl = templateUrl;
	        this.slotCount = slotCount;
	        this.encapsulation = encapsulation;
	        this.styles = styles;
	    }
	    return RenderComponentType;
	}());
	exports.RenderComponentType = RenderComponentType;
	var RenderDebugInfo = (function () {
	    function RenderDebugInfo() {
	    }
	    Object.defineProperty(RenderDebugInfo.prototype, "injector", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(RenderDebugInfo.prototype, "component", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(RenderDebugInfo.prototype, "providerTokens", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(RenderDebugInfo.prototype, "references", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(RenderDebugInfo.prototype, "context", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(RenderDebugInfo.prototype, "source", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    return RenderDebugInfo;
	}());
	exports.RenderDebugInfo = RenderDebugInfo;
	var Renderer = (function () {
	    function Renderer() {
	    }
	    return Renderer;
	}());
	exports.Renderer = Renderer;
	/**
	 * Injectable service that provides a low-level interface for modifying the UI.
	 *
	 * Use this service to bypass Angular's templating and make custom UI changes that can't be
	 * expressed declaratively. For example if you need to set a property or an attribute whose name is
	 * not statically known, use {@link #setElementProperty} or {@link #setElementAttribute}
	 * respectively.
	 *
	 * If you are implementing a custom renderer, you must implement this interface.
	 *
	 * The default Renderer implementation is `DomRenderer`. Also available is `WebWorkerRenderer`.
	 */
	var RootRenderer = (function () {
	    function RootRenderer() {
	    }
	    return RootRenderer;
	}());
	exports.RootRenderer = RootRenderer;


/***/ },
/* 77 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var di_1 = __webpack_require__(6);
	var lang_1 = __webpack_require__(5);
	// Note: Need to rename warn as in Dart
	// class members and imports can't use the same name.
	var _warnImpl = lang_1.warn;
	var Console = (function () {
	    function Console() {
	    }
	    Console.prototype.log = function (message) { lang_1.print(message); };
	    // Note: for reporting errors use `DOM.logError()` as it is platform specific
	    Console.prototype.warn = function (message) { _warnImpl(message); };
	    Console = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], Console);
	    return Console;
	}());
	exports.Console = Console;


/***/ },
/* 78 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	// Public API for Zone
	var ng_zone_1 = __webpack_require__(62);
	exports.NgZone = ng_zone_1.NgZone;
	exports.NgZoneError = ng_zone_1.NgZoneError;


/***/ },
/* 79 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	// Public API for render
	var api_1 = __webpack_require__(76);
	exports.RootRenderer = api_1.RootRenderer;
	exports.Renderer = api_1.Renderer;
	exports.RenderComponentType = api_1.RenderComponentType;


/***/ },
/* 80 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	// Public API for compiler
	var component_resolver_1 = __webpack_require__(66);
	exports.ComponentResolver = component_resolver_1.ComponentResolver;
	var query_list_1 = __webpack_require__(81);
	exports.QueryList = query_list_1.QueryList;
	var dynamic_component_loader_1 = __webpack_require__(82);
	exports.DynamicComponentLoader = dynamic_component_loader_1.DynamicComponentLoader;
	var element_ref_1 = __webpack_require__(71);
	exports.ElementRef = element_ref_1.ElementRef;
	var template_ref_1 = __webpack_require__(83);
	exports.TemplateRef = template_ref_1.TemplateRef;
	var view_ref_1 = __webpack_require__(84);
	exports.EmbeddedViewRef = view_ref_1.EmbeddedViewRef;
	exports.ViewRef = view_ref_1.ViewRef;
	var view_container_ref_1 = __webpack_require__(72);
	exports.ViewContainerRef = view_container_ref_1.ViewContainerRef;
	var component_factory_1 = __webpack_require__(67);
	exports.ComponentRef = component_factory_1.ComponentRef;
	exports.ComponentFactory = component_factory_1.ComponentFactory;
	var exceptions_1 = __webpack_require__(75);
	exports.ExpressionChangedAfterItHasBeenCheckedException = exceptions_1.ExpressionChangedAfterItHasBeenCheckedException;


/***/ },
/* 81 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	var async_1 = __webpack_require__(41);
	/**
	 * An unmodifiable list of items that Angular keeps up to date when the state
	 * of the application changes.
	 *
	 * The type of object that {@link QueryMetadata} and {@link ViewQueryMetadata} provide.
	 *
	 * Implements an iterable interface, therefore it can be used in both ES6
	 * javascript `for (var i of items)` loops as well as in Angular templates with
	 * `*ngFor="let i of myList"`.
	 *
	 * Changes can be observed by subscribing to the changes `Observable`.
	 *
	 * NOTE: In the future this class will implement an `Observable` interface.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/RX8sJnQYl9FWuSCWme5z?p=preview))
	 * ```typescript
	 * @Component({...})
	 * class Container {
	 *   constructor(@Query(Item) items: QueryList<Item>) {
	 *     items.changes.subscribe(_ => console.log(items.length));
	 *   }
	 * }
	 * ```
	 */
	var QueryList = (function () {
	    function QueryList() {
	        this._dirty = true;
	        this._results = [];
	        this._emitter = new async_1.EventEmitter();
	    }
	    Object.defineProperty(QueryList.prototype, "changes", {
	        get: function () { return this._emitter; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(QueryList.prototype, "length", {
	        get: function () { return this._results.length; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(QueryList.prototype, "first", {
	        get: function () { return collection_1.ListWrapper.first(this._results); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(QueryList.prototype, "last", {
	        get: function () { return collection_1.ListWrapper.last(this._results); },
	        enumerable: true,
	        configurable: true
	    });
	    /**
	     * returns a new array with the passed in function applied to each element.
	     */
	    QueryList.prototype.map = function (fn) { return this._results.map(fn); };
	    /**
	     * returns a filtered array.
	     */
	    QueryList.prototype.filter = function (fn) { return this._results.filter(fn); };
	    /**
	     * returns a reduced value.
	     */
	    QueryList.prototype.reduce = function (fn, init) { return this._results.reduce(fn, init); };
	    /**
	     * executes function for each element in a query.
	     */
	    QueryList.prototype.forEach = function (fn) { this._results.forEach(fn); };
	    /**
	     * converts QueryList into an array
	     */
	    QueryList.prototype.toArray = function () { return collection_1.ListWrapper.clone(this._results); };
	    QueryList.prototype[lang_1.getSymbolIterator()] = function () { return this._results[lang_1.getSymbolIterator()](); };
	    QueryList.prototype.toString = function () { return this._results.toString(); };
	    /**
	     * @internal
	     */
	    QueryList.prototype.reset = function (res) {
	        this._results = collection_1.ListWrapper.flatten(res);
	        this._dirty = false;
	    };
	    /** @internal */
	    QueryList.prototype.notifyOnChanges = function () { this._emitter.emit(this); };
	    /** internal */
	    QueryList.prototype.setDirty = function () { this._dirty = true; };
	    Object.defineProperty(QueryList.prototype, "dirty", {
	        /** internal */
	        get: function () { return this._dirty; },
	        enumerable: true,
	        configurable: true
	    });
	    return QueryList;
	}());
	exports.QueryList = QueryList;


/***/ },
/* 82 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var di_1 = __webpack_require__(6);
	var component_resolver_1 = __webpack_require__(66);
	var lang_1 = __webpack_require__(5);
	/**
	 * Use ComponentResolver and ViewContainerRef directly.
	 *
	 * @deprecated
	 */
	var DynamicComponentLoader = (function () {
	    function DynamicComponentLoader() {
	    }
	    return DynamicComponentLoader;
	}());
	exports.DynamicComponentLoader = DynamicComponentLoader;
	var DynamicComponentLoader_ = (function (_super) {
	    __extends(DynamicComponentLoader_, _super);
	    function DynamicComponentLoader_(_compiler) {
	        _super.call(this);
	        this._compiler = _compiler;
	    }
	    DynamicComponentLoader_.prototype.loadAsRoot = function (type, overrideSelectorOrNode, injector, onDispose, projectableNodes) {
	        return this._compiler.resolveComponent(type).then(function (componentFactory) {
	            var componentRef = componentFactory.create(injector, projectableNodes, lang_1.isPresent(overrideSelectorOrNode) ? overrideSelectorOrNode : componentFactory.selector);
	            if (lang_1.isPresent(onDispose)) {
	                componentRef.onDestroy(onDispose);
	            }
	            return componentRef;
	        });
	    };
	    DynamicComponentLoader_.prototype.loadNextToLocation = function (type, location, providers, projectableNodes) {
	        if (providers === void 0) { providers = null; }
	        if (projectableNodes === void 0) { projectableNodes = null; }
	        return this._compiler.resolveComponent(type).then(function (componentFactory) {
	            var contextInjector = location.parentInjector;
	            var childInjector = lang_1.isPresent(providers) && providers.length > 0 ?
	                di_1.ReflectiveInjector.fromResolvedProviders(providers, contextInjector) :
	                contextInjector;
	            return location.createComponent(componentFactory, location.length, childInjector, projectableNodes);
	        });
	    };
	    DynamicComponentLoader_ = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [component_resolver_1.ComponentResolver])
	    ], DynamicComponentLoader_);
	    return DynamicComponentLoader_;
	}(DynamicComponentLoader));
	exports.DynamicComponentLoader_ = DynamicComponentLoader_;


/***/ },
/* 83 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var EMPTY_CONTEXT = new Object();
	/**
	 * Represents an Embedded Template that can be used to instantiate Embedded Views.
	 *
	 * You can access a `TemplateRef`, in two ways. Via a directive placed on a `<template>` element (or
	 * directive prefixed with `*`) and have the `TemplateRef` for this Embedded View injected into the
	 * constructor of the directive using the `TemplateRef` Token. Alternatively you can query for the
	 * `TemplateRef` from a Component or a Directive via {@link Query}.
	 *
	 * To instantiate Embedded Views based on a Template, use
	 * {@link ViewContainerRef#createEmbeddedView}, which will create the View and attach it to the
	 * View Container.
	 */
	var TemplateRef = (function () {
	    function TemplateRef() {
	    }
	    Object.defineProperty(TemplateRef.prototype, "elementRef", {
	        /**
	         * The location in the View where the Embedded View logically belongs to.
	         *
	         * The data-binding and injection contexts of Embedded Views created from this `TemplateRef`
	         * inherit from the contexts of this location.
	         *
	         * Typically new Embedded Views are attached to the View Container of this location, but in
	         * advanced use-cases, the View can be attached to a different container while keeping the
	         * data-binding and injection context from the original location.
	         *
	         */
	        // TODO(i): rename to anchor or location
	        get: function () { return null; },
	        enumerable: true,
	        configurable: true
	    });
	    return TemplateRef;
	}());
	exports.TemplateRef = TemplateRef;
	var TemplateRef_ = (function (_super) {
	    __extends(TemplateRef_, _super);
	    function TemplateRef_(_appElement, _viewFactory) {
	        _super.call(this);
	        this._appElement = _appElement;
	        this._viewFactory = _viewFactory;
	    }
	    TemplateRef_.prototype.createEmbeddedView = function (context) {
	        var view = this._viewFactory(this._appElement.parentView.viewUtils, this._appElement.parentInjector, this._appElement);
	        if (lang_1.isBlank(context)) {
	            context = EMPTY_CONTEXT;
	        }
	        view.create(context, null, null);
	        return view.ref;
	    };
	    Object.defineProperty(TemplateRef_.prototype, "elementRef", {
	        get: function () { return this._appElement.elementRef; },
	        enumerable: true,
	        configurable: true
	    });
	    return TemplateRef_;
	}(TemplateRef));
	exports.TemplateRef_ = TemplateRef_;


/***/ },
/* 84 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var exceptions_1 = __webpack_require__(12);
	var constants_1 = __webpack_require__(34);
	var ViewRef = (function () {
	    function ViewRef() {
	    }
	    Object.defineProperty(ViewRef.prototype, "destroyed", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    return ViewRef;
	}());
	exports.ViewRef = ViewRef;
	/**
	 * Represents an Angular View.
	 *
	 * <!-- TODO: move the next two paragraphs to the dev guide -->
	 * A View is a fundamental building block of the application UI. It is the smallest grouping of
	 * Elements which are created and destroyed together.
	 *
	 * Properties of elements in a View can change, but the structure (number and order) of elements in
	 * a View cannot. Changing the structure of Elements can only be done by inserting, moving or
	 * removing nested Views via a {@link ViewContainerRef}. Each View can contain many View Containers.
	 * <!-- /TODO -->
	 *
	 * ### Example
	 *
	 * Given this template...
	 *
	 * ```
	 * Count: {{items.length}}
	 * <ul>
	 *   <li *ngFor="let  item of items">{{item}}</li>
	 * </ul>
	 * ```
	 *
	 * ... we have two {@link TemplateRef}s:
	 *
	 * Outer {@link TemplateRef}:
	 * ```
	 * Count: {{items.length}}
	 * <ul>
	 *   <template ngFor let-item [ngForOf]="items"></template>
	 * </ul>
	 * ```
	 *
	 * Inner {@link TemplateRef}:
	 * ```
	 *   <li>{{item}}</li>
	 * ```
	 *
	 * Notice that the original template is broken down into two separate {@link TemplateRef}s.
	 *
	 * The outer/inner {@link TemplateRef}s are then assembled into views like so:
	 *
	 * ```
	 * <!-- ViewRef: outer-0 -->
	 * Count: 2
	 * <ul>
	 *   <template view-container-ref></template>
	 *   <!-- ViewRef: inner-1 --><li>first</li><!-- /ViewRef: inner-1 -->
	 *   <!-- ViewRef: inner-2 --><li>second</li><!-- /ViewRef: inner-2 -->
	 * </ul>
	 * <!-- /ViewRef: outer-0 -->
	 * ```
	 */
	var EmbeddedViewRef = (function (_super) {
	    __extends(EmbeddedViewRef, _super);
	    function EmbeddedViewRef() {
	        _super.apply(this, arguments);
	    }
	    Object.defineProperty(EmbeddedViewRef.prototype, "context", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(EmbeddedViewRef.prototype, "rootNodes", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    ;
	    return EmbeddedViewRef;
	}(ViewRef));
	exports.EmbeddedViewRef = EmbeddedViewRef;
	var ViewRef_ = (function () {
	    function ViewRef_(_view) {
	        this._view = _view;
	        this._view = _view;
	    }
	    Object.defineProperty(ViewRef_.prototype, "internalView", {
	        get: function () { return this._view; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ViewRef_.prototype, "rootNodes", {
	        get: function () { return this._view.flatRootNodes; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ViewRef_.prototype, "context", {
	        get: function () { return this._view.context; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ViewRef_.prototype, "destroyed", {
	        get: function () { return this._view.destroyed; },
	        enumerable: true,
	        configurable: true
	    });
	    ViewRef_.prototype.markForCheck = function () { this._view.markPathToRootAsCheckOnce(); };
	    ViewRef_.prototype.detach = function () { this._view.cdMode = constants_1.ChangeDetectionStrategy.Detached; };
	    ViewRef_.prototype.detectChanges = function () { this._view.detectChanges(false); };
	    ViewRef_.prototype.checkNoChanges = function () { this._view.detectChanges(true); };
	    ViewRef_.prototype.reattach = function () {
	        this._view.cdMode = constants_1.ChangeDetectionStrategy.CheckAlways;
	        this.markForCheck();
	    };
	    ViewRef_.prototype.onDestroy = function (callback) { this._view.disposables.push(callback); };
	    ViewRef_.prototype.destroy = function () { this._view.destroy(); };
	    return ViewRef_;
	}());
	exports.ViewRef_ = ViewRef_;


/***/ },
/* 85 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var EventListener = (function () {
	    function EventListener(name, callback) {
	        this.name = name;
	        this.callback = callback;
	    }
	    ;
	    return EventListener;
	}());
	exports.EventListener = EventListener;
	var DebugNode = (function () {
	    function DebugNode(nativeNode, parent, _debugInfo) {
	        this._debugInfo = _debugInfo;
	        this.nativeNode = nativeNode;
	        if (lang_1.isPresent(parent) && parent instanceof DebugElement) {
	            parent.addChild(this);
	        }
	        else {
	            this.parent = null;
	        }
	        this.listeners = [];
	    }
	    Object.defineProperty(DebugNode.prototype, "injector", {
	        get: function () { return lang_1.isPresent(this._debugInfo) ? this._debugInfo.injector : null; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DebugNode.prototype, "componentInstance", {
	        get: function () {
	            return lang_1.isPresent(this._debugInfo) ? this._debugInfo.component : null;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DebugNode.prototype, "context", {
	        get: function () { return lang_1.isPresent(this._debugInfo) ? this._debugInfo.context : null; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DebugNode.prototype, "references", {
	        get: function () {
	            return lang_1.isPresent(this._debugInfo) ? this._debugInfo.references : null;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DebugNode.prototype, "providerTokens", {
	        get: function () {
	            return lang_1.isPresent(this._debugInfo) ? this._debugInfo.providerTokens : null;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DebugNode.prototype, "source", {
	        get: function () { return lang_1.isPresent(this._debugInfo) ? this._debugInfo.source : null; },
	        enumerable: true,
	        configurable: true
	    });
	    /**
	     * Use injector.get(token) instead.
	     *
	     * @deprecated
	     */
	    DebugNode.prototype.inject = function (token) { return this.injector.get(token); };
	    return DebugNode;
	}());
	exports.DebugNode = DebugNode;
	var DebugElement = (function (_super) {
	    __extends(DebugElement, _super);
	    function DebugElement(nativeNode, parent, _debugInfo) {
	        _super.call(this, nativeNode, parent, _debugInfo);
	        this.properties = {};
	        this.attributes = {};
	        this.childNodes = [];
	        this.nativeElement = nativeNode;
	    }
	    DebugElement.prototype.addChild = function (child) {
	        if (lang_1.isPresent(child)) {
	            this.childNodes.push(child);
	            child.parent = this;
	        }
	    };
	    DebugElement.prototype.removeChild = function (child) {
	        var childIndex = this.childNodes.indexOf(child);
	        if (childIndex !== -1) {
	            child.parent = null;
	            this.childNodes.splice(childIndex, 1);
	        }
	    };
	    DebugElement.prototype.insertChildrenAfter = function (child, newChildren) {
	        var siblingIndex = this.childNodes.indexOf(child);
	        if (siblingIndex !== -1) {
	            var previousChildren = this.childNodes.slice(0, siblingIndex + 1);
	            var nextChildren = this.childNodes.slice(siblingIndex + 1);
	            this.childNodes =
	                collection_1.ListWrapper.concat(collection_1.ListWrapper.concat(previousChildren, newChildren), nextChildren);
	            for (var i = 0; i < newChildren.length; ++i) {
	                var newChild = newChildren[i];
	                if (lang_1.isPresent(newChild.parent)) {
	                    newChild.parent.removeChild(newChild);
	                }
	                newChild.parent = this;
	            }
	        }
	    };
	    DebugElement.prototype.query = function (predicate) {
	        var results = this.queryAll(predicate);
	        return results.length > 0 ? results[0] : null;
	    };
	    DebugElement.prototype.queryAll = function (predicate) {
	        var matches = [];
	        _queryElementChildren(this, predicate, matches);
	        return matches;
	    };
	    DebugElement.prototype.queryAllNodes = function (predicate) {
	        var matches = [];
	        _queryNodeChildren(this, predicate, matches);
	        return matches;
	    };
	    Object.defineProperty(DebugElement.prototype, "children", {
	        get: function () {
	            var children = [];
	            this.childNodes.forEach(function (node) {
	                if (node instanceof DebugElement) {
	                    children.push(node);
	                }
	            });
	            return children;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    DebugElement.prototype.triggerEventHandler = function (eventName, eventObj) {
	        this.listeners.forEach(function (listener) {
	            if (listener.name == eventName) {
	                listener.callback(eventObj);
	            }
	        });
	    };
	    return DebugElement;
	}(DebugNode));
	exports.DebugElement = DebugElement;
	function asNativeElements(debugEls) {
	    return debugEls.map(function (el) { return el.nativeElement; });
	}
	exports.asNativeElements = asNativeElements;
	function _queryElementChildren(element, predicate, matches) {
	    element.childNodes.forEach(function (node) {
	        if (node instanceof DebugElement) {
	            if (predicate(node)) {
	                matches.push(node);
	            }
	            _queryElementChildren(node, predicate, matches);
	        }
	    });
	}
	function _queryNodeChildren(parentNode, predicate, matches) {
	    if (parentNode instanceof DebugElement) {
	        parentNode.childNodes.forEach(function (node) {
	            if (predicate(node)) {
	                matches.push(node);
	            }
	            if (node instanceof DebugElement) {
	                _queryNodeChildren(node, predicate, matches);
	            }
	        });
	    }
	}
	// Need to keep the nodes in a global Map so that multiple angular apps are supported.
	var _nativeNodeToDebugNode = new Map();
	function getDebugNode(nativeNode) {
	    return _nativeNodeToDebugNode.get(nativeNode);
	}
	exports.getDebugNode = getDebugNode;
	function getAllDebugNodes() {
	    return collection_1.MapWrapper.values(_nativeNodeToDebugNode);
	}
	exports.getAllDebugNodes = getAllDebugNodes;
	function indexDebugNode(node) {
	    _nativeNodeToDebugNode.set(node.nativeNode, node);
	}
	exports.indexDebugNode = indexDebugNode;
	function removeDebugNodeFromIndex(node) {
	    _nativeNodeToDebugNode.delete(node.nativeNode);
	}
	exports.removeDebugNodeFromIndex = removeDebugNodeFromIndex;


/***/ },
/* 86 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var di_1 = __webpack_require__(6);
	/**
	 * A token that can be provided when bootstraping an application to make an array of directives
	 * available in every component of the application.
	 *
	 * ### Example
	 *
	 * ```typescript
	 * import {PLATFORM_DIRECTIVES} from 'angular2/core';
	 * import {OtherDirective} from './myDirectives';
	 *
	 * @Component({
	 *   selector: 'my-component',
	 *   template: `
	 *     <!-- can use other directive even though the component does not list it in `directives` -->
	 *     <other-directive></other-directive>
	 *   `
	 * })
	 * export class MyComponent {
	 *   ...
	 * }
	 *
	 * bootstrap(MyComponent, [provide(PLATFORM_DIRECTIVES, {useValue: [OtherDirective], multi:true})]);
	 * ```
	 */
	exports.PLATFORM_DIRECTIVES = 
	/*@ts2dart_const*/ new di_1.OpaqueToken("Platform Directives");
	/**
	 * A token that can be provided when bootstraping an application to make an array of pipes
	 * available in every component of the application.
	 *
	 * ### Example
	 *
	 * ```typescript
	 * import {PLATFORM_PIPES} from 'angular2/core';
	 * import {OtherPipe} from './myPipe';
	 *
	 * @Component({
	 *   selector: 'my-component',
	 *   template: `
	 *     {{123 | other-pipe}}
	 *   `
	 * })
	 * export class MyComponent {
	 *   ...
	 * }
	 *
	 * bootstrap(MyComponent, [provide(PLATFORM_PIPES, {useValue: [OtherPipe], multi:true})]);
	 * ```
	 */
	exports.PLATFORM_PIPES = new di_1.OpaqueToken("Platform Pipes");


/***/ },
/* 87 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var console_1 = __webpack_require__(77);
	var reflection_1 = __webpack_require__(18);
	var reflector_reader_1 = __webpack_require__(20);
	var testability_1 = __webpack_require__(65);
	var application_ref_1 = __webpack_require__(61);
	function _reflector() {
	    return reflection_1.reflector;
	}
	var __unused; // prevent missing use Dart warning.
	/**
	 * A default set of providers which should be included in any Angular platform.
	 */
	exports.PLATFORM_COMMON_PROVIDERS = [
	    application_ref_1.PLATFORM_CORE_PROVIDERS,
	    /*@ts2dart_Provider*/ { provide: reflection_1.Reflector, useFactory: _reflector, deps: [] },
	    /*@ts2dart_Provider*/ { provide: reflector_reader_1.ReflectorReader, useExisting: reflection_1.Reflector },
	    testability_1.TestabilityRegistry,
	    console_1.Console
	];


/***/ },
/* 88 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var application_tokens_1 = __webpack_require__(64);
	var application_ref_1 = __webpack_require__(61);
	var change_detection_1 = __webpack_require__(29);
	var view_utils_1 = __webpack_require__(68);
	var component_resolver_1 = __webpack_require__(66);
	var dynamic_component_loader_1 = __webpack_require__(82);
	var __unused; // avoid unused import when Type union types are erased
	/**
	 * A default set of providers which should be included in any Angular
	 * application, regardless of the platform it runs onto.
	 */
	exports.APPLICATION_COMMON_PROVIDERS = 
	/*@ts2dart_const*/ [
	    application_ref_1.APPLICATION_CORE_PROVIDERS,
	    /* @ts2dart_Provider */ { provide: component_resolver_1.ComponentResolver, useClass: component_resolver_1.ReflectorComponentResolver },
	    application_tokens_1.APP_ID_RANDOM_PROVIDER,
	    view_utils_1.ViewUtils,
	    /* @ts2dart_Provider */ { provide: change_detection_1.IterableDiffers, useValue: change_detection_1.defaultIterableDiffers },
	    /* @ts2dart_Provider */ { provide: change_detection_1.KeyValueDiffers, useValue: change_detection_1.defaultKeyValueDiffers },
	    /* @ts2dart_Provider */ { provide: dynamic_component_loader_1.DynamicComponentLoader, useClass: dynamic_component_loader_1.DynamicComponentLoader_ }
	];


/***/ },
/* 89 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	function __export(m) {
	    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
	}
	__export(__webpack_require__(90));
	__export(__webpack_require__(104));
	__export(__webpack_require__(114));
	__export(__webpack_require__(138));


/***/ },
/* 90 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * @module
	 * @description
	 * This module provides a set of common Pipes.
	 */
	"use strict";
	var async_pipe_1 = __webpack_require__(91);
	exports.AsyncPipe = async_pipe_1.AsyncPipe;
	var date_pipe_1 = __webpack_require__(93);
	exports.DatePipe = date_pipe_1.DatePipe;
	var json_pipe_1 = __webpack_require__(95);
	exports.JsonPipe = json_pipe_1.JsonPipe;
	var slice_pipe_1 = __webpack_require__(96);
	exports.SlicePipe = slice_pipe_1.SlicePipe;
	var lowercase_pipe_1 = __webpack_require__(97);
	exports.LowerCasePipe = lowercase_pipe_1.LowerCasePipe;
	var number_pipe_1 = __webpack_require__(98);
	exports.NumberPipe = number_pipe_1.NumberPipe;
	exports.DecimalPipe = number_pipe_1.DecimalPipe;
	exports.PercentPipe = number_pipe_1.PercentPipe;
	exports.CurrencyPipe = number_pipe_1.CurrencyPipe;
	var uppercase_pipe_1 = __webpack_require__(99);
	exports.UpperCasePipe = uppercase_pipe_1.UpperCasePipe;
	var replace_pipe_1 = __webpack_require__(100);
	exports.ReplacePipe = replace_pipe_1.ReplacePipe;
	var i18n_plural_pipe_1 = __webpack_require__(101);
	exports.I18nPluralPipe = i18n_plural_pipe_1.I18nPluralPipe;
	var i18n_select_pipe_1 = __webpack_require__(102);
	exports.I18nSelectPipe = i18n_select_pipe_1.I18nSelectPipe;
	var common_pipes_1 = __webpack_require__(103);
	exports.COMMON_PIPES = common_pipes_1.COMMON_PIPES;


/***/ },
/* 91 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var lang_1 = __webpack_require__(5);
	var async_1 = __webpack_require__(41);
	var core_1 = __webpack_require__(2);
	var invalid_pipe_argument_exception_1 = __webpack_require__(92);
	var ObservableStrategy = (function () {
	    function ObservableStrategy() {
	    }
	    ObservableStrategy.prototype.createSubscription = function (async, updateLatestValue) {
	        return async_1.ObservableWrapper.subscribe(async, updateLatestValue, function (e) { throw e; });
	    };
	    ObservableStrategy.prototype.dispose = function (subscription) { async_1.ObservableWrapper.dispose(subscription); };
	    ObservableStrategy.prototype.onDestroy = function (subscription) { async_1.ObservableWrapper.dispose(subscription); };
	    return ObservableStrategy;
	}());
	var PromiseStrategy = (function () {
	    function PromiseStrategy() {
	    }
	    PromiseStrategy.prototype.createSubscription = function (async, updateLatestValue) {
	        return async.then(updateLatestValue);
	    };
	    PromiseStrategy.prototype.dispose = function (subscription) { };
	    PromiseStrategy.prototype.onDestroy = function (subscription) { };
	    return PromiseStrategy;
	}());
	var _promiseStrategy = new PromiseStrategy();
	var _observableStrategy = new ObservableStrategy();
	var __unused; // avoid unused import when Promise union types are erased
	/**
	 * The `async` pipe subscribes to an Observable or Promise and returns the latest value it has
	 * emitted.
	 * When a new value is emitted, the `async` pipe marks the component to be checked for changes.
	 *
	 * ### Example
	 *
	 * This example binds a `Promise` to the view. Clicking the `Resolve` button resolves the
	 * promise.
	 *
	 * {@example core/pipes/ts/async_pipe/async_pipe_example.ts region='AsyncPipe'}
	 *
	 * It's also possible to use `async` with Observables. The example below binds the `time` Observable
	 * to the view. Every 500ms, the `time` Observable updates the view with the current time.
	 *
	 * ```typescript
	 * ```
	 */
	var AsyncPipe = (function () {
	    function AsyncPipe(_ref) {
	        /** @internal */
	        this._latestValue = null;
	        /** @internal */
	        this._latestReturnedValue = null;
	        /** @internal */
	        this._subscription = null;
	        /** @internal */
	        this._obj = null;
	        this._strategy = null;
	        this._ref = _ref;
	    }
	    AsyncPipe.prototype.ngOnDestroy = function () {
	        if (lang_1.isPresent(this._subscription)) {
	            this._dispose();
	        }
	    };
	    AsyncPipe.prototype.transform = function (obj) {
	        if (lang_1.isBlank(this._obj)) {
	            if (lang_1.isPresent(obj)) {
	                this._subscribe(obj);
	            }
	            this._latestReturnedValue = this._latestValue;
	            return this._latestValue;
	        }
	        if (obj !== this._obj) {
	            this._dispose();
	            return this.transform(obj);
	        }
	        if (this._latestValue === this._latestReturnedValue) {
	            return this._latestReturnedValue;
	        }
	        else {
	            this._latestReturnedValue = this._latestValue;
	            return core_1.WrappedValue.wrap(this._latestValue);
	        }
	    };
	    /** @internal */
	    AsyncPipe.prototype._subscribe = function (obj) {
	        var _this = this;
	        this._obj = obj;
	        this._strategy = this._selectStrategy(obj);
	        this._subscription = this._strategy.createSubscription(obj, function (value) { return _this._updateLatestValue(obj, value); });
	    };
	    /** @internal */
	    AsyncPipe.prototype._selectStrategy = function (obj) {
	        if (lang_1.isPromise(obj)) {
	            return _promiseStrategy;
	        }
	        else if (async_1.ObservableWrapper.isObservable(obj)) {
	            return _observableStrategy;
	        }
	        else {
	            throw new invalid_pipe_argument_exception_1.InvalidPipeArgumentException(AsyncPipe, obj);
	        }
	    };
	    /** @internal */
	    AsyncPipe.prototype._dispose = function () {
	        this._strategy.dispose(this._subscription);
	        this._latestValue = null;
	        this._latestReturnedValue = null;
	        this._subscription = null;
	        this._obj = null;
	    };
	    /** @internal */
	    AsyncPipe.prototype._updateLatestValue = function (async, value) {
	        if (async === this._obj) {
	            this._latestValue = value;
	            this._ref.markForCheck();
	        }
	    };
	    AsyncPipe = __decorate([
	        // avoid unused import when Promise union types are erased
	        core_1.Pipe({ name: 'async', pure: false }),
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [core_1.ChangeDetectorRef])
	    ], AsyncPipe);
	    return AsyncPipe;
	}());
	exports.AsyncPipe = AsyncPipe;


/***/ },
/* 92 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var InvalidPipeArgumentException = (function (_super) {
	    __extends(InvalidPipeArgumentException, _super);
	    function InvalidPipeArgumentException(type, value) {
	        _super.call(this, "Invalid argument '" + value + "' for pipe '" + lang_1.stringify(type) + "'");
	    }
	    return InvalidPipeArgumentException;
	}(exceptions_1.BaseException));
	exports.InvalidPipeArgumentException = InvalidPipeArgumentException;


/***/ },
/* 93 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var lang_1 = __webpack_require__(5);
	var intl_1 = __webpack_require__(94);
	var core_1 = __webpack_require__(2);
	var collection_1 = __webpack_require__(15);
	var invalid_pipe_argument_exception_1 = __webpack_require__(92);
	// TODO: move to a global configurable location along with other i18n components.
	var defaultLocale = 'en-US';
	/**
	 * Formats a date value to a string based on the requested format.
	 *
	 * WARNINGS:
	 * - this pipe is marked as pure hence it will not be re-evaluated when the input is mutated.
	 *   Instead users should treat the date as an immutable object and change the reference when the
	 *   pipe needs to re-run (this is to avoid reformatting the date on every change detection run
	 *   which would be an expensive operation).
	 * - this pipe uses the Internationalization API. Therefore it is only reliable in Chrome and Opera
	 *   browsers.
	 *
	 * ## Usage
	 *
	 *     expression | date[:format]
	 *
	 * where `expression` is a date object or a number (milliseconds since UTC epoch) and
	 * `format` indicates which date/time components to include:
	 *
	 *  | Component | Symbol | Short Form   | Long Form         | Numeric   | 2-digit   |
	 *  |-----------|:------:|--------------|-------------------|-----------|-----------|
	 *  | era       |   G    | G (AD)       | GGGG (Anno Domini)| -         | -         |
	 *  | year      |   y    | -            | -                 | y (2015)  | yy (15)   |
	 *  | month     |   M    | MMM (Sep)    | MMMM (September)  | M (9)     | MM (09)   |
	 *  | day       |   d    | -            | -                 | d (3)     | dd (03)   |
	 *  | weekday   |   E    | EEE (Sun)    | EEEE (Sunday)     | -         | -         |
	 *  | hour      |   j    | -            | -                 | j (13)    | jj (13)   |
	 *  | hour12    |   h    | -            | -                 | h (1 PM)  | hh (01 PM)|
	 *  | hour24    |   H    | -            | -                 | H (13)    | HH (13)   |
	 *  | minute    |   m    | -            | -                 | m (5)     | mm (05)   |
	 *  | second    |   s    | -            | -                 | s (9)     | ss (09)   |
	 *  | timezone  |   z    | -            | z (Pacific Standard Time)| -  | -         |
	 *  | timezone  |   Z    | Z (GMT-8:00) | -                 | -         | -         |
	 *
	 * In javascript, only the components specified will be respected (not the ordering,
	 * punctuations, ...) and details of the formatting will be dependent on the locale.
	 * On the other hand in Dart version, you can also include quoted text as well as some extra
	 * date/time components such as quarter. For more information see:
	 * https://api.dartlang.org/apidocs/channels/stable/dartdoc-viewer/intl/intl.DateFormat.
	 *
	 * `format` can also be one of the following predefined formats:
	 *
	 *  - `'medium'`: equivalent to `'yMMMdjms'` (e.g. Sep 3, 2010, 12:05:08 PM for en-US)
	 *  - `'short'`: equivalent to `'yMdjm'` (e.g. 9/3/2010, 12:05 PM for en-US)
	 *  - `'fullDate'`: equivalent to `'yMMMMEEEEd'` (e.g. Friday, September 3, 2010 for en-US)
	 *  - `'longDate'`: equivalent to `'yMMMMd'` (e.g. September 3, 2010)
	 *  - `'mediumDate'`: equivalent to `'yMMMd'` (e.g. Sep 3, 2010 for en-US)
	 *  - `'shortDate'`: equivalent to `'yMd'` (e.g. 9/3/2010 for en-US)
	 *  - `'mediumTime'`: equivalent to `'jms'` (e.g. 12:05:08 PM for en-US)
	 *  - `'shortTime'`: equivalent to `'jm'` (e.g. 12:05 PM for en-US)
	 *
	 * Timezone of the formatted text will be the local system timezone of the end-users machine.
	 *
	 * ### Examples
	 *
	 * Assuming `dateObj` is (year: 2015, month: 6, day: 15, hour: 21, minute: 43, second: 11)
	 * in the _local_ time and locale is 'en-US':
	 *
	 * ```
	 *     {{ dateObj | date }}               // output is 'Jun 15, 2015'
	 *     {{ dateObj | date:'medium' }}      // output is 'Jun 15, 2015, 9:43:11 PM'
	 *     {{ dateObj | date:'shortTime' }}   // output is '9:43 PM'
	 *     {{ dateObj | date:'mmss' }}        // output is '43:11'
	 * ```
	 *
	 * {@example core/pipes/ts/date_pipe/date_pipe_example.ts region='DatePipe'}
	 */
	var DatePipe = (function () {
	    function DatePipe() {
	    }
	    DatePipe.prototype.transform = function (value, pattern) {
	        if (pattern === void 0) { pattern = 'mediumDate'; }
	        if (lang_1.isBlank(value))
	            return null;
	        if (!this.supports(value)) {
	            throw new invalid_pipe_argument_exception_1.InvalidPipeArgumentException(DatePipe, value);
	        }
	        if (lang_1.isNumber(value)) {
	            value = lang_1.DateWrapper.fromMillis(value);
	        }
	        if (collection_1.StringMapWrapper.contains(DatePipe._ALIASES, pattern)) {
	            pattern = collection_1.StringMapWrapper.get(DatePipe._ALIASES, pattern);
	        }
	        return intl_1.DateFormatter.format(value, defaultLocale, pattern);
	    };
	    DatePipe.prototype.supports = function (obj) { return lang_1.isDate(obj) || lang_1.isNumber(obj); };
	    /** @internal */
	    DatePipe._ALIASES = {
	        'medium': 'yMMMdjms',
	        'short': 'yMdjm',
	        'fullDate': 'yMMMMEEEEd',
	        'longDate': 'yMMMMd',
	        'mediumDate': 'yMMMd',
	        'shortDate': 'yMd',
	        'mediumTime': 'jms',
	        'shortTime': 'jm'
	    };
	    DatePipe = __decorate([
	        core_1.Pipe({ name: 'date', pure: true }),
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], DatePipe);
	    return DatePipe;
	}());
	exports.DatePipe = DatePipe;


/***/ },
/* 94 */
/***/ function(module, exports) {

	"use strict";
	(function (NumberFormatStyle) {
	    NumberFormatStyle[NumberFormatStyle["Decimal"] = 0] = "Decimal";
	    NumberFormatStyle[NumberFormatStyle["Percent"] = 1] = "Percent";
	    NumberFormatStyle[NumberFormatStyle["Currency"] = 2] = "Currency";
	})(exports.NumberFormatStyle || (exports.NumberFormatStyle = {}));
	var NumberFormatStyle = exports.NumberFormatStyle;
	var NumberFormatter = (function () {
	    function NumberFormatter() {
	    }
	    NumberFormatter.format = function (num, locale, style, _a) {
	        var _b = _a === void 0 ? {} : _a, _c = _b.minimumIntegerDigits, minimumIntegerDigits = _c === void 0 ? 1 : _c, _d = _b.minimumFractionDigits, minimumFractionDigits = _d === void 0 ? 0 : _d, _e = _b.maximumFractionDigits, maximumFractionDigits = _e === void 0 ? 3 : _e, currency = _b.currency, _f = _b.currencyAsSymbol, currencyAsSymbol = _f === void 0 ? false : _f;
	        var intlOptions = {
	            minimumIntegerDigits: minimumIntegerDigits,
	            minimumFractionDigits: minimumFractionDigits,
	            maximumFractionDigits: maximumFractionDigits
	        };
	        intlOptions.style = NumberFormatStyle[style].toLowerCase();
	        if (style == NumberFormatStyle.Currency) {
	            intlOptions.currency = currency;
	            intlOptions.currencyDisplay = currencyAsSymbol ? 'symbol' : 'code';
	        }
	        return new Intl.NumberFormat(locale, intlOptions).format(num);
	    };
	    return NumberFormatter;
	}());
	exports.NumberFormatter = NumberFormatter;
	function digitCondition(len) {
	    return len == 2 ? '2-digit' : 'numeric';
	}
	function nameCondition(len) {
	    return len < 4 ? 'short' : 'long';
	}
	function extractComponents(pattern) {
	    var ret = {};
	    var i = 0, j;
	    while (i < pattern.length) {
	        j = i;
	        while (j < pattern.length && pattern[j] == pattern[i])
	            j++;
	        var len = j - i;
	        switch (pattern[i]) {
	            case 'G':
	                ret.era = nameCondition(len);
	                break;
	            case 'y':
	                ret.year = digitCondition(len);
	                break;
	            case 'M':
	                if (len >= 3)
	                    ret.month = nameCondition(len);
	                else
	                    ret.month = digitCondition(len);
	                break;
	            case 'd':
	                ret.day = digitCondition(len);
	                break;
	            case 'E':
	                ret.weekday = nameCondition(len);
	                break;
	            case 'j':
	                ret.hour = digitCondition(len);
	                break;
	            case 'h':
	                ret.hour = digitCondition(len);
	                ret.hour12 = true;
	                break;
	            case 'H':
	                ret.hour = digitCondition(len);
	                ret.hour12 = false;
	                break;
	            case 'm':
	                ret.minute = digitCondition(len);
	                break;
	            case 's':
	                ret.second = digitCondition(len);
	                break;
	            case 'z':
	                ret.timeZoneName = 'long';
	                break;
	            case 'Z':
	                ret.timeZoneName = 'short';
	                break;
	        }
	        i = j;
	    }
	    return ret;
	}
	var dateFormatterCache = new Map();
	var DateFormatter = (function () {
	    function DateFormatter() {
	    }
	    DateFormatter.format = function (date, locale, pattern) {
	        var key = locale + pattern;
	        if (dateFormatterCache.has(key)) {
	            return dateFormatterCache.get(key).format(date);
	        }
	        var formatter = new Intl.DateTimeFormat(locale, extractComponents(pattern));
	        dateFormatterCache.set(key, formatter);
	        return formatter.format(date);
	    };
	    return DateFormatter;
	}());
	exports.DateFormatter = DateFormatter;


/***/ },
/* 95 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var lang_1 = __webpack_require__(5);
	var core_1 = __webpack_require__(2);
	/**
	 * Transforms any input value using `JSON.stringify`. Useful for debugging.
	 *
	 * ### Example
	 * {@example core/pipes/ts/json_pipe/json_pipe_example.ts region='JsonPipe'}
	 */
	/* @ts2dart_const */
	var JsonPipe = (function () {
	    function JsonPipe() {
	    }
	    JsonPipe.prototype.transform = function (value) { return lang_1.Json.stringify(value); };
	    JsonPipe = __decorate([
	        core_1.Pipe({ name: 'json', pure: false }),
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], JsonPipe);
	    return JsonPipe;
	}());
	exports.JsonPipe = JsonPipe;


/***/ },
/* 96 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var core_1 = __webpack_require__(2);
	var invalid_pipe_argument_exception_1 = __webpack_require__(92);
	/**
	 * Creates a new List or String containing only a subset (slice) of the
	 * elements.
	 *
	 * The starting index of the subset to return is specified by the `start` parameter.
	 *
	 * The ending index of the subset to return is specified by the optional `end` parameter.
	 *
	 * ### Usage
	 *
	 *     expression | slice:start[:end]
	 *
	 * All behavior is based on the expected behavior of the JavaScript API
	 * Array.prototype.slice() and String.prototype.slice()
	 *
	 * Where the input expression is a [List] or [String], and `start` is:
	 *
	 * - **a positive integer**: return the item at _start_ index and all items after
	 * in the list or string expression.
	 * - **a negative integer**: return the item at _start_ index from the end and all items after
	 * in the list or string expression.
	 * - **`|start|` greater than the size of the expression**: return an empty list or string.
	 * - **`|start|` negative greater than the size of the expression**: return entire list or
	 * string expression.
	 *
	 * and where `end` is:
	 *
	 * - **omitted**: return all items until the end of the input
	 * - **a positive integer**: return all items before _end_ index of the list or string
	 * expression.
	 * - **a negative integer**: return all items before _end_ index from the end of the list
	 * or string expression.
	 *
	 * When operating on a [List], the returned list is always a copy even when all
	 * the elements are being returned.
	 *
	 * ## List Example
	 *
	 * This `ngFor` example:
	 *
	 * {@example core/pipes/ts/slice_pipe/slice_pipe_example.ts region='SlicePipe_list'}
	 *
	 * produces the following:
	 *
	 *     <li>b</li>
	 *     <li>c</li>
	 *
	 * ## String Examples
	 *
	 * {@example core/pipes/ts/slice_pipe/slice_pipe_example.ts region='SlicePipe_string'}
	 */
	var SlicePipe = (function () {
	    function SlicePipe() {
	    }
	    SlicePipe.prototype.transform = function (value, start, end) {
	        if (end === void 0) { end = null; }
	        if (!this.supports(value)) {
	            throw new invalid_pipe_argument_exception_1.InvalidPipeArgumentException(SlicePipe, value);
	        }
	        if (lang_1.isBlank(value))
	            return value;
	        if (lang_1.isString(value)) {
	            return lang_1.StringWrapper.slice(value, start, end);
	        }
	        return collection_1.ListWrapper.slice(value, start, end);
	    };
	    SlicePipe.prototype.supports = function (obj) { return lang_1.isString(obj) || lang_1.isArray(obj); };
	    SlicePipe = __decorate([
	        core_1.Pipe({ name: 'slice', pure: false }),
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], SlicePipe);
	    return SlicePipe;
	}());
	exports.SlicePipe = SlicePipe;


/***/ },
/* 97 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var lang_1 = __webpack_require__(5);
	var core_1 = __webpack_require__(2);
	var invalid_pipe_argument_exception_1 = __webpack_require__(92);
	/**
	 * Transforms text to lowercase.
	 *
	 * ### Example
	 *
	 * {@example core/pipes/ts/lowerupper_pipe/lowerupper_pipe_example.ts region='LowerUpperPipe'}
	 */
	var LowerCasePipe = (function () {
	    function LowerCasePipe() {
	    }
	    LowerCasePipe.prototype.transform = function (value) {
	        if (lang_1.isBlank(value))
	            return value;
	        if (!lang_1.isString(value)) {
	            throw new invalid_pipe_argument_exception_1.InvalidPipeArgumentException(LowerCasePipe, value);
	        }
	        return value.toLowerCase();
	    };
	    LowerCasePipe = __decorate([
	        core_1.Pipe({ name: 'lowercase' }),
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], LowerCasePipe);
	    return LowerCasePipe;
	}());
	exports.LowerCasePipe = LowerCasePipe;


/***/ },
/* 98 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var intl_1 = __webpack_require__(94);
	var core_1 = __webpack_require__(2);
	var invalid_pipe_argument_exception_1 = __webpack_require__(92);
	var defaultLocale = 'en-US';
	var _re = lang_1.RegExpWrapper.create('^(\\d+)?\\.((\\d+)(\\-(\\d+))?)?$');
	/**
	 * Internal base class for numeric pipes.
	 */
	var NumberPipe = (function () {
	    function NumberPipe() {
	    }
	    /** @internal */
	    NumberPipe._format = function (value, style, digits, currency, currencyAsSymbol) {
	        if (currency === void 0) { currency = null; }
	        if (currencyAsSymbol === void 0) { currencyAsSymbol = false; }
	        if (lang_1.isBlank(value))
	            return null;
	        if (!lang_1.isNumber(value)) {
	            throw new invalid_pipe_argument_exception_1.InvalidPipeArgumentException(NumberPipe, value);
	        }
	        var minInt = 1, minFraction = 0, maxFraction = 3;
	        if (lang_1.isPresent(digits)) {
	            var parts = lang_1.RegExpWrapper.firstMatch(_re, digits);
	            if (lang_1.isBlank(parts)) {
	                throw new exceptions_1.BaseException(digits + " is not a valid digit info for number pipes");
	            }
	            if (lang_1.isPresent(parts[1])) {
	                minInt = lang_1.NumberWrapper.parseIntAutoRadix(parts[1]);
	            }
	            if (lang_1.isPresent(parts[3])) {
	                minFraction = lang_1.NumberWrapper.parseIntAutoRadix(parts[3]);
	            }
	            if (lang_1.isPresent(parts[5])) {
	                maxFraction = lang_1.NumberWrapper.parseIntAutoRadix(parts[5]);
	            }
	        }
	        return intl_1.NumberFormatter.format(value, defaultLocale, style, {
	            minimumIntegerDigits: minInt,
	            minimumFractionDigits: minFraction,
	            maximumFractionDigits: maxFraction,
	            currency: currency,
	            currencyAsSymbol: currencyAsSymbol
	        });
	    };
	    NumberPipe = __decorate([
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], NumberPipe);
	    return NumberPipe;
	}());
	exports.NumberPipe = NumberPipe;
	/**
	 * WARNING: this pipe uses the Internationalization API.
	 * Therefore it is only reliable in Chrome and Opera browsers.
	 *
	 * Formats a number as local text. i.e. group sizing and separator and other locale-specific
	 * configurations are based on the active locale.
	 *
	 * ### Usage
	 *
	 *     expression | number[:digitInfo]
	 *
	 * where `expression` is a number and `digitInfo` has the following format:
	 *
	 *     {minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}
	 *
	 * - minIntegerDigits is the minimum number of integer digits to use. Defaults to 1.
	 * - minFractionDigits is the minimum number of digits after fraction. Defaults to 0.
	 * - maxFractionDigits is the maximum number of digits after fraction. Defaults to 3.
	 *
	 * For more information on the acceptable range for each of these numbers and other
	 * details see your native internationalization library.
	 *
	 * ### Example
	 *
	 * {@example core/pipes/ts/number_pipe/number_pipe_example.ts region='NumberPipe'}
	 */
	var DecimalPipe = (function (_super) {
	    __extends(DecimalPipe, _super);
	    function DecimalPipe() {
	        _super.apply(this, arguments);
	    }
	    DecimalPipe.prototype.transform = function (value, digits) {
	        if (digits === void 0) { digits = null; }
	        return NumberPipe._format(value, intl_1.NumberFormatStyle.Decimal, digits);
	    };
	    DecimalPipe = __decorate([
	        core_1.Pipe({ name: 'number' }),
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], DecimalPipe);
	    return DecimalPipe;
	}(NumberPipe));
	exports.DecimalPipe = DecimalPipe;
	/**
	 * WARNING: this pipe uses the Internationalization API.
	 * Therefore it is only reliable in Chrome and Opera browsers.
	 *
	 * Formats a number as local percent.
	 *
	 * ### Usage
	 *
	 *     expression | percent[:digitInfo]
	 *
	 * For more information about `digitInfo` see {@link DecimalPipe}
	 *
	 * ### Example
	 *
	 * {@example core/pipes/ts/number_pipe/number_pipe_example.ts region='PercentPipe'}
	 */
	var PercentPipe = (function (_super) {
	    __extends(PercentPipe, _super);
	    function PercentPipe() {
	        _super.apply(this, arguments);
	    }
	    PercentPipe.prototype.transform = function (value, digits) {
	        if (digits === void 0) { digits = null; }
	        return NumberPipe._format(value, intl_1.NumberFormatStyle.Percent, digits);
	    };
	    PercentPipe = __decorate([
	        core_1.Pipe({ name: 'percent' }),
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], PercentPipe);
	    return PercentPipe;
	}(NumberPipe));
	exports.PercentPipe = PercentPipe;
	/**
	 * WARNING: this pipe uses the Internationalization API.
	 * Therefore it is only reliable in Chrome and Opera browsers.
	 *
	 * Formats a number as local currency.
	 *
	 * ### Usage
	 *
	 *     expression | currency[:currencyCode[:symbolDisplay[:digitInfo]]]
	 *
	 * where `currencyCode` is the ISO 4217 currency code, such as "USD" for the US dollar and
	 * "EUR" for the euro. `symbolDisplay` is a boolean indicating whether to use the currency
	 * symbol (e.g. $) or the currency code (e.g. USD) in the output. The default for this value
	 * is `false`.
	 * For more information about `digitInfo` see {@link DecimalPipe}
	 *
	 * ### Example
	 *
	 * {@example core/pipes/ts/number_pipe/number_pipe_example.ts region='CurrencyPipe'}
	 */
	var CurrencyPipe = (function (_super) {
	    __extends(CurrencyPipe, _super);
	    function CurrencyPipe() {
	        _super.apply(this, arguments);
	    }
	    CurrencyPipe.prototype.transform = function (value, currencyCode, symbolDisplay, digits) {
	        if (currencyCode === void 0) { currencyCode = 'USD'; }
	        if (symbolDisplay === void 0) { symbolDisplay = false; }
	        if (digits === void 0) { digits = null; }
	        return NumberPipe._format(value, intl_1.NumberFormatStyle.Currency, digits, currencyCode, symbolDisplay);
	    };
	    CurrencyPipe = __decorate([
	        core_1.Pipe({ name: 'currency' }),
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], CurrencyPipe);
	    return CurrencyPipe;
	}(NumberPipe));
	exports.CurrencyPipe = CurrencyPipe;


/***/ },
/* 99 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var lang_1 = __webpack_require__(5);
	var core_1 = __webpack_require__(2);
	var invalid_pipe_argument_exception_1 = __webpack_require__(92);
	/**
	 * Implements uppercase transforms to text.
	 *
	 * ### Example
	 *
	 * {@example core/pipes/ts/lowerupper_pipe/lowerupper_pipe_example.ts region='LowerUpperPipe'}
	 */
	var UpperCasePipe = (function () {
	    function UpperCasePipe() {
	    }
	    UpperCasePipe.prototype.transform = function (value) {
	        if (lang_1.isBlank(value))
	            return value;
	        if (!lang_1.isString(value)) {
	            throw new invalid_pipe_argument_exception_1.InvalidPipeArgumentException(UpperCasePipe, value);
	        }
	        return value.toUpperCase();
	    };
	    UpperCasePipe = __decorate([
	        core_1.Pipe({ name: 'uppercase' }),
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], UpperCasePipe);
	    return UpperCasePipe;
	}());
	exports.UpperCasePipe = UpperCasePipe;


/***/ },
/* 100 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var lang_1 = __webpack_require__(5);
	var core_1 = __webpack_require__(2);
	var invalid_pipe_argument_exception_1 = __webpack_require__(92);
	/**
	 * Creates a new String with some or all of the matches of a pattern replaced by
	 * a replacement.
	 *
	 * The pattern to be matched is specified by the 'pattern' parameter.
	 *
	 * The replacement to be set is specified by the 'replacement' parameter.
	 *
	 * An optional 'flags' parameter can be set.
	 *
	 * ### Usage
	 *
	 *     expression | replace:pattern:replacement
	 *
	 * All behavior is based on the expected behavior of the JavaScript API
	 * String.prototype.replace() function.
	 *
	 * Where the input expression is a [String] or [Number] (to be treated as a string),
	 * the `pattern` is a [String] or [RegExp],
	 * the 'replacement' is a [String] or [Function].
	 *
	 * --Note--: The 'pattern' parameter will be converted to a RegExp instance. Make sure to escape the
	 * string properly if you are matching for regular expression special characters like parenthesis,
	 * brackets etc.
	 */
	var ReplacePipe = (function () {
	    function ReplacePipe() {
	    }
	    ReplacePipe.prototype.transform = function (value, pattern, replacement) {
	        if (lang_1.isBlank(value)) {
	            return value;
	        }
	        if (!this._supportedInput(value)) {
	            throw new invalid_pipe_argument_exception_1.InvalidPipeArgumentException(ReplacePipe, value);
	        }
	        var input = value.toString();
	        if (!this._supportedPattern(pattern)) {
	            throw new invalid_pipe_argument_exception_1.InvalidPipeArgumentException(ReplacePipe, pattern);
	        }
	        if (!this._supportedReplacement(replacement)) {
	            throw new invalid_pipe_argument_exception_1.InvalidPipeArgumentException(ReplacePipe, replacement);
	        }
	        // template fails with literal RegExp e.g /pattern/igm
	        // var rgx = pattern instanceof RegExp ? pattern : RegExpWrapper.create(pattern);
	        if (lang_1.isFunction(replacement)) {
	            var rgxPattern = lang_1.isString(pattern) ? lang_1.RegExpWrapper.create(pattern) : pattern;
	            return lang_1.StringWrapper.replaceAllMapped(input, rgxPattern, replacement);
	        }
	        if (pattern instanceof RegExp) {
	            // use the replaceAll variant
	            return lang_1.StringWrapper.replaceAll(input, pattern, replacement);
	        }
	        return lang_1.StringWrapper.replace(input, pattern, replacement);
	    };
	    ReplacePipe.prototype._supportedInput = function (input) { return lang_1.isString(input) || lang_1.isNumber(input); };
	    ReplacePipe.prototype._supportedPattern = function (pattern) {
	        return lang_1.isString(pattern) || pattern instanceof RegExp;
	    };
	    ReplacePipe.prototype._supportedReplacement = function (replacement) {
	        return lang_1.isString(replacement) || lang_1.isFunction(replacement);
	    };
	    ReplacePipe = __decorate([
	        core_1.Pipe({ name: 'replace' }),
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], ReplacePipe);
	    return ReplacePipe;
	}());
	exports.ReplacePipe = ReplacePipe;


/***/ },
/* 101 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var lang_1 = __webpack_require__(5);
	var core_1 = __webpack_require__(2);
	var invalid_pipe_argument_exception_1 = __webpack_require__(92);
	var interpolationExp = lang_1.RegExpWrapper.create('#');
	/**
	 *
	 *  Maps a value to a string that pluralizes the value properly.
	 *
	 *  ## Usage
	 *
	 *  expression | i18nPlural:mapping
	 *
	 *  where `expression` is a number and `mapping` is an object that indicates the proper text for
	 *  when the `expression` evaluates to 0, 1, or some other number.  You can interpolate the actual
	 *  value into the text using the `#` sign.
	 *
	 *  ## Example
	 *
	 *  ```
	 *  <div>
	 *    {{ messages.length | i18nPlural: messageMapping }}
	 *  </div>
	 *
	 *  class MyApp {
	 *    messages: any[];
	 *    messageMapping: any = {
	 *      '=0': 'No messages.',
	 *      '=1': 'One message.',
	 *      'other': '# messages.'
	 *    }
	 *    ...
	 *  }
	 *  ```
	 *
	 */
	var I18nPluralPipe = (function () {
	    function I18nPluralPipe() {
	    }
	    I18nPluralPipe.prototype.transform = function (value, pluralMap) {
	        var key;
	        var valueStr;
	        if (!lang_1.isStringMap(pluralMap)) {
	            throw new invalid_pipe_argument_exception_1.InvalidPipeArgumentException(I18nPluralPipe, pluralMap);
	        }
	        key = value === 0 || value === 1 ? "=" + value : 'other';
	        valueStr = lang_1.isPresent(value) ? value.toString() : '';
	        return lang_1.StringWrapper.replaceAll(pluralMap[key], interpolationExp, valueStr);
	    };
	    I18nPluralPipe = __decorate([
	        core_1.Pipe({ name: 'i18nPlural', pure: true }),
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], I18nPluralPipe);
	    return I18nPluralPipe;
	}());
	exports.I18nPluralPipe = I18nPluralPipe;


/***/ },
/* 102 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var core_1 = __webpack_require__(2);
	var invalid_pipe_argument_exception_1 = __webpack_require__(92);
	/**
	 *
	 *  Generic selector that displays the string that matches the current value.
	 *
	 *  ## Usage
	 *
	 *  expression | i18nSelect:mapping
	 *
	 *  where `mapping` is an object that indicates the text that should be displayed
	 *  for different values of the provided `expression`.
	 *
	 *  ## Example
	 *
	 *  ```
	 *  <div>
	 *    {{ gender | i18nSelect: inviteMap }}
	 *  </div>
	 *
	 *  class MyApp {
	 *    gender: string = 'male';
	 *    inviteMap: any = {
	 *      'male': 'Invite her.',
	 *      'female': 'Invite him.',
	 *      'other': 'Invite them.'
	 *    }
	 *    ...
	 *  }
	 *  ```
	 */
	var I18nSelectPipe = (function () {
	    function I18nSelectPipe() {
	    }
	    I18nSelectPipe.prototype.transform = function (value, mapping) {
	        if (!lang_1.isStringMap(mapping)) {
	            throw new invalid_pipe_argument_exception_1.InvalidPipeArgumentException(I18nSelectPipe, mapping);
	        }
	        return collection_1.StringMapWrapper.contains(mapping, value) ? mapping[value] : mapping['other'];
	    };
	    I18nSelectPipe = __decorate([
	        core_1.Pipe({ name: 'i18nSelect', pure: true }),
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], I18nSelectPipe);
	    return I18nSelectPipe;
	}());
	exports.I18nSelectPipe = I18nSelectPipe;


/***/ },
/* 103 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	/**
	 * @module
	 * @description
	 * This module provides a set of common Pipes.
	 */
	var async_pipe_1 = __webpack_require__(91);
	var uppercase_pipe_1 = __webpack_require__(99);
	var lowercase_pipe_1 = __webpack_require__(97);
	var json_pipe_1 = __webpack_require__(95);
	var slice_pipe_1 = __webpack_require__(96);
	var date_pipe_1 = __webpack_require__(93);
	var number_pipe_1 = __webpack_require__(98);
	var replace_pipe_1 = __webpack_require__(100);
	var i18n_plural_pipe_1 = __webpack_require__(101);
	var i18n_select_pipe_1 = __webpack_require__(102);
	/**
	 * A collection of Angular core pipes that are likely to be used in each and every
	 * application.
	 *
	 * This collection can be used to quickly enumerate all the built-in pipes in the `pipes`
	 * property of the `@Component` decorator.
	 */
	exports.COMMON_PIPES = [
	    async_pipe_1.AsyncPipe,
	    uppercase_pipe_1.UpperCasePipe,
	    lowercase_pipe_1.LowerCasePipe,
	    json_pipe_1.JsonPipe,
	    slice_pipe_1.SlicePipe,
	    number_pipe_1.DecimalPipe,
	    number_pipe_1.PercentPipe,
	    number_pipe_1.CurrencyPipe,
	    date_pipe_1.DatePipe,
	    replace_pipe_1.ReplacePipe,
	    i18n_plural_pipe_1.I18nPluralPipe,
	    i18n_select_pipe_1.I18nSelectPipe
	];


/***/ },
/* 104 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	function __export(m) {
	    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
	}
	/**
	 * @module
	 * @description
	 * Common directives shipped with Angular.
	 */
	var ng_class_1 = __webpack_require__(105);
	exports.NgClass = ng_class_1.NgClass;
	var ng_for_1 = __webpack_require__(106);
	exports.NgFor = ng_for_1.NgFor;
	var ng_if_1 = __webpack_require__(107);
	exports.NgIf = ng_if_1.NgIf;
	var ng_template_outlet_1 = __webpack_require__(108);
	exports.NgTemplateOutlet = ng_template_outlet_1.NgTemplateOutlet;
	var ng_style_1 = __webpack_require__(109);
	exports.NgStyle = ng_style_1.NgStyle;
	var ng_switch_1 = __webpack_require__(110);
	exports.NgSwitch = ng_switch_1.NgSwitch;
	exports.NgSwitchWhen = ng_switch_1.NgSwitchWhen;
	exports.NgSwitchDefault = ng_switch_1.NgSwitchDefault;
	var ng_plural_1 = __webpack_require__(111);
	exports.NgPlural = ng_plural_1.NgPlural;
	exports.NgPluralCase = ng_plural_1.NgPluralCase;
	exports.NgLocalization = ng_plural_1.NgLocalization;
	__export(__webpack_require__(112));
	var core_directives_1 = __webpack_require__(113);
	exports.CORE_DIRECTIVES = core_directives_1.CORE_DIRECTIVES;


/***/ },
/* 105 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var lang_1 = __webpack_require__(5);
	var core_1 = __webpack_require__(2);
	var collection_1 = __webpack_require__(15);
	/**
	 * 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;
	 *     }
	 *   }
	 * }
	 * ```
	 */
	var NgClass = (function () {
	    function NgClass(_iterableDiffers, _keyValueDiffers, _ngEl, _renderer) {
	        this._iterableDiffers = _iterableDiffers;
	        this._keyValueDiffers = _keyValueDiffers;
	        this._ngEl = _ngEl;
	        this._renderer = _renderer;
	        this._initialClasses = [];
	    }
	    Object.defineProperty(NgClass.prototype, "initialClasses", {
	        set: function (v) {
	            this._applyInitialClasses(true);
	            this._initialClasses = lang_1.isPresent(v) && lang_1.isString(v) ? v.split(' ') : [];
	            this._applyInitialClasses(false);
	            this._applyClasses(this._rawClass, false);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgClass.prototype, "rawClass", {
	        set: function (v) {
	            this._cleanupClasses(this._rawClass);
	            if (lang_1.isString(v)) {
	                v = v.split(' ');
	            }
	            this._rawClass = v;
	            this._iterableDiffer = null;
	            this._keyValueDiffer = null;
	            if (lang_1.isPresent(v)) {
	                if (collection_1.isListLikeIterable(v)) {
	                    this._iterableDiffer = this._iterableDiffers.find(v).create(null);
	                }
	                else {
	                    this._keyValueDiffer = this._keyValueDiffers.find(v).create(null);
	                }
	            }
	        },
	        enumerable: true,
	        configurable: true
	    });
	    NgClass.prototype.ngDoCheck = function () {
	        if (lang_1.isPresent(this._iterableDiffer)) {
	            var changes = this._iterableDiffer.diff(this._rawClass);
	            if (lang_1.isPresent(changes)) {
	                this._applyIterableChanges(changes);
	            }
	        }
	        if (lang_1.isPresent(this._keyValueDiffer)) {
	            var changes = this._keyValueDiffer.diff(this._rawClass);
	            if (lang_1.isPresent(changes)) {
	                this._applyKeyValueChanges(changes);
	            }
	        }
	    };
	    NgClass.prototype.ngOnDestroy = function () { this._cleanupClasses(this._rawClass); };
	    NgClass.prototype._cleanupClasses = function (rawClassVal) {
	        this._applyClasses(rawClassVal, true);
	        this._applyInitialClasses(false);
	    };
	    NgClass.prototype._applyKeyValueChanges = function (changes) {
	        var _this = this;
	        changes.forEachAddedItem(function (record) { _this._toggleClass(record.key, record.currentValue); });
	        changes.forEachChangedItem(function (record) { _this._toggleClass(record.key, record.currentValue); });
	        changes.forEachRemovedItem(function (record) {
	            if (record.previousValue) {
	                _this._toggleClass(record.key, false);
	            }
	        });
	    };
	    NgClass.prototype._applyIterableChanges = function (changes) {
	        var _this = this;
	        changes.forEachAddedItem(function (record) { _this._toggleClass(record.item, true); });
	        changes.forEachRemovedItem(function (record) { _this._toggleClass(record.item, false); });
	    };
	    NgClass.prototype._applyInitialClasses = function (isCleanup) {
	        var _this = this;
	        this._initialClasses.forEach(function (className) { return _this._toggleClass(className, !isCleanup); });
	    };
	    NgClass.prototype._applyClasses = function (rawClassVal, isCleanup) {
	        var _this = this;
	        if (lang_1.isPresent(rawClassVal)) {
	            if (lang_1.isArray(rawClassVal)) {
	                rawClassVal.forEach(function (className) { return _this._toggleClass(className, !isCleanup); });
	            }
	            else if (rawClassVal instanceof Set) {
	                rawClassVal.forEach(function (className) { return _this._toggleClass(className, !isCleanup); });
	            }
	            else {
	                collection_1.StringMapWrapper.forEach(rawClassVal, function (expVal, className) {
	                    if (lang_1.isPresent(expVal))
	                        _this._toggleClass(className, !isCleanup);
	                });
	            }
	        }
	    };
	    NgClass.prototype._toggleClass = function (className, enabled) {
	        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);
	            }
	        }
	    };
	    NgClass = __decorate([
	        core_1.Directive({ selector: '[ngClass]', inputs: ['rawClass: ngClass', 'initialClasses: class'] }), 
	        __metadata('design:paramtypes', [core_1.IterableDiffers, core_1.KeyValueDiffers, core_1.ElementRef, core_1.Renderer])
	    ], NgClass);
	    return NgClass;
	}());
	exports.NgClass = NgClass;


/***/ },
/* 106 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var core_1 = __webpack_require__(2);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var NgForRow = (function () {
	    function NgForRow($implicit, index, count) {
	        this.$implicit = $implicit;
	        this.index = index;
	        this.count = count;
	    }
	    Object.defineProperty(NgForRow.prototype, "first", {
	        get: function () { return this.index === 0; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgForRow.prototype, "last", {
	        get: function () { return this.index === this.count - 1; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgForRow.prototype, "even", {
	        get: function () { return this.index % 2 === 0; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgForRow.prototype, "odd", {
	        get: function () { return !this.even; },
	        enumerable: true,
	        configurable: true
	    });
	    return NgForRow;
	}());
	exports.NgForRow = NgForRow;
	/**
	 * 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.
	 * * `first` will be set to a boolean value indicating whether the item is the first one in the
	 *   iteration.
	 * * `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="let 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.
	 */
	var NgFor = (function () {
	    function NgFor(_viewContainer, _templateRef, _iterableDiffers, _cdr) {
	        this._viewContainer = _viewContainer;
	        this._templateRef = _templateRef;
	        this._iterableDiffers = _iterableDiffers;
	        this._cdr = _cdr;
	    }
	    Object.defineProperty(NgFor.prototype, "ngForOf", {
	        set: function (value) {
	            this._ngForOf = value;
	            if (lang_1.isBlank(this._differ) && lang_1.isPresent(value)) {
	                try {
	                    this._differ = this._iterableDiffers.find(value).create(this._cdr, this._ngForTrackBy);
	                }
	                catch (e) {
	                    throw new exceptions_1.BaseException("Cannot find a differ supporting object '" + value + "' of type '" + lang_1.getTypeNameForDebugging(value) + "'. NgFor only supports binding to Iterables such as Arrays.");
	                }
	            }
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgFor.prototype, "ngForTemplate", {
	        set: function (value) {
	            if (lang_1.isPresent(value)) {
	                this._templateRef = value;
	            }
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgFor.prototype, "ngForTrackBy", {
	        set: function (value) { this._ngForTrackBy = value; },
	        enumerable: true,
	        configurable: true
	    });
	    NgFor.prototype.ngDoCheck = function () {
	        if (lang_1.isPresent(this._differ)) {
	            var changes = this._differ.diff(this._ngForOf);
	            if (lang_1.isPresent(changes))
	                this._applyChanges(changes);
	        }
	    };
	    NgFor.prototype._applyChanges = function (changes) {
	        var _this = this;
	        // TODO(rado): check if change detection can produce a change record that is
	        // easier to consume than current.
	        var recordViewTuples = [];
	        changes.forEachRemovedItem(function (removedRecord) {
	            return recordViewTuples.push(new RecordViewTuple(removedRecord, null));
	        });
	        changes.forEachMovedItem(function (movedRecord) {
	            return recordViewTuples.push(new RecordViewTuple(movedRecord, null));
	        });
	        var insertTuples = this._bulkRemove(recordViewTuples);
	        changes.forEachAddedItem(function (addedRecord) {
	            return 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 = this._viewContainer.get(i);
	            viewRef.context.index = i;
	            viewRef.context.count = ilen;
	        }
	        changes.forEachIdentityChange(function (record) {
	            var viewRef = _this._viewContainer.get(record.currentIndex);
	            viewRef.context.$implicit = record.item;
	        });
	    };
	    NgFor.prototype._perViewChange = function (view, record) {
	        view.context.$implicit = record.item;
	    };
	    NgFor.prototype._bulkRemove = function (tuples) {
	        tuples.sort(function (a, b) {
	            return a.record.previousIndex - b.record.previousIndex;
	        });
	        var movedTuples = [];
	        for (var i = tuples.length - 1; i >= 0; i--) {
	            var tuple = tuples[i];
	            // separate moved views from removed views.
	            if (lang_1.isPresent(tuple.record.currentIndex)) {
	                tuple.view =
	                    this._viewContainer.detach(tuple.record.previousIndex);
	                movedTuples.push(tuple);
	            }
	            else {
	                this._viewContainer.remove(tuple.record.previousIndex);
	            }
	        }
	        return movedTuples;
	    };
	    NgFor.prototype._bulkInsert = function (tuples) {
	        tuples.sort(function (a, b) { return a.record.currentIndex - b.record.currentIndex; });
	        for (var i = 0; i < tuples.length; i++) {
	            var tuple = tuples[i];
	            if (lang_1.isPresent(tuple.view)) {
	                this._viewContainer.insert(tuple.view, tuple.record.currentIndex);
	            }
	            else {
	                tuple.view = this._viewContainer.createEmbeddedView(this._templateRef, new NgForRow(null, null, null), tuple.record.currentIndex);
	            }
	        }
	        return tuples;
	    };
	    NgFor = __decorate([
	        core_1.Directive({ selector: '[ngFor][ngForOf]', inputs: ['ngForTrackBy', 'ngForOf', 'ngForTemplate'] }), 
	        __metadata('design:paramtypes', [core_1.ViewContainerRef, core_1.TemplateRef, core_1.IterableDiffers, core_1.ChangeDetectorRef])
	    ], NgFor);
	    return NgFor;
	}());
	exports.NgFor = NgFor;
	var RecordViewTuple = (function () {
	    function RecordViewTuple(record, view) {
	        this.record = record;
	        this.view = view;
	    }
	    return RecordViewTuple;
	}());


/***/ },
/* 107 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var core_1 = __webpack_require__(2);
	var lang_1 = __webpack_require__(5);
	/**
	 * 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>`
	 */
	var NgIf = (function () {
	    function NgIf(_viewContainer, _templateRef) {
	        this._viewContainer = _viewContainer;
	        this._templateRef = _templateRef;
	        this._prevCondition = null;
	    }
	    Object.defineProperty(NgIf.prototype, "ngIf", {
	        set: function (newCondition /* boolean */) {
	            if (newCondition && (lang_1.isBlank(this._prevCondition) || !this._prevCondition)) {
	                this._prevCondition = true;
	                this._viewContainer.createEmbeddedView(this._templateRef);
	            }
	            else if (!newCondition && (lang_1.isBlank(this._prevCondition) || this._prevCondition)) {
	                this._prevCondition = false;
	                this._viewContainer.clear();
	            }
	        },
	        enumerable: true,
	        configurable: true
	    });
	    NgIf = __decorate([
	        core_1.Directive({ selector: '[ngIf]', inputs: ['ngIf'] }), 
	        __metadata('design:paramtypes', [core_1.ViewContainerRef, core_1.TemplateRef])
	    ], NgIf);
	    return NgIf;
	}());
	exports.NgIf = NgIf;


/***/ },
/* 108 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var core_1 = __webpack_require__(2);
	var lang_1 = __webpack_require__(5);
	/**
	 * Creates and inserts an embedded view based on a prepared `TemplateRef`.
	 *
	 * ### Syntax
	 * - `<template [ngTemplateOutlet]="templateRefExpression"></template>`
	 */
	var NgTemplateOutlet = (function () {
	    function NgTemplateOutlet(_viewContainerRef) {
	        this._viewContainerRef = _viewContainerRef;
	    }
	    Object.defineProperty(NgTemplateOutlet.prototype, "ngTemplateOutlet", {
	        set: function (templateRef) {
	            if (lang_1.isPresent(this._insertedViewRef)) {
	                this._viewContainerRef.remove(this._viewContainerRef.indexOf(this._insertedViewRef));
	            }
	            if (lang_1.isPresent(templateRef)) {
	                this._insertedViewRef = this._viewContainerRef.createEmbeddedView(templateRef);
	            }
	        },
	        enumerable: true,
	        configurable: true
	    });
	    __decorate([
	        core_1.Input(), 
	        __metadata('design:type', core_1.TemplateRef), 
	        __metadata('design:paramtypes', [core_1.TemplateRef])
	    ], NgTemplateOutlet.prototype, "ngTemplateOutlet", null);
	    NgTemplateOutlet = __decorate([
	        core_1.Directive({ selector: '[ngTemplateOutlet]' }), 
	        __metadata('design:paramtypes', [core_1.ViewContainerRef])
	    ], NgTemplateOutlet);
	    return NgTemplateOutlet;
	}());
	exports.NgTemplateOutlet = NgTemplateOutlet;


/***/ },
/* 109 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var core_1 = __webpack_require__(2);
	var lang_1 = __webpack_require__(5);
	/**
	 * 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.
	 */
	var NgStyle = (function () {
	    function NgStyle(_differs, _ngEl, _renderer) {
	        this._differs = _differs;
	        this._ngEl = _ngEl;
	        this._renderer = _renderer;
	    }
	    Object.defineProperty(NgStyle.prototype, "rawStyle", {
	        set: function (v) {
	            this._rawStyle = v;
	            if (lang_1.isBlank(this._differ) && lang_1.isPresent(v)) {
	                this._differ = this._differs.find(this._rawStyle).create(null);
	            }
	        },
	        enumerable: true,
	        configurable: true
	    });
	    NgStyle.prototype.ngDoCheck = function () {
	        if (lang_1.isPresent(this._differ)) {
	            var changes = this._differ.diff(this._rawStyle);
	            if (lang_1.isPresent(changes)) {
	                this._applyChanges(changes);
	            }
	        }
	    };
	    NgStyle.prototype._applyChanges = function (changes) {
	        var _this = this;
	        changes.forEachAddedItem(function (record) { _this._setStyle(record.key, record.currentValue); });
	        changes.forEachChangedItem(function (record) { _this._setStyle(record.key, record.currentValue); });
	        changes.forEachRemovedItem(function (record) { _this._setStyle(record.key, null); });
	    };
	    NgStyle.prototype._setStyle = function (name, val) {
	        this._renderer.setElementStyle(this._ngEl.nativeElement, name, val);
	    };
	    NgStyle = __decorate([
	        core_1.Directive({ selector: '[ngStyle]', inputs: ['rawStyle: ngStyle'] }), 
	        __metadata('design:paramtypes', [core_1.KeyValueDiffers, core_1.ElementRef, core_1.Renderer])
	    ], NgStyle);
	    return NgStyle;
	}());
	exports.NgStyle = NgStyle;


/***/ },
/* 110 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var core_1 = __webpack_require__(2);
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var _WHEN_DEFAULT = new Object();
	var SwitchView = (function () {
	    function SwitchView(_viewContainerRef, _templateRef) {
	        this._viewContainerRef = _viewContainerRef;
	        this._templateRef = _templateRef;
	    }
	    SwitchView.prototype.create = function () { this._viewContainerRef.createEmbeddedView(this._templateRef); };
	    SwitchView.prototype.destroy = function () { this._viewContainerRef.clear(); };
	    return SwitchView;
	}());
	exports.SwitchView = SwitchView;
	/**
	 * 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));
	 * ```
	 */
	var NgSwitch = (function () {
	    function NgSwitch() {
	        this._useDefault = false;
	        this._valueViews = new collection_1.Map();
	        this._activeViews = [];
	    }
	    Object.defineProperty(NgSwitch.prototype, "ngSwitch", {
	        set: function (value) {
	            // 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 (lang_1.isBlank(views)) {
	                this._useDefault = true;
	                views = lang_1.normalizeBlank(this._valueViews.get(_WHEN_DEFAULT));
	            }
	            this._activateViews(views);
	            this._switchValue = value;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    /** @internal */
	    NgSwitch.prototype._onWhenValueChanged = function (oldWhen, newWhen, view) {
	        this._deregisterView(oldWhen, view);
	        this._registerView(newWhen, view);
	        if (oldWhen === this._switchValue) {
	            view.destroy();
	            collection_1.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 */
	    NgSwitch.prototype._emptyAllActiveViews = function () {
	        var activeContainers = this._activeViews;
	        for (var i = 0; i < activeContainers.length; i++) {
	            activeContainers[i].destroy();
	        }
	        this._activeViews = [];
	    };
	    /** @internal */
	    NgSwitch.prototype._activateViews = function (views) {
	        // TODO(vicb): assert(this._activeViews.length === 0);
	        if (lang_1.isPresent(views)) {
	            for (var i = 0; i < views.length; i++) {
	                views[i].create();
	            }
	            this._activeViews = views;
	        }
	    };
	    /** @internal */
	    NgSwitch.prototype._registerView = function (value, view) {
	        var views = this._valueViews.get(value);
	        if (lang_1.isBlank(views)) {
	            views = [];
	            this._valueViews.set(value, views);
	        }
	        views.push(view);
	    };
	    /** @internal */
	    NgSwitch.prototype._deregisterView = function (value, view) {
	        // `_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 {
	            collection_1.ListWrapper.remove(views, view);
	        }
	    };
	    NgSwitch = __decorate([
	        core_1.Directive({ selector: '[ngSwitch]', inputs: ['ngSwitch'] }), 
	        __metadata('design:paramtypes', [])
	    ], NgSwitch);
	    return NgSwitch;
	}());
	exports.NgSwitch = NgSwitch;
	/**
	 * 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.
	 */
	var NgSwitchWhen = (function () {
	    function NgSwitchWhen(viewContainer, templateRef, ngSwitch) {
	        // `_WHEN_DEFAULT` is used as a marker for a not yet initialized value
	        /** @internal */
	        this._value = _WHEN_DEFAULT;
	        this._switch = ngSwitch;
	        this._view = new SwitchView(viewContainer, templateRef);
	    }
	    Object.defineProperty(NgSwitchWhen.prototype, "ngSwitchWhen", {
	        set: function (value) {
	            this._switch._onWhenValueChanged(this._value, value, this._view);
	            this._value = value;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    NgSwitchWhen = __decorate([
	        core_1.Directive({ selector: '[ngSwitchWhen]', inputs: ['ngSwitchWhen'] }),
	        __param(2, core_1.Host()), 
	        __metadata('design:paramtypes', [core_1.ViewContainerRef, core_1.TemplateRef, NgSwitch])
	    ], NgSwitchWhen);
	    return NgSwitchWhen;
	}());
	exports.NgSwitchWhen = NgSwitchWhen;
	/**
	 * Default case statements are displayed when no match expression matches the switch expression
	 * value.
	 *
	 * See {@link NgSwitch} for more details and example.
	 */
	var NgSwitchDefault = (function () {
	    function NgSwitchDefault(viewContainer, templateRef, sswitch) {
	        sswitch._registerView(_WHEN_DEFAULT, new SwitchView(viewContainer, templateRef));
	    }
	    NgSwitchDefault = __decorate([
	        core_1.Directive({ selector: '[ngSwitchDefault]' }),
	        __param(2, core_1.Host()), 
	        __metadata('design:paramtypes', [core_1.ViewContainerRef, core_1.TemplateRef, NgSwitch])
	    ], NgSwitchDefault);
	    return NgSwitchDefault;
	}());
	exports.NgSwitchDefault = NgSwitchDefault;


/***/ },
/* 111 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var core_1 = __webpack_require__(2);
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var ng_switch_1 = __webpack_require__(110);
	var _CATEGORY_DEFAULT = 'other';
	var NgLocalization = (function () {
	    function NgLocalization() {
	    }
	    return NgLocalization;
	}());
	exports.NgLocalization = NgLocalization;
	/**
	 * `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;
	 *   }
	 * }
	 *
	 * ```
	 */
	var NgPluralCase = (function () {
	    function NgPluralCase(value, template, viewContainer) {
	        this.value = value;
	        this._view = new ng_switch_1.SwitchView(viewContainer, template);
	    }
	    NgPluralCase = __decorate([
	        core_1.Directive({ selector: '[ngPluralCase]' }),
	        __param(0, core_1.Attribute('ngPluralCase')), 
	        __metadata('design:paramtypes', [String, core_1.TemplateRef, core_1.ViewContainerRef])
	    ], NgPluralCase);
	    return NgPluralCase;
	}());
	exports.NgPluralCase = NgPluralCase;
	var NgPlural = (function () {
	    function NgPlural(_localization) {
	        this._localization = _localization;
	        this._caseViews = new collection_1.Map();
	        this.cases = null;
	    }
	    Object.defineProperty(NgPlural.prototype, "ngPlural", {
	        set: function (value) {
	            this._switchValue = value;
	            this._updateView();
	        },
	        enumerable: true,
	        configurable: true
	    });
	    NgPlural.prototype.ngAfterContentInit = function () {
	        var _this = this;
	        this.cases.forEach(function (pluralCase) {
	            _this._caseViews.set(_this._formatValue(pluralCase), pluralCase._view);
	        });
	        this._updateView();
	    };
	    /** @internal */
	    NgPlural.prototype._updateView = function () {
	        this._clearViews();
	        var view = this._caseViews.get(this._switchValue);
	        if (!lang_1.isPresent(view))
	            view = this._getCategoryView(this._switchValue);
	        this._activateView(view);
	    };
	    /** @internal */
	    NgPlural.prototype._clearViews = function () {
	        if (lang_1.isPresent(this._activeView))
	            this._activeView.destroy();
	    };
	    /** @internal */
	    NgPlural.prototype._activateView = function (view) {
	        if (!lang_1.isPresent(view))
	            return;
	        this._activeView = view;
	        this._activeView.create();
	    };
	    /** @internal */
	    NgPlural.prototype._getCategoryView = function (value) {
	        var category = this._localization.getPluralCategory(value);
	        var categoryView = this._caseViews.get(category);
	        return lang_1.isPresent(categoryView) ? categoryView : this._caseViews.get(_CATEGORY_DEFAULT);
	    };
	    /** @internal */
	    NgPlural.prototype._isValueView = function (pluralCase) { return pluralCase.value[0] === "="; };
	    /** @internal */
	    NgPlural.prototype._formatValue = function (pluralCase) {
	        return this._isValueView(pluralCase) ? this._stripValue(pluralCase.value) : pluralCase.value;
	    };
	    /** @internal */
	    NgPlural.prototype._stripValue = function (value) { return lang_1.NumberWrapper.parseInt(value.substring(1), 10); };
	    __decorate([
	        core_1.ContentChildren(NgPluralCase), 
	        __metadata('design:type', core_1.QueryList)
	    ], NgPlural.prototype, "cases", void 0);
	    __decorate([
	        core_1.Input(), 
	        __metadata('design:type', Number), 
	        __metadata('design:paramtypes', [Number])
	    ], NgPlural.prototype, "ngPlural", null);
	    NgPlural = __decorate([
	        core_1.Directive({ selector: '[ngPlural]' }), 
	        __metadata('design:paramtypes', [NgLocalization])
	    ], NgPlural);
	    return NgPlural;
	}());
	exports.NgPlural = NgPlural;


/***/ },
/* 112 */
/***/ function(module, exports) {

	// TS does not have Observables
	"use strict";


/***/ },
/* 113 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var ng_class_1 = __webpack_require__(105);
	var ng_for_1 = __webpack_require__(106);
	var ng_if_1 = __webpack_require__(107);
	var ng_template_outlet_1 = __webpack_require__(108);
	var ng_style_1 = __webpack_require__(109);
	var ng_switch_1 = __webpack_require__(110);
	var ng_plural_1 = __webpack_require__(111);
	/**
	 * 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 {
	 *   ...
	 * }
	 * ```
	 */
	exports.CORE_DIRECTIVES = [
	    ng_class_1.NgClass,
	    ng_for_1.NgFor,
	    ng_if_1.NgIf,
	    ng_template_outlet_1.NgTemplateOutlet,
	    ng_style_1.NgStyle,
	    ng_switch_1.NgSwitch,
	    ng_switch_1.NgSwitchWhen,
	    ng_switch_1.NgSwitchDefault,
	    ng_plural_1.NgPlural,
	    ng_plural_1.NgPluralCase
	];


/***/ },
/* 114 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	/**
	 * @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.
	 *
	 */
	var model_1 = __webpack_require__(115);
	exports.AbstractControl = model_1.AbstractControl;
	exports.Control = model_1.Control;
	exports.ControlGroup = model_1.ControlGroup;
	exports.ControlArray = model_1.ControlArray;
	var abstract_control_directive_1 = __webpack_require__(116);
	exports.AbstractControlDirective = abstract_control_directive_1.AbstractControlDirective;
	var control_container_1 = __webpack_require__(117);
	exports.ControlContainer = control_container_1.ControlContainer;
	var ng_control_name_1 = __webpack_require__(118);
	exports.NgControlName = ng_control_name_1.NgControlName;
	var ng_form_control_1 = __webpack_require__(129);
	exports.NgFormControl = ng_form_control_1.NgFormControl;
	var ng_model_1 = __webpack_require__(130);
	exports.NgModel = ng_model_1.NgModel;
	var ng_control_1 = __webpack_require__(119);
	exports.NgControl = ng_control_1.NgControl;
	var ng_control_group_1 = __webpack_require__(131);
	exports.NgControlGroup = ng_control_group_1.NgControlGroup;
	var ng_form_model_1 = __webpack_require__(132);
	exports.NgFormModel = ng_form_model_1.NgFormModel;
	var ng_form_1 = __webpack_require__(133);
	exports.NgForm = ng_form_1.NgForm;
	var control_value_accessor_1 = __webpack_require__(120);
	exports.NG_VALUE_ACCESSOR = control_value_accessor_1.NG_VALUE_ACCESSOR;
	var default_value_accessor_1 = __webpack_require__(123);
	exports.DefaultValueAccessor = default_value_accessor_1.DefaultValueAccessor;
	var ng_control_status_1 = __webpack_require__(134);
	exports.NgControlStatus = ng_control_status_1.NgControlStatus;
	var checkbox_value_accessor_1 = __webpack_require__(125);
	exports.CheckboxControlValueAccessor = checkbox_value_accessor_1.CheckboxControlValueAccessor;
	var select_control_value_accessor_1 = __webpack_require__(126);
	exports.NgSelectOption = select_control_value_accessor_1.NgSelectOption;
	exports.SelectControlValueAccessor = select_control_value_accessor_1.SelectControlValueAccessor;
	var directives_1 = __webpack_require__(135);
	exports.FORM_DIRECTIVES = directives_1.FORM_DIRECTIVES;
	exports.RadioButtonState = directives_1.RadioButtonState;
	var validators_1 = __webpack_require__(122);
	exports.NG_VALIDATORS = validators_1.NG_VALIDATORS;
	exports.NG_ASYNC_VALIDATORS = validators_1.NG_ASYNC_VALIDATORS;
	exports.Validators = validators_1.Validators;
	var validators_2 = __webpack_require__(136);
	exports.RequiredValidator = validators_2.RequiredValidator;
	exports.MinLengthValidator = validators_2.MinLengthValidator;
	exports.MaxLengthValidator = validators_2.MaxLengthValidator;
	exports.PatternValidator = validators_2.PatternValidator;
	var form_builder_1 = __webpack_require__(137);
	exports.FormBuilder = form_builder_1.FormBuilder;
	var form_builder_2 = __webpack_require__(137);
	var radio_control_value_accessor_1 = __webpack_require__(127);
	/**
	 * Shorthand set of providers used for building Angular forms.
	 *
	 * ### Example
	 *
	 * ```typescript
	 * bootstrap(MyApp, [FORM_PROVIDERS]);
	 * ```
	 */
	exports.FORM_PROVIDERS = [form_builder_2.FormBuilder, radio_control_value_accessor_1.RadioControlRegistry];
	/**
	 * See {@link FORM_PROVIDERS} instead.
	 *
	 * @deprecated
	 */
	exports.FORM_BINDINGS = exports.FORM_PROVIDERS;


/***/ },
/* 115 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var async_1 = __webpack_require__(41);
	var promise_1 = __webpack_require__(42);
	var collection_1 = __webpack_require__(15);
	/**
	 * Indicates that a Control is valid, i.e. that no errors exist in the input value.
	 */
	exports.VALID = "VALID";
	/**
	 * Indicates that a Control is invalid, i.e. that an error exists in the input value.
	 */
	exports.INVALID = "INVALID";
	/**
	 * Indicates that a Control is pending, i.e. that async validation is occurring and
	 * errors are not yet available for the input value.
	 */
	exports.PENDING = "PENDING";
	function isControl(control) {
	    return control instanceof AbstractControl;
	}
	exports.isControl = isControl;
	function _find(control, path) {
	    if (lang_1.isBlank(path))
	        return null;
	    if (!(path instanceof Array)) {
	        path = path.split("/");
	    }
	    if (path instanceof Array && collection_1.ListWrapper.isEmpty(path))
	        return null;
	    return path
	        .reduce(function (v, name) {
	        if (v instanceof ControlGroup) {
	            return lang_1.isPresent(v.controls[name]) ? v.controls[name] : null;
	        }
	        else if (v instanceof ControlArray) {
	            var index = name;
	            return lang_1.isPresent(v.at(index)) ? v.at(index) : null;
	        }
	        else {
	            return null;
	        }
	    }, control);
	}
	function toObservable(r) {
	    return promise_1.PromiseWrapper.isPromise(r) ? async_1.ObservableWrapper.fromPromise(r) : r;
	}
	/**
	 *
	 */
	var AbstractControl = (function () {
	    function AbstractControl(validator, asyncValidator) {
	        this.validator = validator;
	        this.asyncValidator = asyncValidator;
	        this._pristine = true;
	        this._touched = false;
	    }
	    Object.defineProperty(AbstractControl.prototype, "value", {
	        get: function () { return this._value; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControl.prototype, "status", {
	        get: function () { return this._status; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControl.prototype, "valid", {
	        get: function () { return this._status === exports.VALID; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControl.prototype, "errors", {
	        /**
	         * Returns the errors of this control.
	         */
	        get: function () { return this._errors; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControl.prototype, "pristine", {
	        get: function () { return this._pristine; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControl.prototype, "dirty", {
	        get: function () { return !this.pristine; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControl.prototype, "touched", {
	        get: function () { return this._touched; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControl.prototype, "untouched", {
	        get: function () { return !this._touched; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControl.prototype, "valueChanges", {
	        get: function () { return this._valueChanges; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControl.prototype, "statusChanges", {
	        get: function () { return this._statusChanges; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControl.prototype, "pending", {
	        get: function () { return this._status == exports.PENDING; },
	        enumerable: true,
	        configurable: true
	    });
	    AbstractControl.prototype.markAsTouched = function () { this._touched = true; };
	    AbstractControl.prototype.markAsDirty = function (_a) {
	        var onlySelf = (_a === void 0 ? {} : _a).onlySelf;
	        onlySelf = lang_1.normalizeBool(onlySelf);
	        this._pristine = false;
	        if (lang_1.isPresent(this._parent) && !onlySelf) {
	            this._parent.markAsDirty({ onlySelf: onlySelf });
	        }
	    };
	    AbstractControl.prototype.markAsPending = function (_a) {
	        var onlySelf = (_a === void 0 ? {} : _a).onlySelf;
	        onlySelf = lang_1.normalizeBool(onlySelf);
	        this._status = exports.PENDING;
	        if (lang_1.isPresent(this._parent) && !onlySelf) {
	            this._parent.markAsPending({ onlySelf: onlySelf });
	        }
	    };
	    AbstractControl.prototype.setParent = function (parent) { this._parent = parent; };
	    AbstractControl.prototype.updateValueAndValidity = function (_a) {
	        var _b = _a === void 0 ? {} : _a, onlySelf = _b.onlySelf, emitEvent = _b.emitEvent;
	        onlySelf = lang_1.normalizeBool(onlySelf);
	        emitEvent = lang_1.isPresent(emitEvent) ? emitEvent : true;
	        this._updateValue();
	        this._errors = this._runValidator();
	        this._status = this._calculateStatus();
	        if (this._status == exports.VALID || this._status == exports.PENDING) {
	            this._runAsyncValidator(emitEvent);
	        }
	        if (emitEvent) {
	            async_1.ObservableWrapper.callEmit(this._valueChanges, this._value);
	            async_1.ObservableWrapper.callEmit(this._statusChanges, this._status);
	        }
	        if (lang_1.isPresent(this._parent) && !onlySelf) {
	            this._parent.updateValueAndValidity({ onlySelf: onlySelf, emitEvent: emitEvent });
	        }
	    };
	    AbstractControl.prototype._runValidator = function () {
	        return lang_1.isPresent(this.validator) ? this.validator(this) : null;
	    };
	    AbstractControl.prototype._runAsyncValidator = function (emitEvent) {
	        var _this = this;
	        if (lang_1.isPresent(this.asyncValidator)) {
	            this._status = exports.PENDING;
	            this._cancelExistingSubscription();
	            var obs = toObservable(this.asyncValidator(this));
	            this._asyncValidationSubscription = async_1.ObservableWrapper.subscribe(obs, function (res) { return _this.setErrors(res, { emitEvent: emitEvent }); });
	        }
	    };
	    AbstractControl.prototype._cancelExistingSubscription = function () {
	        if (lang_1.isPresent(this._asyncValidationSubscription)) {
	            async_1.ObservableWrapper.dispose(this._asyncValidationSubscription);
	        }
	    };
	    /**
	     * Sets errors on a control.
	     *
	     * This is used when validations are run not automatically, but manually by the user.
	     *
	     * Calling `setErrors` will also update the validity of the parent control.
	     *
	     * ## Usage
	     *
	     * ```
	     * var login = new Control("someLogin");
	     * login.setErrors({
	     *   "notUnique": true
	     * });
	     *
	     * expect(login.valid).toEqual(false);
	     * expect(login.errors).toEqual({"notUnique": true});
	     *
	     * login.updateValue("someOtherLogin");
	     *
	     * expect(login.valid).toEqual(true);
	     * ```
	     */
	    AbstractControl.prototype.setErrors = function (errors, _a) {
	        var emitEvent = (_a === void 0 ? {} : _a).emitEvent;
	        emitEvent = lang_1.isPresent(emitEvent) ? emitEvent : true;
	        this._errors = errors;
	        this._status = this._calculateStatus();
	        if (emitEvent) {
	            async_1.ObservableWrapper.callEmit(this._statusChanges, this._status);
	        }
	        if (lang_1.isPresent(this._parent)) {
	            this._parent._updateControlsErrors();
	        }
	    };
	    AbstractControl.prototype.find = function (path) { return _find(this, path); };
	    AbstractControl.prototype.getError = function (errorCode, path) {
	        if (path === void 0) { path = null; }
	        var control = lang_1.isPresent(path) && !collection_1.ListWrapper.isEmpty(path) ? this.find(path) : this;
	        if (lang_1.isPresent(control) && lang_1.isPresent(control._errors)) {
	            return collection_1.StringMapWrapper.get(control._errors, errorCode);
	        }
	        else {
	            return null;
	        }
	    };
	    AbstractControl.prototype.hasError = function (errorCode, path) {
	        if (path === void 0) { path = null; }
	        return lang_1.isPresent(this.getError(errorCode, path));
	    };
	    Object.defineProperty(AbstractControl.prototype, "root", {
	        get: function () {
	            var x = this;
	            while (lang_1.isPresent(x._parent)) {
	                x = x._parent;
	            }
	            return x;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    /** @internal */
	    AbstractControl.prototype._updateControlsErrors = function () {
	        this._status = this._calculateStatus();
	        if (lang_1.isPresent(this._parent)) {
	            this._parent._updateControlsErrors();
	        }
	    };
	    /** @internal */
	    AbstractControl.prototype._initObservables = function () {
	        this._valueChanges = new async_1.EventEmitter();
	        this._statusChanges = new async_1.EventEmitter();
	    };
	    AbstractControl.prototype._calculateStatus = function () {
	        if (lang_1.isPresent(this._errors))
	            return exports.INVALID;
	        if (this._anyControlsHaveStatus(exports.PENDING))
	            return exports.PENDING;
	        if (this._anyControlsHaveStatus(exports.INVALID))
	            return exports.INVALID;
	        return exports.VALID;
	    };
	    return AbstractControl;
	}());
	exports.AbstractControl = AbstractControl;
	/**
	 * Defines a part of a form that cannot be divided into other controls. `Control`s have values and
	 * validation state, which is determined by an optional validation function.
	 *
	 * `Control` is one of the three fundamental building blocks used to define forms in Angular, along
	 * with {@link ControlGroup} and {@link ControlArray}.
	 *
	 * ## Usage
	 *
	 * By default, a `Control` is created for every `<input>` or other form component.
	 * With {@link NgFormControl} or {@link NgFormModel} an existing {@link Control} can be
	 * bound to a DOM element instead. This `Control` can be configured with a custom
	 * validation function.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/23DESOpbNnBpBHZt1BR4?p=preview))
	 */
	var Control = (function (_super) {
	    __extends(Control, _super);
	    function Control(value, validator, asyncValidator) {
	        if (value === void 0) { value = null; }
	        if (validator === void 0) { validator = null; }
	        if (asyncValidator === void 0) { asyncValidator = null; }
	        _super.call(this, validator, asyncValidator);
	        this._value = value;
	        this.updateValueAndValidity({ onlySelf: true, emitEvent: false });
	        this._initObservables();
	    }
	    /**
	     * Set the value of the control to `value`.
	     *
	     * If `onlySelf` is `true`, this change will only affect the validation of this `Control`
	     * and not its parent component. If `emitEvent` is `true`, this change will cause a
	     * `valueChanges` event on the `Control` to be emitted. Both of these options default to
	     * `false`.
	     *
	     * If `emitModelToViewChange` is `true`, the view will be notified about the new value
	     * via an `onChange` event. This is the default behavior if `emitModelToViewChange` is not
	     * specified.
	     */
	    Control.prototype.updateValue = function (value, _a) {
	        var _b = _a === void 0 ? {} : _a, onlySelf = _b.onlySelf, emitEvent = _b.emitEvent, emitModelToViewChange = _b.emitModelToViewChange;
	        emitModelToViewChange = lang_1.isPresent(emitModelToViewChange) ? emitModelToViewChange : true;
	        this._value = value;
	        if (lang_1.isPresent(this._onChange) && emitModelToViewChange)
	            this._onChange(this._value);
	        this.updateValueAndValidity({ onlySelf: onlySelf, emitEvent: emitEvent });
	    };
	    /**
	     * @internal
	     */
	    Control.prototype._updateValue = function () { };
	    /**
	     * @internal
	     */
	    Control.prototype._anyControlsHaveStatus = function (status) { return false; };
	    /**
	     * Register a listener for change events.
	     */
	    Control.prototype.registerOnChange = function (fn) { this._onChange = fn; };
	    return Control;
	}(AbstractControl));
	exports.Control = Control;
	/**
	 * Defines a part of a form, of fixed length, that can contain other controls.
	 *
	 * A `ControlGroup` aggregates the values of each {@link Control} in the group.
	 * The status of a `ControlGroup` depends on the status of its children.
	 * If one of the controls in a group is invalid, the entire group is invalid.
	 * Similarly, if a control changes its value, the entire group changes as well.
	 *
	 * `ControlGroup` is one of the three fundamental building blocks used to define forms in Angular,
	 * along with {@link Control} and {@link ControlArray}. {@link ControlArray} can also contain other
	 * controls, but is of variable length.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/23DESOpbNnBpBHZt1BR4?p=preview))
	 */
	var ControlGroup = (function (_super) {
	    __extends(ControlGroup, _super);
	    function ControlGroup(controls, optionals, validator, asyncValidator) {
	        if (optionals === void 0) { optionals = null; }
	        if (validator === void 0) { validator = null; }
	        if (asyncValidator === void 0) { asyncValidator = null; }
	        _super.call(this, validator, asyncValidator);
	        this.controls = controls;
	        this._optionals = lang_1.isPresent(optionals) ? optionals : {};
	        this._initObservables();
	        this._setParentForControls();
	        this.updateValueAndValidity({ onlySelf: true, emitEvent: false });
	    }
	    /**
	     * Add a control to this group.
	     */
	    ControlGroup.prototype.addControl = function (name, control) {
	        this.controls[name] = control;
	        control.setParent(this);
	    };
	    /**
	     * Remove a control from this group.
	     */
	    ControlGroup.prototype.removeControl = function (name) { collection_1.StringMapWrapper.delete(this.controls, name); };
	    /**
	     * Mark the named control as non-optional.
	     */
	    ControlGroup.prototype.include = function (controlName) {
	        collection_1.StringMapWrapper.set(this._optionals, controlName, true);
	        this.updateValueAndValidity();
	    };
	    /**
	     * Mark the named control as optional.
	     */
	    ControlGroup.prototype.exclude = function (controlName) {
	        collection_1.StringMapWrapper.set(this._optionals, controlName, false);
	        this.updateValueAndValidity();
	    };
	    /**
	     * Check whether there is a control with the given name in the group.
	     */
	    ControlGroup.prototype.contains = function (controlName) {
	        var c = collection_1.StringMapWrapper.contains(this.controls, controlName);
	        return c && this._included(controlName);
	    };
	    /** @internal */
	    ControlGroup.prototype._setParentForControls = function () {
	        var _this = this;
	        collection_1.StringMapWrapper.forEach(this.controls, function (control, name) { control.setParent(_this); });
	    };
	    /** @internal */
	    ControlGroup.prototype._updateValue = function () { this._value = this._reduceValue(); };
	    /** @internal */
	    ControlGroup.prototype._anyControlsHaveStatus = function (status) {
	        var _this = this;
	        var res = false;
	        collection_1.StringMapWrapper.forEach(this.controls, function (control, name) {
	            res = res || (_this.contains(name) && control.status == status);
	        });
	        return res;
	    };
	    /** @internal */
	    ControlGroup.prototype._reduceValue = function () {
	        return this._reduceChildren({}, function (acc, control, name) {
	            acc[name] = control.value;
	            return acc;
	        });
	    };
	    /** @internal */
	    ControlGroup.prototype._reduceChildren = function (initValue, fn) {
	        var _this = this;
	        var res = initValue;
	        collection_1.StringMapWrapper.forEach(this.controls, function (control, name) {
	            if (_this._included(name)) {
	                res = fn(res, control, name);
	            }
	        });
	        return res;
	    };
	    /** @internal */
	    ControlGroup.prototype._included = function (controlName) {
	        var isOptional = collection_1.StringMapWrapper.contains(this._optionals, controlName);
	        return !isOptional || collection_1.StringMapWrapper.get(this._optionals, controlName);
	    };
	    return ControlGroup;
	}(AbstractControl));
	exports.ControlGroup = ControlGroup;
	/**
	 * Defines a part of a form, of variable length, that can contain other controls.
	 *
	 * A `ControlArray` aggregates the values of each {@link Control} in the group.
	 * The status of a `ControlArray` depends on the status of its children.
	 * If one of the controls in a group is invalid, the entire array is invalid.
	 * Similarly, if a control changes its value, the entire array changes as well.
	 *
	 * `ControlArray` is one of the three fundamental building blocks used to define forms in Angular,
	 * along with {@link Control} and {@link ControlGroup}. {@link ControlGroup} can also contain
	 * other controls, but is of fixed length.
	 *
	 * ## Adding or removing controls
	 *
	 * To change the controls in the array, use the `push`, `insert`, or `removeAt` methods
	 * in `ControlArray` itself. These methods ensure the controls are properly tracked in the
	 * form's hierarchy. Do not modify the array of `AbstractControl`s used to instantiate
	 * the `ControlArray` directly, as that will result in strange and unexpected behavior such
	 * as broken change detection.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/23DESOpbNnBpBHZt1BR4?p=preview))
	 */
	var ControlArray = (function (_super) {
	    __extends(ControlArray, _super);
	    function ControlArray(controls, validator, asyncValidator) {
	        if (validator === void 0) { validator = null; }
	        if (asyncValidator === void 0) { asyncValidator = null; }
	        _super.call(this, validator, asyncValidator);
	        this.controls = controls;
	        this._initObservables();
	        this._setParentForControls();
	        this.updateValueAndValidity({ onlySelf: true, emitEvent: false });
	    }
	    /**
	     * Get the {@link AbstractControl} at the given `index` in the array.
	     */
	    ControlArray.prototype.at = function (index) { return this.controls[index]; };
	    /**
	     * Insert a new {@link AbstractControl} at the end of the array.
	     */
	    ControlArray.prototype.push = function (control) {
	        this.controls.push(control);
	        control.setParent(this);
	        this.updateValueAndValidity();
	    };
	    /**
	     * Insert a new {@link AbstractControl} at the given `index` in the array.
	     */
	    ControlArray.prototype.insert = function (index, control) {
	        collection_1.ListWrapper.insert(this.controls, index, control);
	        control.setParent(this);
	        this.updateValueAndValidity();
	    };
	    /**
	     * Remove the control at the given `index` in the array.
	     */
	    ControlArray.prototype.removeAt = function (index) {
	        collection_1.ListWrapper.removeAt(this.controls, index);
	        this.updateValueAndValidity();
	    };
	    Object.defineProperty(ControlArray.prototype, "length", {
	        /**
	         * Length of the control array.
	         */
	        get: function () { return this.controls.length; },
	        enumerable: true,
	        configurable: true
	    });
	    /** @internal */
	    ControlArray.prototype._updateValue = function () { this._value = this.controls.map(function (control) { return control.value; }); };
	    /** @internal */
	    ControlArray.prototype._anyControlsHaveStatus = function (status) {
	        return this.controls.some(function (c) { return c.status == status; });
	    };
	    /** @internal */
	    ControlArray.prototype._setParentForControls = function () {
	        var _this = this;
	        this.controls.forEach(function (control) { control.setParent(_this); });
	    };
	    return ControlArray;
	}(AbstractControl));
	exports.ControlArray = ControlArray;


/***/ },
/* 116 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	/**
	 * Base class for control directives.
	 *
	 * Only used internally in the forms module.
	 */
	var AbstractControlDirective = (function () {
	    function AbstractControlDirective() {
	    }
	    Object.defineProperty(AbstractControlDirective.prototype, "control", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControlDirective.prototype, "value", {
	        get: function () { return lang_1.isPresent(this.control) ? this.control.value : null; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControlDirective.prototype, "valid", {
	        get: function () { return lang_1.isPresent(this.control) ? this.control.valid : null; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControlDirective.prototype, "errors", {
	        get: function () {
	            return lang_1.isPresent(this.control) ? this.control.errors : null;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControlDirective.prototype, "pristine", {
	        get: function () { return lang_1.isPresent(this.control) ? this.control.pristine : null; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControlDirective.prototype, "dirty", {
	        get: function () { return lang_1.isPresent(this.control) ? this.control.dirty : null; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControlDirective.prototype, "touched", {
	        get: function () { return lang_1.isPresent(this.control) ? this.control.touched : null; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControlDirective.prototype, "untouched", {
	        get: function () { return lang_1.isPresent(this.control) ? this.control.untouched : null; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AbstractControlDirective.prototype, "path", {
	        get: function () { return null; },
	        enumerable: true,
	        configurable: true
	    });
	    return AbstractControlDirective;
	}());
	exports.AbstractControlDirective = AbstractControlDirective;


/***/ },
/* 117 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var abstract_control_directive_1 = __webpack_require__(116);
	/**
	 * A directive that contains multiple {@link NgControl}s.
	 *
	 * Only used by the forms module.
	 */
	var ControlContainer = (function (_super) {
	    __extends(ControlContainer, _super);
	    function ControlContainer() {
	        _super.apply(this, arguments);
	    }
	    Object.defineProperty(ControlContainer.prototype, "formDirective", {
	        /**
	         * Get the form to which this container belongs.
	         */
	        get: function () { return null; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ControlContainer.prototype, "path", {
	        /**
	         * Get the path to this container.
	         */
	        get: function () { return null; },
	        enumerable: true,
	        configurable: true
	    });
	    return ControlContainer;
	}(abstract_control_directive_1.AbstractControlDirective));
	exports.ControlContainer = ControlContainer;


/***/ },
/* 118 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var async_1 = __webpack_require__(41);
	var core_1 = __webpack_require__(2);
	var control_container_1 = __webpack_require__(117);
	var ng_control_1 = __webpack_require__(119);
	var control_value_accessor_1 = __webpack_require__(120);
	var shared_1 = __webpack_require__(121);
	var validators_1 = __webpack_require__(122);
	exports.controlNameBinding = 
	/*@ts2dart_const*/ /* @ts2dart_Provider */ {
	    provide: ng_control_1.NgControl,
	    useExisting: core_1.forwardRef(function () { return NgControlName; })
	};
	/**
	 * Creates and binds a control with a specified name to a DOM element.
	 *
	 * This directive can only be used as a child of {@link NgForm} or {@link NgFormModel}.

	 * ### Example
	 *
	 * In this example, we create the login and password controls.
	 * We can work with each control separately: check its validity, get its value, listen to its
	 * changes.
	 *
	 *  ```
	 * @Component({
	 *      selector: "login-comp",
	 *      directives: [FORM_DIRECTIVES],
	 *      template: `
	 *        <form #f="ngForm" (submit)='onLogIn(f.value)'>
	 *          Login <input type='text' ngControl='login' #l="form">
	 *          <div *ngIf="!l.valid">Login is invalid</div>
	 *
	 *          Password <input type='password' ngControl='password'>
	 *          <button type='submit'>Log in!</button>
	 *        </form>
	 *      `})
	 * class LoginComp {
	 *  onLogIn(value): void {
	 *    // value === {login: 'some login', password: 'some password'}
	 *  }
	 * }
	 *  ```
	 *
	 * We can also use ngModel to bind a domain model to the form.
	 *
	 *  ```
	 * @Component({
	 *      selector: "login-comp",
	 *      directives: [FORM_DIRECTIVES],
	 *      template: `
	 *        <form (submit)='onLogIn()'>
	 *          Login <input type='text' ngControl='login' [(ngModel)]="credentials.login">
	 *          Password <input type='password' ngControl='password'
	 *                          [(ngModel)]="credentials.password">
	 *          <button type='submit'>Log in!</button>
	 *        </form>
	 *      `})
	 * class LoginComp {
	 *  credentials: {login:string, password:string};
	 *
	 *  onLogIn(): void {
	 *    // this.credentials.login === "some login"
	 *    // this.credentials.password === "some password"
	 *  }
	 * }
	 *  ```
	 */
	var NgControlName = (function (_super) {
	    __extends(NgControlName, _super);
	    function NgControlName(_parent, _validators, _asyncValidators, valueAccessors) {
	        _super.call(this);
	        this._parent = _parent;
	        this._validators = _validators;
	        this._asyncValidators = _asyncValidators;
	        /** @internal */
	        this.update = new async_1.EventEmitter();
	        this._added = false;
	        this.valueAccessor = shared_1.selectValueAccessor(this, valueAccessors);
	    }
	    NgControlName.prototype.ngOnChanges = function (changes) {
	        if (!this._added) {
	            this.formDirective.addControl(this);
	            this._added = true;
	        }
	        if (shared_1.isPropertyUpdated(changes, this.viewModel)) {
	            this.viewModel = this.model;
	            this.formDirective.updateModel(this, this.model);
	        }
	    };
	    NgControlName.prototype.ngOnDestroy = function () { this.formDirective.removeControl(this); };
	    NgControlName.prototype.viewToModelUpdate = function (newValue) {
	        this.viewModel = newValue;
	        async_1.ObservableWrapper.callEmit(this.update, newValue);
	    };
	    Object.defineProperty(NgControlName.prototype, "path", {
	        get: function () { return shared_1.controlPath(this.name, this._parent); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgControlName.prototype, "formDirective", {
	        get: function () { return this._parent.formDirective; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgControlName.prototype, "validator", {
	        get: function () { return shared_1.composeValidators(this._validators); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgControlName.prototype, "asyncValidator", {
	        get: function () { return shared_1.composeAsyncValidators(this._asyncValidators); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgControlName.prototype, "control", {
	        get: function () { return this.formDirective.getControl(this); },
	        enumerable: true,
	        configurable: true
	    });
	    NgControlName = __decorate([
	        core_1.Directive({
	            selector: '[ngControl]',
	            bindings: [exports.controlNameBinding],
	            inputs: ['name: ngControl', 'model: ngModel'],
	            outputs: ['update: ngModelChange'],
	            exportAs: 'ngForm'
	        }),
	        __param(0, core_1.Host()),
	        __param(0, core_1.SkipSelf()),
	        __param(1, core_1.Optional()),
	        __param(1, core_1.Self()),
	        __param(1, core_1.Inject(validators_1.NG_VALIDATORS)),
	        __param(2, core_1.Optional()),
	        __param(2, core_1.Self()),
	        __param(2, core_1.Inject(validators_1.NG_ASYNC_VALIDATORS)),
	        __param(3, core_1.Optional()),
	        __param(3, core_1.Self()),
	        __param(3, core_1.Inject(control_value_accessor_1.NG_VALUE_ACCESSOR)), 
	        __metadata('design:paramtypes', [control_container_1.ControlContainer, Array, Array, Array])
	    ], NgControlName);
	    return NgControlName;
	}(ng_control_1.NgControl));
	exports.NgControlName = NgControlName;


/***/ },
/* 119 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var abstract_control_directive_1 = __webpack_require__(116);
	var exceptions_1 = __webpack_require__(12);
	/**
	 * A base class that all control directive extend.
	 * It binds a {@link Control} object to a DOM element.
	 *
	 * Used internally by Angular forms.
	 */
	var NgControl = (function (_super) {
	    __extends(NgControl, _super);
	    function NgControl() {
	        _super.apply(this, arguments);
	        this.name = null;
	        this.valueAccessor = null;
	    }
	    Object.defineProperty(NgControl.prototype, "validator", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgControl.prototype, "asyncValidator", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    return NgControl;
	}(abstract_control_directive_1.AbstractControlDirective));
	exports.NgControl = NgControl;


/***/ },
/* 120 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var core_1 = __webpack_require__(2);
	/**
	 * Used to provide a {@link ControlValueAccessor} for form controls.
	 *
	 * See {@link DefaultValueAccessor} for how to implement one.
	 */
	exports.NG_VALUE_ACCESSOR = 
	/*@ts2dart_const*/ new core_1.OpaqueToken("NgValueAccessor");


/***/ },
/* 121 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var validators_1 = __webpack_require__(122);
	var default_value_accessor_1 = __webpack_require__(123);
	var number_value_accessor_1 = __webpack_require__(124);
	var checkbox_value_accessor_1 = __webpack_require__(125);
	var select_control_value_accessor_1 = __webpack_require__(126);
	var radio_control_value_accessor_1 = __webpack_require__(127);
	var normalize_validator_1 = __webpack_require__(128);
	function controlPath(name, parent) {
	    var p = collection_1.ListWrapper.clone(parent.path);
	    p.push(name);
	    return p;
	}
	exports.controlPath = controlPath;
	function setUpControl(control, dir) {
	    if (lang_1.isBlank(control))
	        _throwError(dir, "Cannot find control");
	    if (lang_1.isBlank(dir.valueAccessor))
	        _throwError(dir, "No value accessor for");
	    control.validator = validators_1.Validators.compose([control.validator, dir.validator]);
	    control.asyncValidator = validators_1.Validators.composeAsync([control.asyncValidator, dir.asyncValidator]);
	    dir.valueAccessor.writeValue(control.value);
	    // view -> model
	    dir.valueAccessor.registerOnChange(function (newValue) {
	        dir.viewToModelUpdate(newValue);
	        control.updateValue(newValue, { emitModelToViewChange: false });
	        control.markAsDirty();
	    });
	    // model -> view
	    control.registerOnChange(function (newValue) { return dir.valueAccessor.writeValue(newValue); });
	    // touched
	    dir.valueAccessor.registerOnTouched(function () { return control.markAsTouched(); });
	}
	exports.setUpControl = setUpControl;
	function setUpControlGroup(control, dir) {
	    if (lang_1.isBlank(control))
	        _throwError(dir, "Cannot find control");
	    control.validator = validators_1.Validators.compose([control.validator, dir.validator]);
	    control.asyncValidator = validators_1.Validators.composeAsync([control.asyncValidator, dir.asyncValidator]);
	}
	exports.setUpControlGroup = setUpControlGroup;
	function _throwError(dir, message) {
	    var path = dir.path.join(" -> ");
	    throw new exceptions_1.BaseException(message + " '" + path + "'");
	}
	function composeValidators(validators) {
	    return lang_1.isPresent(validators) ? validators_1.Validators.compose(validators.map(normalize_validator_1.normalizeValidator)) : null;
	}
	exports.composeValidators = composeValidators;
	function composeAsyncValidators(validators) {
	    return lang_1.isPresent(validators) ? validators_1.Validators.composeAsync(validators.map(normalize_validator_1.normalizeAsyncValidator)) :
	        null;
	}
	exports.composeAsyncValidators = composeAsyncValidators;
	function isPropertyUpdated(changes, viewModel) {
	    if (!collection_1.StringMapWrapper.contains(changes, "model"))
	        return false;
	    var change = changes["model"];
	    if (change.isFirstChange())
	        return true;
	    return !lang_1.looseIdentical(viewModel, change.currentValue);
	}
	exports.isPropertyUpdated = isPropertyUpdated;
	// TODO: vsavkin remove it once https://github.com/angular/angular/issues/3011 is implemented
	function selectValueAccessor(dir, valueAccessors) {
	    if (lang_1.isBlank(valueAccessors))
	        return null;
	    var defaultAccessor;
	    var builtinAccessor;
	    var customAccessor;
	    valueAccessors.forEach(function (v) {
	        if (lang_1.hasConstructor(v, default_value_accessor_1.DefaultValueAccessor)) {
	            defaultAccessor = v;
	        }
	        else if (lang_1.hasConstructor(v, checkbox_value_accessor_1.CheckboxControlValueAccessor) ||
	            lang_1.hasConstructor(v, number_value_accessor_1.NumberValueAccessor) ||
	            lang_1.hasConstructor(v, select_control_value_accessor_1.SelectControlValueAccessor) ||
	            lang_1.hasConstructor(v, radio_control_value_accessor_1.RadioControlValueAccessor)) {
	            if (lang_1.isPresent(builtinAccessor))
	                _throwError(dir, "More than one built-in value accessor matches");
	            builtinAccessor = v;
	        }
	        else {
	            if (lang_1.isPresent(customAccessor))
	                _throwError(dir, "More than one custom value accessor matches");
	            customAccessor = v;
	        }
	    });
	    if (lang_1.isPresent(customAccessor))
	        return customAccessor;
	    if (lang_1.isPresent(builtinAccessor))
	        return builtinAccessor;
	    if (lang_1.isPresent(defaultAccessor))
	        return defaultAccessor;
	    _throwError(dir, "No valid value accessor for");
	    return null;
	}
	exports.selectValueAccessor = selectValueAccessor;


/***/ },
/* 122 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var promise_1 = __webpack_require__(42);
	var async_1 = __webpack_require__(41);
	var collection_1 = __webpack_require__(15);
	var core_1 = __webpack_require__(2);
	/**
	 * Providers for validators to be used for {@link Control}s in a form.
	 *
	 * Provide this using `multi: true` to add validators.
	 *
	 * ### Example
	 *
	 * {@example core/forms/ts/ng_validators/ng_validators.ts region='ng_validators'}
	 */
	exports.NG_VALIDATORS = new core_1.OpaqueToken("NgValidators");
	/**
	 * Providers for asynchronous validators to be used for {@link Control}s
	 * in a form.
	 *
	 * Provide this using `multi: true` to add validators.
	 *
	 * See {@link NG_VALIDATORS} for more details.
	 */
	exports.NG_ASYNC_VALIDATORS = 
	/*@ts2dart_const*/ new core_1.OpaqueToken("NgAsyncValidators");
	/**
	 * Provides a set of validators used by form controls.
	 *
	 * A validator is a function that processes a {@link Control} or collection of
	 * controls and returns a map of errors. A null map means that validation has passed.
	 *
	 * ### Example
	 *
	 * ```typescript
	 * var loginControl = new Control("", Validators.required)
	 * ```
	 */
	var Validators = (function () {
	    function Validators() {
	    }
	    /**
	     * Validator that requires controls to have a non-empty value.
	     */
	    Validators.required = function (control) {
	        return lang_1.isBlank(control.value) || (lang_1.isString(control.value) && control.value == "") ?
	            { "required": true } :
	            null;
	    };
	    /**
	     * Validator that requires controls to have a value of a minimum length.
	     */
	    Validators.minLength = function (minLength) {
	        return function (control) {
	            if (lang_1.isPresent(Validators.required(control)))
	                return null;
	            var v = control.value;
	            return v.length < minLength ?
	                { "minlength": { "requiredLength": minLength, "actualLength": v.length } } :
	                null;
	        };
	    };
	    /**
	     * Validator that requires controls to have a value of a maximum length.
	     */
	    Validators.maxLength = function (maxLength) {
	        return function (control) {
	            if (lang_1.isPresent(Validators.required(control)))
	                return null;
	            var v = control.value;
	            return v.length > maxLength ?
	                { "maxlength": { "requiredLength": maxLength, "actualLength": v.length } } :
	                null;
	        };
	    };
	    /**
	     * Validator that requires a control to match a regex to its value.
	     */
	    Validators.pattern = function (pattern) {
	        return function (control) {
	            if (lang_1.isPresent(Validators.required(control)))
	                return null;
	            var regex = new RegExp("^" + pattern + "$");
	            var v = control.value;
	            return regex.test(v) ? null :
	                { "pattern": { "requiredPattern": "^" + pattern + "$", "actualValue": v } };
	        };
	    };
	    /**
	     * No-op validator.
	     */
	    Validators.nullValidator = function (c) { return null; };
	    /**
	     * Compose multiple validators into a single function that returns the union
	     * of the individual error maps.
	     */
	    Validators.compose = function (validators) {
	        if (lang_1.isBlank(validators))
	            return null;
	        var presentValidators = validators.filter(lang_1.isPresent);
	        if (presentValidators.length == 0)
	            return null;
	        return function (control) {
	            return _mergeErrors(_executeValidators(control, presentValidators));
	        };
	    };
	    Validators.composeAsync = function (validators) {
	        if (lang_1.isBlank(validators))
	            return null;
	        var presentValidators = validators.filter(lang_1.isPresent);
	        if (presentValidators.length == 0)
	            return null;
	        return function (control) {
	            var promises = _executeAsyncValidators(control, presentValidators).map(_convertToPromise);
	            return promise_1.PromiseWrapper.all(promises).then(_mergeErrors);
	        };
	    };
	    return Validators;
	}());
	exports.Validators = Validators;
	function _convertToPromise(obj) {
	    return promise_1.PromiseWrapper.isPromise(obj) ? obj : async_1.ObservableWrapper.toPromise(obj);
	}
	function _executeValidators(control, validators) {
	    return validators.map(function (v) { return v(control); });
	}
	function _executeAsyncValidators(control, validators) {
	    return validators.map(function (v) { return v(control); });
	}
	function _mergeErrors(arrayOfErrors) {
	    var res = arrayOfErrors.reduce(function (res, errors) {
	        return lang_1.isPresent(errors) ? collection_1.StringMapWrapper.merge(res, errors) : res;
	    }, {});
	    return collection_1.StringMapWrapper.isEmpty(res) ? null : res;
	}


/***/ },
/* 123 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var core_1 = __webpack_require__(2);
	var control_value_accessor_1 = __webpack_require__(120);
	var lang_1 = __webpack_require__(5);
	exports.DEFAULT_VALUE_ACCESSOR = 
	/* @ts2dart_Provider */ {
	    provide: control_value_accessor_1.NG_VALUE_ACCESSOR,
	    useExisting: core_1.forwardRef(function () { return DefaultValueAccessor; }),
	    multi: true
	};
	/**
	 * The default accessor for writing a value and listening to changes that is used by the
	 * {@link NgModel}, {@link NgFormControl}, and {@link NgControlName} directives.
	 *
	 *  ### Example
	 *  ```
	 *  <input type="text" ngControl="searchQuery">
	 *  ```
	 */
	var DefaultValueAccessor = (function () {
	    function DefaultValueAccessor(_renderer, _elementRef) {
	        this._renderer = _renderer;
	        this._elementRef = _elementRef;
	        this.onChange = function (_) { };
	        this.onTouched = function () { };
	    }
	    DefaultValueAccessor.prototype.writeValue = function (value) {
	        var normalizedValue = lang_1.isBlank(value) ? '' : value;
	        this._renderer.setElementProperty(this._elementRef.nativeElement, 'value', normalizedValue);
	    };
	    DefaultValueAccessor.prototype.registerOnChange = function (fn) { this.onChange = fn; };
	    DefaultValueAccessor.prototype.registerOnTouched = function (fn) { this.onTouched = fn; };
	    DefaultValueAccessor = __decorate([
	        core_1.Directive({
	            selector: 'input:not([type=checkbox])[ngControl],textarea[ngControl],input:not([type=checkbox])[ngFormControl],textarea[ngFormControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]',
	            // TODO: vsavkin replace the above selector with the one below it once
	            // https://github.com/angular/angular/issues/3011 is implemented
	            // selector: '[ngControl],[ngModel],[ngFormControl]',
	            host: { '(input)': 'onChange($event.target.value)', '(blur)': 'onTouched()' },
	            bindings: [exports.DEFAULT_VALUE_ACCESSOR]
	        }), 
	        __metadata('design:paramtypes', [core_1.Renderer, core_1.ElementRef])
	    ], DefaultValueAccessor);
	    return DefaultValueAccessor;
	}());
	exports.DefaultValueAccessor = DefaultValueAccessor;


/***/ },
/* 124 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var core_1 = __webpack_require__(2);
	var control_value_accessor_1 = __webpack_require__(120);
	var lang_1 = __webpack_require__(5);
	exports.NUMBER_VALUE_ACCESSOR = {
	    provide: control_value_accessor_1.NG_VALUE_ACCESSOR,
	    useExisting: core_1.forwardRef(function () { return NumberValueAccessor; }),
	    multi: true
	};
	/**
	 * The accessor for writing a number value and listening to changes that is used by the
	 * {@link NgModel}, {@link NgFormControl}, and {@link NgControlName} directives.
	 *
	 *  ### Example
	 *  ```
	 *  <input type="number" [(ngModel)]="age">
	 *  ```
	 */
	var NumberValueAccessor = (function () {
	    function NumberValueAccessor(_renderer, _elementRef) {
	        this._renderer = _renderer;
	        this._elementRef = _elementRef;
	        this.onChange = function (_) { };
	        this.onTouched = function () { };
	    }
	    NumberValueAccessor.prototype.writeValue = function (value) {
	        this._renderer.setElementProperty(this._elementRef.nativeElement, 'value', value);
	    };
	    NumberValueAccessor.prototype.registerOnChange = function (fn) {
	        this.onChange = function (value) { fn(value == '' ? null : lang_1.NumberWrapper.parseFloat(value)); };
	    };
	    NumberValueAccessor.prototype.registerOnTouched = function (fn) { this.onTouched = fn; };
	    NumberValueAccessor = __decorate([
	        core_1.Directive({
	            selector: 'input[type=number][ngControl],input[type=number][ngFormControl],input[type=number][ngModel]',
	            host: {
	                '(change)': 'onChange($event.target.value)',
	                '(input)': 'onChange($event.target.value)',
	                '(blur)': 'onTouched()'
	            },
	            bindings: [exports.NUMBER_VALUE_ACCESSOR]
	        }), 
	        __metadata('design:paramtypes', [core_1.Renderer, core_1.ElementRef])
	    ], NumberValueAccessor);
	    return NumberValueAccessor;
	}());
	exports.NumberValueAccessor = NumberValueAccessor;


/***/ },
/* 125 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var core_1 = __webpack_require__(2);
	var control_value_accessor_1 = __webpack_require__(120);
	exports.CHECKBOX_VALUE_ACCESSOR = {
	    provide: control_value_accessor_1.NG_VALUE_ACCESSOR,
	    useExisting: core_1.forwardRef(function () { return CheckboxControlValueAccessor; }),
	    multi: true
	};
	/**
	 * The accessor for writing a value and listening to changes on a checkbox input element.
	 *
	 *  ### Example
	 *  ```
	 *  <input type="checkbox" ngControl="rememberLogin">
	 *  ```
	 */
	var CheckboxControlValueAccessor = (function () {
	    function CheckboxControlValueAccessor(_renderer, _elementRef) {
	        this._renderer = _renderer;
	        this._elementRef = _elementRef;
	        this.onChange = function (_) { };
	        this.onTouched = function () { };
	    }
	    CheckboxControlValueAccessor.prototype.writeValue = function (value) {
	        this._renderer.setElementProperty(this._elementRef.nativeElement, 'checked', value);
	    };
	    CheckboxControlValueAccessor.prototype.registerOnChange = function (fn) { this.onChange = fn; };
	    CheckboxControlValueAccessor.prototype.registerOnTouched = function (fn) { this.onTouched = fn; };
	    CheckboxControlValueAccessor = __decorate([
	        core_1.Directive({
	            selector: 'input[type=checkbox][ngControl],input[type=checkbox][ngFormControl],input[type=checkbox][ngModel]',
	            host: { '(change)': 'onChange($event.target.checked)', '(blur)': 'onTouched()' },
	            providers: [exports.CHECKBOX_VALUE_ACCESSOR]
	        }), 
	        __metadata('design:paramtypes', [core_1.Renderer, core_1.ElementRef])
	    ], CheckboxControlValueAccessor);
	    return CheckboxControlValueAccessor;
	}());
	exports.CheckboxControlValueAccessor = CheckboxControlValueAccessor;


/***/ },
/* 126 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var core_1 = __webpack_require__(2);
	var control_value_accessor_1 = __webpack_require__(120);
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	exports.SELECT_VALUE_ACCESSOR = {
	    provide: control_value_accessor_1.NG_VALUE_ACCESSOR,
	    useExisting: core_1.forwardRef(function () { return SelectControlValueAccessor; }),
	    multi: true
	};
	function _buildValueString(id, value) {
	    if (lang_1.isBlank(id))
	        return "" + value;
	    if (!lang_1.isPrimitive(value))
	        value = "Object";
	    return lang_1.StringWrapper.slice(id + ": " + value, 0, 50);
	}
	function _extractId(valueString) {
	    return valueString.split(":")[0];
	}
	/**
	 * The accessor for writing a value and listening to changes on a select element.
	 *
	 * Note: We have to listen to the 'change' event because 'input' events aren't fired
	 * for selects in Firefox and IE:
	 * https://bugzilla.mozilla.org/show_bug.cgi?id=1024350
	 * https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/4660045/
	 *
	 */
	var SelectControlValueAccessor = (function () {
	    function SelectControlValueAccessor(_renderer, _elementRef) {
	        this._renderer = _renderer;
	        this._elementRef = _elementRef;
	        /** @internal */
	        this._optionMap = new Map();
	        /** @internal */
	        this._idCounter = 0;
	        this.onChange = function (_) { };
	        this.onTouched = function () { };
	    }
	    SelectControlValueAccessor.prototype.writeValue = function (value) {
	        this.value = value;
	        var valueString = _buildValueString(this._getOptionId(value), value);
	        this._renderer.setElementProperty(this._elementRef.nativeElement, 'value', valueString);
	    };
	    SelectControlValueAccessor.prototype.registerOnChange = function (fn) {
	        var _this = this;
	        this.onChange = function (valueString) { fn(_this._getOptionValue(valueString)); };
	    };
	    SelectControlValueAccessor.prototype.registerOnTouched = function (fn) { this.onTouched = fn; };
	    /** @internal */
	    SelectControlValueAccessor.prototype._registerOption = function () { return (this._idCounter++).toString(); };
	    /** @internal */
	    SelectControlValueAccessor.prototype._getOptionId = function (value) {
	        for (var _i = 0, _a = collection_1.MapWrapper.keys(this._optionMap); _i < _a.length; _i++) {
	            var id = _a[_i];
	            if (lang_1.looseIdentical(this._optionMap.get(id), value))
	                return id;
	        }
	        return null;
	    };
	    /** @internal */
	    SelectControlValueAccessor.prototype._getOptionValue = function (valueString) {
	        var value = this._optionMap.get(_extractId(valueString));
	        return lang_1.isPresent(value) ? value : valueString;
	    };
	    SelectControlValueAccessor = __decorate([
	        core_1.Directive({
	            selector: 'select[ngControl],select[ngFormControl],select[ngModel]',
	            host: { '(change)': 'onChange($event.target.value)', '(blur)': 'onTouched()' },
	            providers: [exports.SELECT_VALUE_ACCESSOR]
	        }), 
	        __metadata('design:paramtypes', [core_1.Renderer, core_1.ElementRef])
	    ], SelectControlValueAccessor);
	    return SelectControlValueAccessor;
	}());
	exports.SelectControlValueAccessor = SelectControlValueAccessor;
	/**
	 * Marks `<option>` as dynamic, so Angular can be notified when options change.
	 *
	 * ### Example
	 *
	 * ```
	 * <select ngControl="city">
	 *   <option *ngFor="let c of cities" [value]="c"></option>
	 * </select>
	 * ```
	 */
	var NgSelectOption = (function () {
	    function NgSelectOption(_element, _renderer, _select) {
	        this._element = _element;
	        this._renderer = _renderer;
	        this._select = _select;
	        if (lang_1.isPresent(this._select))
	            this.id = this._select._registerOption();
	    }
	    Object.defineProperty(NgSelectOption.prototype, "ngValue", {
	        set: function (value) {
	            if (this._select == null)
	                return;
	            this._select._optionMap.set(this.id, value);
	            this._setElementValue(_buildValueString(this.id, value));
	            this._select.writeValue(this._select.value);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgSelectOption.prototype, "value", {
	        set: function (value) {
	            this._setElementValue(value);
	            if (lang_1.isPresent(this._select))
	                this._select.writeValue(this._select.value);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    /** @internal */
	    NgSelectOption.prototype._setElementValue = function (value) {
	        this._renderer.setElementProperty(this._element.nativeElement, 'value', value);
	    };
	    NgSelectOption.prototype.ngOnDestroy = function () {
	        if (lang_1.isPresent(this._select)) {
	            this._select._optionMap.delete(this.id);
	            this._select.writeValue(this._select.value);
	        }
	    };
	    __decorate([
	        core_1.Input('ngValue'), 
	        __metadata('design:type', Object), 
	        __metadata('design:paramtypes', [Object])
	    ], NgSelectOption.prototype, "ngValue", null);
	    __decorate([
	        core_1.Input('value'), 
	        __metadata('design:type', Object), 
	        __metadata('design:paramtypes', [Object])
	    ], NgSelectOption.prototype, "value", null);
	    NgSelectOption = __decorate([
	        core_1.Directive({ selector: 'option' }),
	        __param(2, core_1.Optional()),
	        __param(2, core_1.Host()), 
	        __metadata('design:paramtypes', [core_1.ElementRef, core_1.Renderer, SelectControlValueAccessor])
	    ], NgSelectOption);
	    return NgSelectOption;
	}());
	exports.NgSelectOption = NgSelectOption;


/***/ },
/* 127 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var core_1 = __webpack_require__(2);
	var control_value_accessor_1 = __webpack_require__(120);
	var ng_control_1 = __webpack_require__(119);
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	exports.RADIO_VALUE_ACCESSOR = {
	    provide: control_value_accessor_1.NG_VALUE_ACCESSOR,
	    useExisting: core_1.forwardRef(function () { return RadioControlValueAccessor; }),
	    multi: true
	};
	/**
	 * Internal class used by Angular to uncheck radio buttons with the matching name.
	 */
	var RadioControlRegistry = (function () {
	    function RadioControlRegistry() {
	        this._accessors = [];
	    }
	    RadioControlRegistry.prototype.add = function (control, accessor) {
	        this._accessors.push([control, accessor]);
	    };
	    RadioControlRegistry.prototype.remove = function (accessor) {
	        var indexToRemove = -1;
	        for (var i = 0; i < this._accessors.length; ++i) {
	            if (this._accessors[i][1] === accessor) {
	                indexToRemove = i;
	            }
	        }
	        collection_1.ListWrapper.removeAt(this._accessors, indexToRemove);
	    };
	    RadioControlRegistry.prototype.select = function (accessor) {
	        this._accessors.forEach(function (c) {
	            if (c[0].control.root === accessor._control.control.root && c[1] !== accessor) {
	                c[1].fireUncheck();
	            }
	        });
	    };
	    RadioControlRegistry = __decorate([
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], RadioControlRegistry);
	    return RadioControlRegistry;
	}());
	exports.RadioControlRegistry = RadioControlRegistry;
	/**
	 * The value provided by the forms API for radio buttons.
	 */
	var RadioButtonState = (function () {
	    function RadioButtonState(checked, value) {
	        this.checked = checked;
	        this.value = value;
	    }
	    return RadioButtonState;
	}());
	exports.RadioButtonState = RadioButtonState;
	/**
	 * The accessor for writing a radio control value and listening to changes that is used by the
	 * {@link NgModel}, {@link NgFormControl}, and {@link NgControlName} directives.
	 *
	 *  ### Example
	 *  ```
	 *  @Component({
	 *    template: `
	 *      <input type="radio" name="food" [(ngModel)]="foodChicken">
	 *      <input type="radio" name="food" [(ngModel)]="foodFish">
	 *    `
	 *  })
	 *  class FoodCmp {
	 *    foodChicken = new RadioButtonState(true, "chicken");
	 *    foodFish = new RadioButtonState(false, "fish");
	 *  }
	 *  ```
	 */
	var RadioControlValueAccessor = (function () {
	    function RadioControlValueAccessor(_renderer, _elementRef, _registry, _injector) {
	        this._renderer = _renderer;
	        this._elementRef = _elementRef;
	        this._registry = _registry;
	        this._injector = _injector;
	        this.onChange = function () { };
	        this.onTouched = function () { };
	    }
	    RadioControlValueAccessor.prototype.ngOnInit = function () {
	        this._control = this._injector.get(ng_control_1.NgControl);
	        this._registry.add(this._control, this);
	    };
	    RadioControlValueAccessor.prototype.ngOnDestroy = function () { this._registry.remove(this); };
	    RadioControlValueAccessor.prototype.writeValue = function (value) {
	        this._state = value;
	        if (lang_1.isPresent(value) && value.checked) {
	            this._renderer.setElementProperty(this._elementRef.nativeElement, 'checked', true);
	        }
	    };
	    RadioControlValueAccessor.prototype.registerOnChange = function (fn) {
	        var _this = this;
	        this._fn = fn;
	        this.onChange = function () {
	            fn(new RadioButtonState(true, _this._state.value));
	            _this._registry.select(_this);
	        };
	    };
	    RadioControlValueAccessor.prototype.fireUncheck = function () { this._fn(new RadioButtonState(false, this._state.value)); };
	    RadioControlValueAccessor.prototype.registerOnTouched = function (fn) { this.onTouched = fn; };
	    __decorate([
	        core_1.Input(), 
	        __metadata('design:type', String)
	    ], RadioControlValueAccessor.prototype, "name", void 0);
	    RadioControlValueAccessor = __decorate([
	        core_1.Directive({
	            selector: 'input[type=radio][ngControl],input[type=radio][ngFormControl],input[type=radio][ngModel]',
	            host: { '(change)': 'onChange()', '(blur)': 'onTouched()' },
	            providers: [exports.RADIO_VALUE_ACCESSOR]
	        }), 
	        __metadata('design:paramtypes', [core_1.Renderer, core_1.ElementRef, RadioControlRegistry, core_1.Injector])
	    ], RadioControlValueAccessor);
	    return RadioControlValueAccessor;
	}());
	exports.RadioControlValueAccessor = RadioControlValueAccessor;


/***/ },
/* 128 */
/***/ function(module, exports) {

	"use strict";
	function normalizeValidator(validator) {
	    if (validator.validate !== undefined) {
	        return function (c) { return validator.validate(c); };
	    }
	    else {
	        return validator;
	    }
	}
	exports.normalizeValidator = normalizeValidator;
	function normalizeAsyncValidator(validator) {
	    if (validator.validate !== undefined) {
	        return function (c) { return Promise.resolve(validator.validate(c)); };
	    }
	    else {
	        return validator;
	    }
	}
	exports.normalizeAsyncValidator = normalizeAsyncValidator;


/***/ },
/* 129 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var collection_1 = __webpack_require__(15);
	var async_1 = __webpack_require__(41);
	var core_1 = __webpack_require__(2);
	var ng_control_1 = __webpack_require__(119);
	var validators_1 = __webpack_require__(122);
	var control_value_accessor_1 = __webpack_require__(120);
	var shared_1 = __webpack_require__(121);
	exports.formControlBinding = 
	/*@ts2dart_const*/ /* @ts2dart_Provider */ {
	    provide: ng_control_1.NgControl,
	    useExisting: core_1.forwardRef(function () { return NgFormControl; })
	};
	/**
	 * Binds an existing {@link Control} to a DOM element.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/jcQlZ2tTh22BZZ2ucNAT?p=preview))
	 *
	 * In this example, we bind the control to an input element. When the value of the input element
	 * changes, the value of the control will reflect that change. Likewise, if the value of the
	 * control changes, the input element reflects that change.
	 *
	 *  ```typescript
	 * @Component({
	 *   selector: 'my-app',
	 *   template: `
	 *     <div>
	 *       <h2>NgFormControl Example</h2>
	 *       <form>
	 *         <p>Element with existing control: <input type="text"
	 * [ngFormControl]="loginControl"></p>
	 *         <p>Value of existing control: {{loginControl.value}}</p>
	 *       </form>
	 *     </div>
	 *   `,
	 *   directives: [CORE_DIRECTIVES, FORM_DIRECTIVES]
	 * })
	 * export class App {
	 *   loginControl: Control = new Control('');
	 * }
	 *  ```
	 *
	 * ### ngModel
	 *
	 * We can also use `ngModel` to bind a domain model to the form.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/yHMLuHO7DNgT8XvtjTDH?p=preview))
	 *
	 *  ```typescript
	 * @Component({
	 *      selector: "login-comp",
	 *      directives: [FORM_DIRECTIVES],
	 *      template: "<input type='text' [ngFormControl]='loginControl' [(ngModel)]='login'>"
	 *      })
	 * class LoginComp {
	 *  loginControl: Control = new Control('');
	 *  login:string;
	 * }
	 *  ```
	 */
	var NgFormControl = (function (_super) {
	    __extends(NgFormControl, _super);
	    function NgFormControl(_validators, _asyncValidators, valueAccessors) {
	        _super.call(this);
	        this._validators = _validators;
	        this._asyncValidators = _asyncValidators;
	        this.update = new async_1.EventEmitter();
	        this.valueAccessor = shared_1.selectValueAccessor(this, valueAccessors);
	    }
	    NgFormControl.prototype.ngOnChanges = function (changes) {
	        if (this._isControlChanged(changes)) {
	            shared_1.setUpControl(this.form, this);
	            this.form.updateValueAndValidity({ emitEvent: false });
	        }
	        if (shared_1.isPropertyUpdated(changes, this.viewModel)) {
	            this.form.updateValue(this.model);
	            this.viewModel = this.model;
	        }
	    };
	    Object.defineProperty(NgFormControl.prototype, "path", {
	        get: function () { return []; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgFormControl.prototype, "validator", {
	        get: function () { return shared_1.composeValidators(this._validators); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgFormControl.prototype, "asyncValidator", {
	        get: function () { return shared_1.composeAsyncValidators(this._asyncValidators); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgFormControl.prototype, "control", {
	        get: function () { return this.form; },
	        enumerable: true,
	        configurable: true
	    });
	    NgFormControl.prototype.viewToModelUpdate = function (newValue) {
	        this.viewModel = newValue;
	        async_1.ObservableWrapper.callEmit(this.update, newValue);
	    };
	    NgFormControl.prototype._isControlChanged = function (changes) {
	        return collection_1.StringMapWrapper.contains(changes, "form");
	    };
	    NgFormControl = __decorate([
	        core_1.Directive({
	            selector: '[ngFormControl]',
	            bindings: [exports.formControlBinding],
	            inputs: ['form: ngFormControl', 'model: ngModel'],
	            outputs: ['update: ngModelChange'],
	            exportAs: 'ngForm'
	        }),
	        __param(0, core_1.Optional()),
	        __param(0, core_1.Self()),
	        __param(0, core_1.Inject(validators_1.NG_VALIDATORS)),
	        __param(1, core_1.Optional()),
	        __param(1, core_1.Self()),
	        __param(1, core_1.Inject(validators_1.NG_ASYNC_VALIDATORS)),
	        __param(2, core_1.Optional()),
	        __param(2, core_1.Self()),
	        __param(2, core_1.Inject(control_value_accessor_1.NG_VALUE_ACCESSOR)), 
	        __metadata('design:paramtypes', [Array, Array, Array])
	    ], NgFormControl);
	    return NgFormControl;
	}(ng_control_1.NgControl));
	exports.NgFormControl = NgFormControl;


/***/ },
/* 130 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var async_1 = __webpack_require__(41);
	var core_1 = __webpack_require__(2);
	var control_value_accessor_1 = __webpack_require__(120);
	var ng_control_1 = __webpack_require__(119);
	var model_1 = __webpack_require__(115);
	var validators_1 = __webpack_require__(122);
	var shared_1 = __webpack_require__(121);
	exports.formControlBinding = 
	/*@ts2dart_const*/ /* @ts2dart_Provider */ {
	    provide: ng_control_1.NgControl,
	    useExisting: core_1.forwardRef(function () { return NgModel; })
	};
	/**
	 * Binds a domain model to a form control.
	 *
	 * ### Usage
	 *
	 * `ngModel` binds an existing domain model to a form control. For a
	 * two-way binding, use `[(ngModel)]` to ensure the model updates in
	 * both directions.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/R3UX5qDaUqFO2VYR0UzH?p=preview))
	 *  ```typescript
	 * @Component({
	 *      selector: "search-comp",
	 *      directives: [FORM_DIRECTIVES],
	 *      template: `<input type='text' [(ngModel)]="searchQuery">`
	 *      })
	 * class SearchComp {
	 *  searchQuery: string;
	 * }
	 *  ```
	 */
	var NgModel = (function (_super) {
	    __extends(NgModel, _super);
	    function NgModel(_validators, _asyncValidators, valueAccessors) {
	        _super.call(this);
	        this._validators = _validators;
	        this._asyncValidators = _asyncValidators;
	        /** @internal */
	        this._control = new model_1.Control();
	        /** @internal */
	        this._added = false;
	        this.update = new async_1.EventEmitter();
	        this.valueAccessor = shared_1.selectValueAccessor(this, valueAccessors);
	    }
	    NgModel.prototype.ngOnChanges = function (changes) {
	        if (!this._added) {
	            shared_1.setUpControl(this._control, this);
	            this._control.updateValueAndValidity({ emitEvent: false });
	            this._added = true;
	        }
	        if (shared_1.isPropertyUpdated(changes, this.viewModel)) {
	            this._control.updateValue(this.model);
	            this.viewModel = this.model;
	        }
	    };
	    Object.defineProperty(NgModel.prototype, "control", {
	        get: function () { return this._control; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgModel.prototype, "path", {
	        get: function () { return []; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgModel.prototype, "validator", {
	        get: function () { return shared_1.composeValidators(this._validators); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgModel.prototype, "asyncValidator", {
	        get: function () { return shared_1.composeAsyncValidators(this._asyncValidators); },
	        enumerable: true,
	        configurable: true
	    });
	    NgModel.prototype.viewToModelUpdate = function (newValue) {
	        this.viewModel = newValue;
	        async_1.ObservableWrapper.callEmit(this.update, newValue);
	    };
	    NgModel = __decorate([
	        core_1.Directive({
	            selector: '[ngModel]:not([ngControl]):not([ngFormControl])',
	            bindings: [exports.formControlBinding],
	            inputs: ['model: ngModel'],
	            outputs: ['update: ngModelChange'],
	            exportAs: 'ngForm'
	        }),
	        __param(0, core_1.Optional()),
	        __param(0, core_1.Self()),
	        __param(0, core_1.Inject(validators_1.NG_VALIDATORS)),
	        __param(1, core_1.Optional()),
	        __param(1, core_1.Self()),
	        __param(1, core_1.Inject(validators_1.NG_ASYNC_VALIDATORS)),
	        __param(2, core_1.Optional()),
	        __param(2, core_1.Self()),
	        __param(2, core_1.Inject(control_value_accessor_1.NG_VALUE_ACCESSOR)), 
	        __metadata('design:paramtypes', [Array, Array, Array])
	    ], NgModel);
	    return NgModel;
	}(ng_control_1.NgControl));
	exports.NgModel = NgModel;


/***/ },
/* 131 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var core_1 = __webpack_require__(2);
	var control_container_1 = __webpack_require__(117);
	var shared_1 = __webpack_require__(121);
	var validators_1 = __webpack_require__(122);
	exports.controlGroupProvider = 
	/*@ts2dart_const*/ /* @ts2dart_Provider */ {
	    provide: control_container_1.ControlContainer,
	    useExisting: core_1.forwardRef(function () { return NgControlGroup; })
	};
	/**
	 * Creates and binds a control group to a DOM element.
	 *
	 * This directive can only be used as a child of {@link NgForm} or {@link NgFormModel}.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/7EJ11uGeaggViYM6T5nq?p=preview))
	 *
	 * ```typescript
	 * @Component({
	 *   selector: 'my-app',
	 *   directives: [FORM_DIRECTIVES],
	 *   template: `
	 *     <div>
	 *       <h2>Angular2 Control &amp; ControlGroup Example</h2>
	 *       <form #f="ngForm">
	 *         <div ngControlGroup="name" #cg-name="form">
	 *           <h3>Enter your name:</h3>
	 *           <p>First: <input ngControl="first" required></p>
	 *           <p>Middle: <input ngControl="middle"></p>
	 *           <p>Last: <input ngControl="last" required></p>
	 *         </div>
	 *         <h3>Name value:</h3>
	 *         <pre>{{valueOf(cgName)}}</pre>
	 *         <p>Name is {{cgName?.control?.valid ? "valid" : "invalid"}}</p>
	 *         <h3>What's your favorite food?</h3>
	 *         <p><input ngControl="food"></p>
	 *         <h3>Form value</h3>
	 *         <pre>{{valueOf(f)}}</pre>
	 *       </form>
	 *     </div>
	 *   `
	 * })
	 * export class App {
	 *   valueOf(cg: NgControlGroup): string {
	 *     if (cg.control == null) {
	 *       return null;
	 *     }
	 *     return JSON.stringify(cg.control.value, null, 2);
	 *   }
	 * }
	 * ```
	 *
	 * This example declares a control group for a user's name. The value and validation state of
	 * this group can be accessed separately from the overall form.
	 */
	var NgControlGroup = (function (_super) {
	    __extends(NgControlGroup, _super);
	    function NgControlGroup(parent, _validators, _asyncValidators) {
	        _super.call(this);
	        this._validators = _validators;
	        this._asyncValidators = _asyncValidators;
	        this._parent = parent;
	    }
	    NgControlGroup.prototype.ngOnInit = function () { this.formDirective.addControlGroup(this); };
	    NgControlGroup.prototype.ngOnDestroy = function () { this.formDirective.removeControlGroup(this); };
	    Object.defineProperty(NgControlGroup.prototype, "control", {
	        /**
	         * Get the {@link ControlGroup} backing this binding.
	         */
	        get: function () { return this.formDirective.getControlGroup(this); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgControlGroup.prototype, "path", {
	        /**
	         * Get the path to this control group.
	         */
	        get: function () { return shared_1.controlPath(this.name, this._parent); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgControlGroup.prototype, "formDirective", {
	        /**
	         * Get the {@link Form} to which this group belongs.
	         */
	        get: function () { return this._parent.formDirective; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgControlGroup.prototype, "validator", {
	        get: function () { return shared_1.composeValidators(this._validators); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgControlGroup.prototype, "asyncValidator", {
	        get: function () { return shared_1.composeAsyncValidators(this._asyncValidators); },
	        enumerable: true,
	        configurable: true
	    });
	    NgControlGroup = __decorate([
	        core_1.Directive({
	            selector: '[ngControlGroup]',
	            providers: [exports.controlGroupProvider],
	            inputs: ['name: ngControlGroup'],
	            exportAs: 'ngForm'
	        }),
	        __param(0, core_1.Host()),
	        __param(0, core_1.SkipSelf()),
	        __param(1, core_1.Optional()),
	        __param(1, core_1.Self()),
	        __param(1, core_1.Inject(validators_1.NG_VALIDATORS)),
	        __param(2, core_1.Optional()),
	        __param(2, core_1.Self()),
	        __param(2, core_1.Inject(validators_1.NG_ASYNC_VALIDATORS)), 
	        __metadata('design:paramtypes', [control_container_1.ControlContainer, Array, Array])
	    ], NgControlGroup);
	    return NgControlGroup;
	}(control_container_1.ControlContainer));
	exports.NgControlGroup = NgControlGroup;


/***/ },
/* 132 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var exceptions_1 = __webpack_require__(12);
	var async_1 = __webpack_require__(41);
	var core_1 = __webpack_require__(2);
	var control_container_1 = __webpack_require__(117);
	var shared_1 = __webpack_require__(121);
	var validators_1 = __webpack_require__(122);
	exports.formDirectiveProvider = 
	/*@ts2dart_const*/ /* @ts2dart_Provider */ {
	    provide: control_container_1.ControlContainer,
	    useExisting: core_1.forwardRef(function () { return NgFormModel; })
	};
	/**
	 * Binds an existing control group to a DOM element.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/jqrVirudY8anJxTMUjTP?p=preview))
	 *
	 * In this example, we bind the control group to the form element, and we bind the login and
	 * password controls to the login and password elements.
	 *
	 *  ```typescript
	 * @Component({
	 *   selector: 'my-app',
	 *   template: `
	 *     <div>
	 *       <h2>NgFormModel Example</h2>
	 *       <form [ngFormModel]="loginForm">
	 *         <p>Login: <input type="text" ngControl="login"></p>
	 *         <p>Password: <input type="password" ngControl="password"></p>
	 *       </form>
	 *       <p>Value:</p>
	 *       <pre>{{value}}</pre>
	 *     </div>
	 *   `,
	 *   directives: [FORM_DIRECTIVES]
	 * })
	 * export class App {
	 *   loginForm: ControlGroup;
	 *
	 *   constructor() {
	 *     this.loginForm = new ControlGroup({
	 *       login: new Control(""),
	 *       password: new Control("")
	 *     });
	 *   }
	 *
	 *   get value(): string {
	 *     return JSON.stringify(this.loginForm.value, null, 2);
	 *   }
	 * }
	 *  ```
	 *
	 * We can also use ngModel to bind a domain model to the form.
	 *
	 *  ```typescript
	 * @Component({
	 *      selector: "login-comp",
	 *      directives: [FORM_DIRECTIVES],
	 *      template: `
	 *        <form [ngFormModel]='loginForm'>
	 *          Login <input type='text' ngControl='login' [(ngModel)]='credentials.login'>
	 *          Password <input type='password' ngControl='password'
	 *                          [(ngModel)]='credentials.password'>
	 *          <button (click)="onLogin()">Login</button>
	 *        </form>`
	 *      })
	 * class LoginComp {
	 *  credentials: {login: string, password: string};
	 *  loginForm: ControlGroup;
	 *
	 *  constructor() {
	 *    this.loginForm = new ControlGroup({
	 *      login: new Control(""),
	 *      password: new Control("")
	 *    });
	 *  }
	 *
	 *  onLogin(): void {
	 *    // this.credentials.login === 'some login'
	 *    // this.credentials.password === 'some password'
	 *  }
	 * }
	 *  ```
	 */
	var NgFormModel = (function (_super) {
	    __extends(NgFormModel, _super);
	    function NgFormModel(_validators, _asyncValidators) {
	        _super.call(this);
	        this._validators = _validators;
	        this._asyncValidators = _asyncValidators;
	        this.form = null;
	        this.directives = [];
	        this.ngSubmit = new async_1.EventEmitter();
	    }
	    NgFormModel.prototype.ngOnChanges = function (changes) {
	        this._checkFormPresent();
	        if (collection_1.StringMapWrapper.contains(changes, "form")) {
	            var sync = shared_1.composeValidators(this._validators);
	            this.form.validator = validators_1.Validators.compose([this.form.validator, sync]);
	            var async = shared_1.composeAsyncValidators(this._asyncValidators);
	            this.form.asyncValidator = validators_1.Validators.composeAsync([this.form.asyncValidator, async]);
	            this.form.updateValueAndValidity({ onlySelf: true, emitEvent: false });
	        }
	        this._updateDomValue();
	    };
	    Object.defineProperty(NgFormModel.prototype, "formDirective", {
	        get: function () { return this; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgFormModel.prototype, "control", {
	        get: function () { return this.form; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgFormModel.prototype, "path", {
	        get: function () { return []; },
	        enumerable: true,
	        configurable: true
	    });
	    NgFormModel.prototype.addControl = function (dir) {
	        var ctrl = this.form.find(dir.path);
	        shared_1.setUpControl(ctrl, dir);
	        ctrl.updateValueAndValidity({ emitEvent: false });
	        this.directives.push(dir);
	    };
	    NgFormModel.prototype.getControl = function (dir) { return this.form.find(dir.path); };
	    NgFormModel.prototype.removeControl = function (dir) { collection_1.ListWrapper.remove(this.directives, dir); };
	    NgFormModel.prototype.addControlGroup = function (dir) {
	        var ctrl = this.form.find(dir.path);
	        shared_1.setUpControlGroup(ctrl, dir);
	        ctrl.updateValueAndValidity({ emitEvent: false });
	    };
	    NgFormModel.prototype.removeControlGroup = function (dir) { };
	    NgFormModel.prototype.getControlGroup = function (dir) {
	        return this.form.find(dir.path);
	    };
	    NgFormModel.prototype.updateModel = function (dir, value) {
	        var ctrl = this.form.find(dir.path);
	        ctrl.updateValue(value);
	    };
	    NgFormModel.prototype.onSubmit = function () {
	        async_1.ObservableWrapper.callEmit(this.ngSubmit, null);
	        return false;
	    };
	    /** @internal */
	    NgFormModel.prototype._updateDomValue = function () {
	        var _this = this;
	        this.directives.forEach(function (dir) {
	            var ctrl = _this.form.find(dir.path);
	            dir.valueAccessor.writeValue(ctrl.value);
	        });
	    };
	    NgFormModel.prototype._checkFormPresent = function () {
	        if (lang_1.isBlank(this.form)) {
	            throw new exceptions_1.BaseException("ngFormModel expects a form. Please pass one in. Example: <form [ngFormModel]=\"myCoolForm\">");
	        }
	    };
	    NgFormModel = __decorate([
	        core_1.Directive({
	            selector: '[ngFormModel]',
	            bindings: [exports.formDirectiveProvider],
	            inputs: ['form: ngFormModel'],
	            host: { '(submit)': 'onSubmit()' },
	            outputs: ['ngSubmit'],
	            exportAs: 'ngForm'
	        }),
	        __param(0, core_1.Optional()),
	        __param(0, core_1.Self()),
	        __param(0, core_1.Inject(validators_1.NG_VALIDATORS)),
	        __param(1, core_1.Optional()),
	        __param(1, core_1.Self()),
	        __param(1, core_1.Inject(validators_1.NG_ASYNC_VALIDATORS)), 
	        __metadata('design:paramtypes', [Array, Array])
	    ], NgFormModel);
	    return NgFormModel;
	}(control_container_1.ControlContainer));
	exports.NgFormModel = NgFormModel;


/***/ },
/* 133 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var async_1 = __webpack_require__(41);
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	var core_1 = __webpack_require__(2);
	var control_container_1 = __webpack_require__(117);
	var model_1 = __webpack_require__(115);
	var shared_1 = __webpack_require__(121);
	var validators_1 = __webpack_require__(122);
	exports.formDirectiveProvider = 
	/*@ts2dart_const*/ /* @ts2dart_Provider */ {
	    provide: control_container_1.ControlContainer,
	    useExisting: core_1.forwardRef(function () { return NgForm; })
	};
	/**
	 * If `NgForm` is bound in a component, `<form>` elements in that component will be
	 * upgraded to use the Angular form system.
	 *
	 * ### Typical Use
	 *
	 * Include `FORM_DIRECTIVES` in the `directives` section of a {@link View} annotation
	 * to use `NgForm` and its associated controls.
	 *
	 * ### Structure
	 *
	 * An Angular form is a collection of `Control`s in some hierarchy.
	 * `Control`s can be at the top level or can be organized in `ControlGroup`s
	 * or `ControlArray`s. This hierarchy is reflected in the form's `value`, a
	 * JSON object that mirrors the form structure.
	 *
	 * ### Submission
	 *
	 * The `ngSubmit` event signals when the user triggers a form submission.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/ltdgYj4P0iY64AR71EpL?p=preview))
	 *
	 *  ```typescript
	 * @Component({
	 *   selector: 'my-app',
	 *   template: `
	 *     <div>
	 *       <p>Submit the form to see the data object Angular builds</p>
	 *       <h2>NgForm demo</h2>
	 *       <form #f="ngForm" (ngSubmit)="onSubmit(f.value)">
	 *         <h3>Control group: credentials</h3>
	 *         <div ngControlGroup="credentials">
	 *           <p>Login: <input type="text" ngControl="login"></p>
	 *           <p>Password: <input type="password" ngControl="password"></p>
	 *         </div>
	 *         <h3>Control group: person</h3>
	 *         <div ngControlGroup="person">
	 *           <p>First name: <input type="text" ngControl="firstName"></p>
	 *           <p>Last name: <input type="text" ngControl="lastName"></p>
	 *         </div>
	 *         <button type="submit">Submit Form</button>
	 *       <p>Form data submitted:</p>
	 *       </form>
	 *       <pre>{{data}}</pre>
	 *     </div>
	 * `,
	 *   directives: [CORE_DIRECTIVES, FORM_DIRECTIVES]
	 * })
	 * export class App {
	 *   constructor() {}
	 *
	 *   data: string;
	 *
	 *   onSubmit(data) {
	 *     this.data = JSON.stringify(data, null, 2);
	 *   }
	 * }
	 *  ```
	 */
	var NgForm = (function (_super) {
	    __extends(NgForm, _super);
	    function NgForm(validators, asyncValidators) {
	        _super.call(this);
	        this.ngSubmit = new async_1.EventEmitter();
	        this.form = new model_1.ControlGroup({}, null, shared_1.composeValidators(validators), shared_1.composeAsyncValidators(asyncValidators));
	    }
	    Object.defineProperty(NgForm.prototype, "formDirective", {
	        get: function () { return this; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgForm.prototype, "control", {
	        get: function () { return this.form; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgForm.prototype, "path", {
	        get: function () { return []; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgForm.prototype, "controls", {
	        get: function () { return this.form.controls; },
	        enumerable: true,
	        configurable: true
	    });
	    NgForm.prototype.addControl = function (dir) {
	        var _this = this;
	        async_1.PromiseWrapper.scheduleMicrotask(function () {
	            var container = _this._findContainer(dir.path);
	            var ctrl = new model_1.Control();
	            shared_1.setUpControl(ctrl, dir);
	            container.addControl(dir.name, ctrl);
	            ctrl.updateValueAndValidity({ emitEvent: false });
	        });
	    };
	    NgForm.prototype.getControl = function (dir) { return this.form.find(dir.path); };
	    NgForm.prototype.removeControl = function (dir) {
	        var _this = this;
	        async_1.PromiseWrapper.scheduleMicrotask(function () {
	            var container = _this._findContainer(dir.path);
	            if (lang_1.isPresent(container)) {
	                container.removeControl(dir.name);
	                container.updateValueAndValidity({ emitEvent: false });
	            }
	        });
	    };
	    NgForm.prototype.addControlGroup = function (dir) {
	        var _this = this;
	        async_1.PromiseWrapper.scheduleMicrotask(function () {
	            var container = _this._findContainer(dir.path);
	            var group = new model_1.ControlGroup({});
	            shared_1.setUpControlGroup(group, dir);
	            container.addControl(dir.name, group);
	            group.updateValueAndValidity({ emitEvent: false });
	        });
	    };
	    NgForm.prototype.removeControlGroup = function (dir) {
	        var _this = this;
	        async_1.PromiseWrapper.scheduleMicrotask(function () {
	            var container = _this._findContainer(dir.path);
	            if (lang_1.isPresent(container)) {
	                container.removeControl(dir.name);
	                container.updateValueAndValidity({ emitEvent: false });
	            }
	        });
	    };
	    NgForm.prototype.getControlGroup = function (dir) {
	        return this.form.find(dir.path);
	    };
	    NgForm.prototype.updateModel = function (dir, value) {
	        var _this = this;
	        async_1.PromiseWrapper.scheduleMicrotask(function () {
	            var ctrl = _this.form.find(dir.path);
	            ctrl.updateValue(value);
	        });
	    };
	    NgForm.prototype.onSubmit = function () {
	        async_1.ObservableWrapper.callEmit(this.ngSubmit, null);
	        return false;
	    };
	    /** @internal */
	    NgForm.prototype._findContainer = function (path) {
	        path.pop();
	        return collection_1.ListWrapper.isEmpty(path) ? this.form : this.form.find(path);
	    };
	    NgForm = __decorate([
	        core_1.Directive({
	            selector: 'form:not([ngNoForm]):not([ngFormModel]),ngForm,[ngForm]',
	            bindings: [exports.formDirectiveProvider],
	            host: {
	                '(submit)': 'onSubmit()',
	            },
	            outputs: ['ngSubmit'],
	            exportAs: 'ngForm'
	        }),
	        __param(0, core_1.Optional()),
	        __param(0, core_1.Self()),
	        __param(0, core_1.Inject(validators_1.NG_VALIDATORS)),
	        __param(1, core_1.Optional()),
	        __param(1, core_1.Self()),
	        __param(1, core_1.Inject(validators_1.NG_ASYNC_VALIDATORS)), 
	        __metadata('design:paramtypes', [Array, Array])
	    ], NgForm);
	    return NgForm;
	}(control_container_1.ControlContainer));
	exports.NgForm = NgForm;


/***/ },
/* 134 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var core_1 = __webpack_require__(2);
	var ng_control_1 = __webpack_require__(119);
	var lang_1 = __webpack_require__(5);
	/**
	 * Directive automatically applied to Angular forms that sets CSS classes
	 * based on control status (valid/invalid/dirty/etc).
	 */
	var NgControlStatus = (function () {
	    function NgControlStatus(cd) {
	        this._cd = cd;
	    }
	    Object.defineProperty(NgControlStatus.prototype, "ngClassUntouched", {
	        get: function () {
	            return lang_1.isPresent(this._cd.control) ? this._cd.control.untouched : false;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgControlStatus.prototype, "ngClassTouched", {
	        get: function () {
	            return lang_1.isPresent(this._cd.control) ? this._cd.control.touched : false;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgControlStatus.prototype, "ngClassPristine", {
	        get: function () {
	            return lang_1.isPresent(this._cd.control) ? this._cd.control.pristine : false;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgControlStatus.prototype, "ngClassDirty", {
	        get: function () {
	            return lang_1.isPresent(this._cd.control) ? this._cd.control.dirty : false;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgControlStatus.prototype, "ngClassValid", {
	        get: function () {
	            return lang_1.isPresent(this._cd.control) ? this._cd.control.valid : false;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(NgControlStatus.prototype, "ngClassInvalid", {
	        get: function () {
	            return lang_1.isPresent(this._cd.control) ? !this._cd.control.valid : false;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    NgControlStatus = __decorate([
	        core_1.Directive({
	            selector: '[ngControl],[ngModel],[ngFormControl]',
	            host: {
	                '[class.ng-untouched]': 'ngClassUntouched',
	                '[class.ng-touched]': 'ngClassTouched',
	                '[class.ng-pristine]': 'ngClassPristine',
	                '[class.ng-dirty]': 'ngClassDirty',
	                '[class.ng-valid]': 'ngClassValid',
	                '[class.ng-invalid]': 'ngClassInvalid'
	            }
	        }),
	        __param(0, core_1.Self()), 
	        __metadata('design:paramtypes', [ng_control_1.NgControl])
	    ], NgControlStatus);
	    return NgControlStatus;
	}());
	exports.NgControlStatus = NgControlStatus;


/***/ },
/* 135 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var ng_control_name_1 = __webpack_require__(118);
	var ng_form_control_1 = __webpack_require__(129);
	var ng_model_1 = __webpack_require__(130);
	var ng_control_group_1 = __webpack_require__(131);
	var ng_form_model_1 = __webpack_require__(132);
	var ng_form_1 = __webpack_require__(133);
	var default_value_accessor_1 = __webpack_require__(123);
	var checkbox_value_accessor_1 = __webpack_require__(125);
	var number_value_accessor_1 = __webpack_require__(124);
	var radio_control_value_accessor_1 = __webpack_require__(127);
	var ng_control_status_1 = __webpack_require__(134);
	var select_control_value_accessor_1 = __webpack_require__(126);
	var validators_1 = __webpack_require__(136);
	var ng_control_name_2 = __webpack_require__(118);
	exports.NgControlName = ng_control_name_2.NgControlName;
	var ng_form_control_2 = __webpack_require__(129);
	exports.NgFormControl = ng_form_control_2.NgFormControl;
	var ng_model_2 = __webpack_require__(130);
	exports.NgModel = ng_model_2.NgModel;
	var ng_control_group_2 = __webpack_require__(131);
	exports.NgControlGroup = ng_control_group_2.NgControlGroup;
	var ng_form_model_2 = __webpack_require__(132);
	exports.NgFormModel = ng_form_model_2.NgFormModel;
	var ng_form_2 = __webpack_require__(133);
	exports.NgForm = ng_form_2.NgForm;
	var default_value_accessor_2 = __webpack_require__(123);
	exports.DefaultValueAccessor = default_value_accessor_2.DefaultValueAccessor;
	var checkbox_value_accessor_2 = __webpack_require__(125);
	exports.CheckboxControlValueAccessor = checkbox_value_accessor_2.CheckboxControlValueAccessor;
	var radio_control_value_accessor_2 = __webpack_require__(127);
	exports.RadioControlValueAccessor = radio_control_value_accessor_2.RadioControlValueAccessor;
	exports.RadioButtonState = radio_control_value_accessor_2.RadioButtonState;
	var number_value_accessor_2 = __webpack_require__(124);
	exports.NumberValueAccessor = number_value_accessor_2.NumberValueAccessor;
	var ng_control_status_2 = __webpack_require__(134);
	exports.NgControlStatus = ng_control_status_2.NgControlStatus;
	var select_control_value_accessor_2 = __webpack_require__(126);
	exports.SelectControlValueAccessor = select_control_value_accessor_2.SelectControlValueAccessor;
	exports.NgSelectOption = select_control_value_accessor_2.NgSelectOption;
	var validators_2 = __webpack_require__(136);
	exports.RequiredValidator = validators_2.RequiredValidator;
	exports.MinLengthValidator = validators_2.MinLengthValidator;
	exports.MaxLengthValidator = validators_2.MaxLengthValidator;
	exports.PatternValidator = validators_2.PatternValidator;
	var ng_control_1 = __webpack_require__(119);
	exports.NgControl = ng_control_1.NgControl;
	/**
	 *
	 * A list of all the form directives used as part of a `@Component` annotation.
	 *
	 *  This is a shorthand for importing them each individually.
	 *
	 * ### Example
	 *
	 * ```typescript
	 * @Component({
	 *   selector: 'my-app',
	 *   directives: [FORM_DIRECTIVES]
	 * })
	 * class MyApp {}
	 * ```
	 */
	exports.FORM_DIRECTIVES = [
	    ng_control_name_1.NgControlName,
	    ng_control_group_1.NgControlGroup,
	    ng_form_control_1.NgFormControl,
	    ng_model_1.NgModel,
	    ng_form_model_1.NgFormModel,
	    ng_form_1.NgForm,
	    select_control_value_accessor_1.NgSelectOption,
	    default_value_accessor_1.DefaultValueAccessor,
	    number_value_accessor_1.NumberValueAccessor,
	    checkbox_value_accessor_1.CheckboxControlValueAccessor,
	    select_control_value_accessor_1.SelectControlValueAccessor,
	    radio_control_value_accessor_1.RadioControlValueAccessor,
	    ng_control_status_1.NgControlStatus,
	    validators_1.RequiredValidator,
	    validators_1.MinLengthValidator,
	    validators_1.MaxLengthValidator,
	    validators_1.PatternValidator
	];


/***/ },
/* 136 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var core_1 = __webpack_require__(2);
	var lang_1 = __webpack_require__(5);
	var validators_1 = __webpack_require__(122);
	var REQUIRED = validators_1.Validators.required;
	exports.REQUIRED_VALIDATOR = {
	    provide: validators_1.NG_VALIDATORS,
	    useValue: REQUIRED,
	    multi: true
	};
	/**
	 * A Directive that adds the `required` validator to any controls marked with the
	 * `required` attribute, via the {@link NG_VALIDATORS} binding.
	 *
	 * ### Example
	 *
	 * ```
	 * <input ngControl="fullName" required>
	 * ```
	 */
	var RequiredValidator = (function () {
	    function RequiredValidator() {
	    }
	    RequiredValidator = __decorate([
	        core_1.Directive({
	            selector: '[required][ngControl],[required][ngFormControl],[required][ngModel]',
	            providers: [exports.REQUIRED_VALIDATOR]
	        }), 
	        __metadata('design:paramtypes', [])
	    ], RequiredValidator);
	    return RequiredValidator;
	}());
	exports.RequiredValidator = RequiredValidator;
	/**
	 * Provivder which adds {@link MinLengthValidator} to {@link NG_VALIDATORS}.
	 *
	 * ## Example:
	 *
	 * {@example common/forms/ts/validators/validators.ts region='min'}
	 */
	exports.MIN_LENGTH_VALIDATOR = {
	    provide: validators_1.NG_VALIDATORS,
	    useExisting: core_1.forwardRef(function () { return MinLengthValidator; }),
	    multi: true
	};
	/**
	 * A directive which installs the {@link MinLengthValidator} for any `ngControl`,
	 * `ngFormControl`, or control with `ngModel` that also has a `minlength` attribute.
	 */
	var MinLengthValidator = (function () {
	    function MinLengthValidator(minLength) {
	        this._validator = validators_1.Validators.minLength(lang_1.NumberWrapper.parseInt(minLength, 10));
	    }
	    MinLengthValidator.prototype.validate = function (c) { return this._validator(c); };
	    MinLengthValidator = __decorate([
	        core_1.Directive({
	            selector: '[minlength][ngControl],[minlength][ngFormControl],[minlength][ngModel]',
	            providers: [exports.MIN_LENGTH_VALIDATOR]
	        }),
	        __param(0, core_1.Attribute("minlength")), 
	        __metadata('design:paramtypes', [String])
	    ], MinLengthValidator);
	    return MinLengthValidator;
	}());
	exports.MinLengthValidator = MinLengthValidator;
	/**
	 * Provider which adds {@link MaxLengthValidator} to {@link NG_VALIDATORS}.
	 *
	 * ## Example:
	 *
	 * {@example common/forms/ts/validators/validators.ts region='max'}
	 */
	exports.MAX_LENGTH_VALIDATOR = {
	    provide: validators_1.NG_VALIDATORS,
	    useExisting: core_1.forwardRef(function () { return MaxLengthValidator; }),
	    multi: true
	};
	/**
	 * A directive which installs the {@link MaxLengthValidator} for any `ngControl, `ngFormControl`,
	 * or control with `ngModel` that also has a `maxlength` attribute.
	 */
	var MaxLengthValidator = (function () {
	    function MaxLengthValidator(maxLength) {
	        this._validator = validators_1.Validators.maxLength(lang_1.NumberWrapper.parseInt(maxLength, 10));
	    }
	    MaxLengthValidator.prototype.validate = function (c) { return this._validator(c); };
	    MaxLengthValidator = __decorate([
	        core_1.Directive({
	            selector: '[maxlength][ngControl],[maxlength][ngFormControl],[maxlength][ngModel]',
	            providers: [exports.MAX_LENGTH_VALIDATOR]
	        }),
	        __param(0, core_1.Attribute("maxlength")), 
	        __metadata('design:paramtypes', [String])
	    ], MaxLengthValidator);
	    return MaxLengthValidator;
	}());
	exports.MaxLengthValidator = MaxLengthValidator;
	/**
	 * A Directive that adds the `pattern` validator to any controls marked with the
	 * `pattern` attribute, via the {@link NG_VALIDATORS} binding. Uses attribute value
	 * as the regex to validate Control value against.  Follows pattern attribute
	 * semantics; i.e. regex must match entire Control value.
	 *
	 * ### Example
	 *
	 * ```
	 * <input [ngControl]="fullName" pattern="[a-zA-Z ]*">
	 * ```
	 */
	exports.PATTERN_VALIDATOR = {
	    provide: validators_1.NG_VALIDATORS,
	    useExisting: core_1.forwardRef(function () { return PatternValidator; }),
	    multi: true
	};
	var PatternValidator = (function () {
	    function PatternValidator(pattern) {
	        this._validator = validators_1.Validators.pattern(pattern);
	    }
	    PatternValidator.prototype.validate = function (c) { return this._validator(c); };
	    PatternValidator = __decorate([
	        core_1.Directive({
	            selector: '[pattern][ngControl],[pattern][ngFormControl],[pattern][ngModel]',
	            providers: [exports.PATTERN_VALIDATOR]
	        }),
	        __param(0, core_1.Attribute("pattern")), 
	        __metadata('design:paramtypes', [String])
	    ], PatternValidator);
	    return PatternValidator;
	}());
	exports.PatternValidator = PatternValidator;


/***/ },
/* 137 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var core_1 = __webpack_require__(2);
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	var modelModule = __webpack_require__(115);
	/**
	 * Creates a form object from a user-specified configuration.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/ENgZo8EuIECZNensZCVr?p=preview))
	 *
	 * ```typescript
	 * @Component({
	 *   selector: 'my-app',
	 *   viewBindings: [FORM_BINDINGS]
	 *   template: `
	 *     <form [ngFormModel]="loginForm">
	 *       <p>Login <input ngControl="login"></p>
	 *       <div ngControlGroup="passwordRetry">
	 *         <p>Password <input type="password" ngControl="password"></p>
	 *         <p>Confirm password <input type="password" ngControl="passwordConfirmation"></p>
	 *       </div>
	 *     </form>
	 *     <h3>Form value:</h3>
	 *     <pre>{{value}}</pre>
	 *   `,
	 *   directives: [FORM_DIRECTIVES]
	 * })
	 * export class App {
	 *   loginForm: ControlGroup;
	 *
	 *   constructor(builder: FormBuilder) {
	 *     this.loginForm = builder.group({
	 *       login: ["", Validators.required],
	 *       passwordRetry: builder.group({
	 *         password: ["", Validators.required],
	 *         passwordConfirmation: ["", Validators.required, asyncValidator]
	 *       })
	 *     });
	 *   }
	 *
	 *   get value(): string {
	 *     return JSON.stringify(this.loginForm.value, null, 2);
	 *   }
	 * }
	 * ```
	 */
	var FormBuilder = (function () {
	    function FormBuilder() {
	    }
	    /**
	     * Construct a new {@link ControlGroup} with the given map of configuration.
	     * Valid keys for the `extra` parameter map are `optionals` and `validator`.
	     *
	     * See the {@link ControlGroup} constructor for more details.
	     */
	    FormBuilder.prototype.group = function (controlsConfig, extra) {
	        if (extra === void 0) { extra = null; }
	        var controls = this._reduceControls(controlsConfig);
	        var optionals = (lang_1.isPresent(extra) ? collection_1.StringMapWrapper.get(extra, "optionals") : null);
	        var validator = lang_1.isPresent(extra) ? collection_1.StringMapWrapper.get(extra, "validator") : null;
	        var asyncValidator = lang_1.isPresent(extra) ? collection_1.StringMapWrapper.get(extra, "asyncValidator") : null;
	        return new modelModule.ControlGroup(controls, optionals, validator, asyncValidator);
	    };
	    /**
	     * Construct a new {@link Control} with the given `value`,`validator`, and `asyncValidator`.
	     */
	    FormBuilder.prototype.control = function (value, validator, asyncValidator) {
	        if (validator === void 0) { validator = null; }
	        if (asyncValidator === void 0) { asyncValidator = null; }
	        return new modelModule.Control(value, validator, asyncValidator);
	    };
	    /**
	     * Construct an array of {@link Control}s from the given `controlsConfig` array of
	     * configuration, with the given optional `validator` and `asyncValidator`.
	     */
	    FormBuilder.prototype.array = function (controlsConfig, validator, asyncValidator) {
	        var _this = this;
	        if (validator === void 0) { validator = null; }
	        if (asyncValidator === void 0) { asyncValidator = null; }
	        var controls = controlsConfig.map(function (c) { return _this._createControl(c); });
	        return new modelModule.ControlArray(controls, validator, asyncValidator);
	    };
	    /** @internal */
	    FormBuilder.prototype._reduceControls = function (controlsConfig) {
	        var _this = this;
	        var controls = {};
	        collection_1.StringMapWrapper.forEach(controlsConfig, function (controlConfig, controlName) {
	            controls[controlName] = _this._createControl(controlConfig);
	        });
	        return controls;
	    };
	    /** @internal */
	    FormBuilder.prototype._createControl = function (controlConfig) {
	        if (controlConfig instanceof modelModule.Control ||
	            controlConfig instanceof modelModule.ControlGroup ||
	            controlConfig instanceof modelModule.ControlArray) {
	            return controlConfig;
	        }
	        else if (lang_1.isArray(controlConfig)) {
	            var value = controlConfig[0];
	            var validator = controlConfig.length > 1 ? controlConfig[1] : null;
	            var asyncValidator = controlConfig.length > 2 ? controlConfig[2] : null;
	            return this.control(value, validator, asyncValidator);
	        }
	        else {
	            return this.control(controlConfig);
	        }
	    };
	    FormBuilder = __decorate([
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], FormBuilder);
	    return FormBuilder;
	}());
	exports.FormBuilder = FormBuilder;


/***/ },
/* 138 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var forms_1 = __webpack_require__(114);
	var directives_1 = __webpack_require__(104);
	/**
	 * 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 {
	 *   ...
	 * }
	 * ```
	 */
	exports.COMMON_DIRECTIVES = [directives_1.CORE_DIRECTIVES, forms_1.FORM_DIRECTIVES];


/***/ },
/* 139 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	function __export(m) {
	    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
	}
	/**
	 * @module
	 * @description
	 * Starting point to import all compiler APIs.
	 */
	var compiler_1 = __webpack_require__(140);
	exports.PLATFORM_DIRECTIVES = compiler_1.PLATFORM_DIRECTIVES;
	exports.PLATFORM_PIPES = compiler_1.PLATFORM_PIPES;
	exports.COMPILER_PROVIDERS = compiler_1.COMPILER_PROVIDERS;
	exports.TEMPLATE_TRANSFORMS = compiler_1.TEMPLATE_TRANSFORMS;
	exports.CompilerConfig = compiler_1.CompilerConfig;
	exports.RenderTypes = compiler_1.RenderTypes;
	exports.UrlResolver = compiler_1.UrlResolver;
	exports.DEFAULT_PACKAGE_URL_PROVIDER = compiler_1.DEFAULT_PACKAGE_URL_PROVIDER;
	exports.createOfflineCompileUrlResolver = compiler_1.createOfflineCompileUrlResolver;
	exports.XHR = compiler_1.XHR;
	exports.ViewResolver = compiler_1.ViewResolver;
	exports.DirectiveResolver = compiler_1.DirectiveResolver;
	exports.PipeResolver = compiler_1.PipeResolver;
	exports.SourceModule = compiler_1.SourceModule;
	exports.NormalizedComponentWithViewDirectives = compiler_1.NormalizedComponentWithViewDirectives;
	exports.OfflineCompiler = compiler_1.OfflineCompiler;
	exports.CompileMetadataWithIdentifier = compiler_1.CompileMetadataWithIdentifier;
	exports.CompileMetadataWithType = compiler_1.CompileMetadataWithType;
	exports.CompileIdentifierMetadata = compiler_1.CompileIdentifierMetadata;
	exports.CompileDiDependencyMetadata = compiler_1.CompileDiDependencyMetadata;
	exports.CompileProviderMetadata = compiler_1.CompileProviderMetadata;
	exports.CompileFactoryMetadata = compiler_1.CompileFactoryMetadata;
	exports.CompileTokenMetadata = compiler_1.CompileTokenMetadata;
	exports.CompileTypeMetadata = compiler_1.CompileTypeMetadata;
	exports.CompileQueryMetadata = compiler_1.CompileQueryMetadata;
	exports.CompileTemplateMetadata = compiler_1.CompileTemplateMetadata;
	exports.CompileDirectiveMetadata = compiler_1.CompileDirectiveMetadata;
	exports.CompilePipeMetadata = compiler_1.CompilePipeMetadata;
	__export(__webpack_require__(141));


/***/ },
/* 140 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	function __export(m) {
	    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
	}
	var platform_directives_and_pipes_1 = __webpack_require__(86);
	exports.PLATFORM_DIRECTIVES = platform_directives_and_pipes_1.PLATFORM_DIRECTIVES;
	exports.PLATFORM_PIPES = platform_directives_and_pipes_1.PLATFORM_PIPES;
	__export(__webpack_require__(141));
	var template_parser_1 = __webpack_require__(142);
	exports.TEMPLATE_TRANSFORMS = template_parser_1.TEMPLATE_TRANSFORMS;
	var config_1 = __webpack_require__(164);
	exports.CompilerConfig = config_1.CompilerConfig;
	exports.RenderTypes = config_1.RenderTypes;
	__export(__webpack_require__(157));
	__export(__webpack_require__(165));
	var runtime_compiler_1 = __webpack_require__(167);
	exports.RuntimeCompiler = runtime_compiler_1.RuntimeCompiler;
	__export(__webpack_require__(159));
	__export(__webpack_require__(186));
	var view_resolver_1 = __webpack_require__(190);
	exports.ViewResolver = view_resolver_1.ViewResolver;
	var directive_resolver_1 = __webpack_require__(188);
	exports.DirectiveResolver = directive_resolver_1.DirectiveResolver;
	var pipe_resolver_1 = __webpack_require__(189);
	exports.PipeResolver = pipe_resolver_1.PipeResolver;
	var lang_1 = __webpack_require__(5);
	var template_parser_2 = __webpack_require__(142);
	var html_parser_1 = __webpack_require__(146);
	var directive_normalizer_1 = __webpack_require__(185);
	var metadata_resolver_1 = __webpack_require__(187);
	var style_compiler_1 = __webpack_require__(168);
	var view_compiler_1 = __webpack_require__(170);
	var config_2 = __webpack_require__(164);
	var component_resolver_1 = __webpack_require__(66);
	var runtime_compiler_2 = __webpack_require__(167);
	var element_schema_registry_1 = __webpack_require__(152);
	var dom_element_schema_registry_1 = __webpack_require__(201);
	var url_resolver_2 = __webpack_require__(159);
	var parser_1 = __webpack_require__(144);
	var lexer_1 = __webpack_require__(145);
	var view_resolver_2 = __webpack_require__(190);
	var directive_resolver_2 = __webpack_require__(188);
	var pipe_resolver_2 = __webpack_require__(189);
	function _createCompilerConfig() {
	    return new config_2.CompilerConfig(lang_1.assertionsEnabled(), false, true);
	}
	/**
	 * A set of providers that provide `RuntimeCompiler` and its dependencies to use for
	 * template compilation.
	 */
	exports.COMPILER_PROVIDERS = 
	/*@ts2dart_const*/ [
	    lexer_1.Lexer,
	    parser_1.Parser,
	    html_parser_1.HtmlParser,
	    template_parser_2.TemplateParser,
	    directive_normalizer_1.DirectiveNormalizer,
	    metadata_resolver_1.CompileMetadataResolver,
	    url_resolver_2.DEFAULT_PACKAGE_URL_PROVIDER,
	    style_compiler_1.StyleCompiler,
	    view_compiler_1.ViewCompiler,
	    /*@ts2dart_Provider*/ { provide: config_2.CompilerConfig, useFactory: _createCompilerConfig, deps: [] },
	    runtime_compiler_2.RuntimeCompiler,
	    /*@ts2dart_Provider*/ { provide: component_resolver_1.ComponentResolver, useExisting: runtime_compiler_2.RuntimeCompiler },
	    dom_element_schema_registry_1.DomElementSchemaRegistry,
	    /*@ts2dart_Provider*/ { provide: element_schema_registry_1.ElementSchemaRegistry, useExisting: dom_element_schema_registry_1.DomElementSchemaRegistry },
	    url_resolver_2.UrlResolver,
	    view_resolver_2.ViewResolver,
	    directive_resolver_2.DirectiveResolver,
	    pipe_resolver_2.PipeResolver
	];


/***/ },
/* 141 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	/**
	 * A segment of text within the template.
	 */
	var TextAst = (function () {
	    function TextAst(value, ngContentIndex, sourceSpan) {
	        this.value = value;
	        this.ngContentIndex = ngContentIndex;
	        this.sourceSpan = sourceSpan;
	    }
	    TextAst.prototype.visit = function (visitor, context) { return visitor.visitText(this, context); };
	    return TextAst;
	}());
	exports.TextAst = TextAst;
	/**
	 * A bound expression within the text of a template.
	 */
	var BoundTextAst = (function () {
	    function BoundTextAst(value, ngContentIndex, sourceSpan) {
	        this.value = value;
	        this.ngContentIndex = ngContentIndex;
	        this.sourceSpan = sourceSpan;
	    }
	    BoundTextAst.prototype.visit = function (visitor, context) {
	        return visitor.visitBoundText(this, context);
	    };
	    return BoundTextAst;
	}());
	exports.BoundTextAst = BoundTextAst;
	/**
	 * A plain attribute on an element.
	 */
	var AttrAst = (function () {
	    function AttrAst(name, value, sourceSpan) {
	        this.name = name;
	        this.value = value;
	        this.sourceSpan = sourceSpan;
	    }
	    AttrAst.prototype.visit = function (visitor, context) { return visitor.visitAttr(this, context); };
	    return AttrAst;
	}());
	exports.AttrAst = AttrAst;
	/**
	 * A binding for an element property (e.g. `[property]="expression"`).
	 */
	var BoundElementPropertyAst = (function () {
	    function BoundElementPropertyAst(name, type, value, unit, sourceSpan) {
	        this.name = name;
	        this.type = type;
	        this.value = value;
	        this.unit = unit;
	        this.sourceSpan = sourceSpan;
	    }
	    BoundElementPropertyAst.prototype.visit = function (visitor, context) {
	        return visitor.visitElementProperty(this, context);
	    };
	    return BoundElementPropertyAst;
	}());
	exports.BoundElementPropertyAst = BoundElementPropertyAst;
	/**
	 * A binding for an element event (e.g. `(event)="handler()"`).
	 */
	var BoundEventAst = (function () {
	    function BoundEventAst(name, target, handler, sourceSpan) {
	        this.name = name;
	        this.target = target;
	        this.handler = handler;
	        this.sourceSpan = sourceSpan;
	    }
	    BoundEventAst.prototype.visit = function (visitor, context) {
	        return visitor.visitEvent(this, context);
	    };
	    Object.defineProperty(BoundEventAst.prototype, "fullName", {
	        get: function () {
	            if (lang_1.isPresent(this.target)) {
	                return this.target + ":" + this.name;
	            }
	            else {
	                return this.name;
	            }
	        },
	        enumerable: true,
	        configurable: true
	    });
	    return BoundEventAst;
	}());
	exports.BoundEventAst = BoundEventAst;
	/**
	 * A reference declaration on an element (e.g. `let someName="expression"`).
	 */
	var ReferenceAst = (function () {
	    function ReferenceAst(name, value, sourceSpan) {
	        this.name = name;
	        this.value = value;
	        this.sourceSpan = sourceSpan;
	    }
	    ReferenceAst.prototype.visit = function (visitor, context) {
	        return visitor.visitReference(this, context);
	    };
	    return ReferenceAst;
	}());
	exports.ReferenceAst = ReferenceAst;
	/**
	 * A variable declaration on a <template> (e.g. `var-someName="someLocalName"`).
	 */
	var VariableAst = (function () {
	    function VariableAst(name, value, sourceSpan) {
	        this.name = name;
	        this.value = value;
	        this.sourceSpan = sourceSpan;
	    }
	    VariableAst.prototype.visit = function (visitor, context) {
	        return visitor.visitVariable(this, context);
	    };
	    return VariableAst;
	}());
	exports.VariableAst = VariableAst;
	/**
	 * An element declaration in a template.
	 */
	var ElementAst = (function () {
	    function ElementAst(name, attrs, inputs, outputs, references, directives, providers, hasViewContainer, children, ngContentIndex, sourceSpan) {
	        this.name = name;
	        this.attrs = attrs;
	        this.inputs = inputs;
	        this.outputs = outputs;
	        this.references = references;
	        this.directives = directives;
	        this.providers = providers;
	        this.hasViewContainer = hasViewContainer;
	        this.children = children;
	        this.ngContentIndex = ngContentIndex;
	        this.sourceSpan = sourceSpan;
	    }
	    ElementAst.prototype.visit = function (visitor, context) {
	        return visitor.visitElement(this, context);
	    };
	    return ElementAst;
	}());
	exports.ElementAst = ElementAst;
	/**
	 * A `<template>` element included in an Angular template.
	 */
	var EmbeddedTemplateAst = (function () {
	    function EmbeddedTemplateAst(attrs, outputs, references, variables, directives, providers, hasViewContainer, children, ngContentIndex, sourceSpan) {
	        this.attrs = attrs;
	        this.outputs = outputs;
	        this.references = references;
	        this.variables = variables;
	        this.directives = directives;
	        this.providers = providers;
	        this.hasViewContainer = hasViewContainer;
	        this.children = children;
	        this.ngContentIndex = ngContentIndex;
	        this.sourceSpan = sourceSpan;
	    }
	    EmbeddedTemplateAst.prototype.visit = function (visitor, context) {
	        return visitor.visitEmbeddedTemplate(this, context);
	    };
	    return EmbeddedTemplateAst;
	}());
	exports.EmbeddedTemplateAst = EmbeddedTemplateAst;
	/**
	 * A directive property with a bound value (e.g. `*ngIf="condition").
	 */
	var BoundDirectivePropertyAst = (function () {
	    function BoundDirectivePropertyAst(directiveName, templateName, value, sourceSpan) {
	        this.directiveName = directiveName;
	        this.templateName = templateName;
	        this.value = value;
	        this.sourceSpan = sourceSpan;
	    }
	    BoundDirectivePropertyAst.prototype.visit = function (visitor, context) {
	        return visitor.visitDirectiveProperty(this, context);
	    };
	    return BoundDirectivePropertyAst;
	}());
	exports.BoundDirectivePropertyAst = BoundDirectivePropertyAst;
	/**
	 * A directive declared on an element.
	 */
	var DirectiveAst = (function () {
	    function DirectiveAst(directive, inputs, hostProperties, hostEvents, sourceSpan) {
	        this.directive = directive;
	        this.inputs = inputs;
	        this.hostProperties = hostProperties;
	        this.hostEvents = hostEvents;
	        this.sourceSpan = sourceSpan;
	    }
	    DirectiveAst.prototype.visit = function (visitor, context) {
	        return visitor.visitDirective(this, context);
	    };
	    return DirectiveAst;
	}());
	exports.DirectiveAst = DirectiveAst;
	/**
	 * A provider declared on an element
	 */
	var ProviderAst = (function () {
	    function ProviderAst(token, multiProvider, eager, providers, providerType, sourceSpan) {
	        this.token = token;
	        this.multiProvider = multiProvider;
	        this.eager = eager;
	        this.providers = providers;
	        this.providerType = providerType;
	        this.sourceSpan = sourceSpan;
	    }
	    ProviderAst.prototype.visit = function (visitor, context) {
	        // No visit method in the visitor for now...
	        return null;
	    };
	    return ProviderAst;
	}());
	exports.ProviderAst = ProviderAst;
	(function (ProviderAstType) {
	    ProviderAstType[ProviderAstType["PublicService"] = 0] = "PublicService";
	    ProviderAstType[ProviderAstType["PrivateService"] = 1] = "PrivateService";
	    ProviderAstType[ProviderAstType["Component"] = 2] = "Component";
	    ProviderAstType[ProviderAstType["Directive"] = 3] = "Directive";
	    ProviderAstType[ProviderAstType["Builtin"] = 4] = "Builtin";
	})(exports.ProviderAstType || (exports.ProviderAstType = {}));
	var ProviderAstType = exports.ProviderAstType;
	/**
	 * Position where content is to be projected (instance of `<ng-content>` in a template).
	 */
	var NgContentAst = (function () {
	    function NgContentAst(index, ngContentIndex, sourceSpan) {
	        this.index = index;
	        this.ngContentIndex = ngContentIndex;
	        this.sourceSpan = sourceSpan;
	    }
	    NgContentAst.prototype.visit = function (visitor, context) {
	        return visitor.visitNgContent(this, context);
	    };
	    return NgContentAst;
	}());
	exports.NgContentAst = NgContentAst;
	/**
	 * Enumeration of types of property bindings.
	 */
	(function (PropertyBindingType) {
	    /**
	     * A normal binding to a property (e.g. `[property]="expression"`).
	     */
	    PropertyBindingType[PropertyBindingType["Property"] = 0] = "Property";
	    /**
	     * A binding to an element attribute (e.g. `[attr.name]="expression"`).
	     */
	    PropertyBindingType[PropertyBindingType["Attribute"] = 1] = "Attribute";
	    /**
	     * A binding to a CSS class (e.g. `[class.name]="condition"`).
	     */
	    PropertyBindingType[PropertyBindingType["Class"] = 2] = "Class";
	    /**
	     * A binding to a style rule (e.g. `[style.rule]="expression"`).
	     */
	    PropertyBindingType[PropertyBindingType["Style"] = 3] = "Style";
	})(exports.PropertyBindingType || (exports.PropertyBindingType = {}));
	var PropertyBindingType = exports.PropertyBindingType;
	/**
	 * Visit every node in a list of {@link TemplateAst}s with the given {@link TemplateAstVisitor}.
	 */
	function templateVisitAll(visitor, asts, context) {
	    if (context === void 0) { context = null; }
	    var result = [];
	    asts.forEach(function (ast) {
	        var astResult = ast.visit(visitor, context);
	        if (lang_1.isPresent(astResult)) {
	            result.push(astResult);
	        }
	    });
	    return result;
	}
	exports.templateVisitAll = templateVisitAll;


/***/ },
/* 142 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	var core_1 = __webpack_require__(2);
	var console_1 = __webpack_require__(77);
	var exceptions_1 = __webpack_require__(12);
	var ast_1 = __webpack_require__(143);
	var parser_1 = __webpack_require__(144);
	var html_parser_1 = __webpack_require__(146);
	var html_tags_1 = __webpack_require__(150);
	var parse_util_1 = __webpack_require__(149);
	var view_utils_1 = __webpack_require__(68);
	var template_ast_1 = __webpack_require__(141);
	var selector_1 = __webpack_require__(151);
	var element_schema_registry_1 = __webpack_require__(152);
	var template_preparser_1 = __webpack_require__(153);
	var style_url_resolver_1 = __webpack_require__(154);
	var html_ast_1 = __webpack_require__(147);
	var util_1 = __webpack_require__(155);
	var identifiers_1 = __webpack_require__(156);
	var provider_parser_1 = __webpack_require__(163);
	// Group 1 = "bind-"
	// Group 2 = "var-"
	// Group 3 = "let-"
	// Group 4 = "ref-/#"
	// Group 5 = "on-"
	// Group 6 = "bindon-"
	// Group 7 = the identifier after "bind-", "var-/#", or "on-"
	// Group 8 = identifier inside [()]
	// Group 9 = identifier inside []
	// Group 10 = identifier inside ()
	var BIND_NAME_REGEXP = /^(?:(?:(?:(bind-)|(var-)|(let-)|(ref-|#)|(on-)|(bindon-))(.+))|\[\(([^\)]+)\)\]|\[([^\]]+)\]|\(([^\)]+)\))$/g;
	var TEMPLATE_ELEMENT = 'template';
	var TEMPLATE_ATTR = 'template';
	var TEMPLATE_ATTR_PREFIX = '*';
	var CLASS_ATTR = 'class';
	var PROPERTY_PARTS_SEPARATOR = '.';
	var ATTRIBUTE_PREFIX = 'attr';
	var CLASS_PREFIX = 'class';
	var STYLE_PREFIX = 'style';
	var TEXT_CSS_SELECTOR = selector_1.CssSelector.parse('*')[0];
	/**
	 * Provides an array of {@link TemplateAstVisitor}s which will be used to transform
	 * parsed templates before compilation is invoked, allowing custom expression syntax
	 * and other advanced transformations.
	 *
	 * This is currently an internal-only feature and not meant for general use.
	 */
	exports.TEMPLATE_TRANSFORMS = new core_1.OpaqueToken('TemplateTransforms');
	var TemplateParseError = (function (_super) {
	    __extends(TemplateParseError, _super);
	    function TemplateParseError(message, span, level) {
	        _super.call(this, span, message, level);
	    }
	    return TemplateParseError;
	}(parse_util_1.ParseError));
	exports.TemplateParseError = TemplateParseError;
	var TemplateParseResult = (function () {
	    function TemplateParseResult(templateAst, errors) {
	        this.templateAst = templateAst;
	        this.errors = errors;
	    }
	    return TemplateParseResult;
	}());
	exports.TemplateParseResult = TemplateParseResult;
	var TemplateParser = (function () {
	    function TemplateParser(_exprParser, _schemaRegistry, _htmlParser, _console, transforms) {
	        this._exprParser = _exprParser;
	        this._schemaRegistry = _schemaRegistry;
	        this._htmlParser = _htmlParser;
	        this._console = _console;
	        this.transforms = transforms;
	    }
	    TemplateParser.prototype.parse = function (component, template, directives, pipes, templateUrl) {
	        var result = this.tryParse(component, template, directives, pipes, templateUrl);
	        var warnings = result.errors.filter(function (error) { return error.level === parse_util_1.ParseErrorLevel.WARNING; });
	        var errors = result.errors.filter(function (error) { return error.level === parse_util_1.ParseErrorLevel.FATAL; });
	        if (warnings.length > 0) {
	            this._console.warn("Template parse warnings:\n" + warnings.join('\n'));
	        }
	        if (errors.length > 0) {
	            var errorString = errors.join('\n');
	            throw new exceptions_1.BaseException("Template parse errors:\n" + errorString);
	        }
	        return result.templateAst;
	    };
	    TemplateParser.prototype.tryParse = function (component, template, directives, pipes, templateUrl) {
	        var htmlAstWithErrors = this._htmlParser.parse(template, templateUrl);
	        var errors = htmlAstWithErrors.errors;
	        var result;
	        if (htmlAstWithErrors.rootNodes.length > 0) {
	            var uniqDirectives = removeDuplicates(directives);
	            var uniqPipes = removeDuplicates(pipes);
	            var providerViewContext = new provider_parser_1.ProviderViewContext(component, htmlAstWithErrors.rootNodes[0].sourceSpan);
	            var parseVisitor = new TemplateParseVisitor(providerViewContext, uniqDirectives, uniqPipes, this._exprParser, this._schemaRegistry);
	            result = html_ast_1.htmlVisitAll(parseVisitor, htmlAstWithErrors.rootNodes, EMPTY_ELEMENT_CONTEXT);
	            errors = errors.concat(parseVisitor.errors).concat(providerViewContext.errors);
	        }
	        else {
	            result = [];
	        }
	        if (errors.length > 0) {
	            return new TemplateParseResult(result, errors);
	        }
	        if (lang_1.isPresent(this.transforms)) {
	            this.transforms.forEach(function (transform) { result = template_ast_1.templateVisitAll(transform, result); });
	        }
	        return new TemplateParseResult(result, errors);
	    };
	    TemplateParser = __decorate([
	        core_1.Injectable(),
	        __param(4, core_1.Optional()),
	        __param(4, core_1.Inject(exports.TEMPLATE_TRANSFORMS)), 
	        __metadata('design:paramtypes', [parser_1.Parser, element_schema_registry_1.ElementSchemaRegistry, html_parser_1.HtmlParser, console_1.Console, Array])
	    ], TemplateParser);
	    return TemplateParser;
	}());
	exports.TemplateParser = TemplateParser;
	var TemplateParseVisitor = (function () {
	    function TemplateParseVisitor(providerViewContext, directives, pipes, _exprParser, _schemaRegistry) {
	        var _this = this;
	        this.providerViewContext = providerViewContext;
	        this._exprParser = _exprParser;
	        this._schemaRegistry = _schemaRegistry;
	        this.errors = [];
	        this.directivesIndex = new Map();
	        this.ngContentCount = 0;
	        this.selectorMatcher = new selector_1.SelectorMatcher();
	        collection_1.ListWrapper.forEachWithIndex(directives, function (directive, index) {
	            var selector = selector_1.CssSelector.parse(directive.selector);
	            _this.selectorMatcher.addSelectables(selector, directive);
	            _this.directivesIndex.set(directive, index);
	        });
	        this.pipesByName = new Map();
	        pipes.forEach(function (pipe) { return _this.pipesByName.set(pipe.name, pipe); });
	    }
	    TemplateParseVisitor.prototype._reportError = function (message, sourceSpan, level) {
	        if (level === void 0) { level = parse_util_1.ParseErrorLevel.FATAL; }
	        this.errors.push(new TemplateParseError(message, sourceSpan, level));
	    };
	    TemplateParseVisitor.prototype._parseInterpolation = function (value, sourceSpan) {
	        var sourceInfo = sourceSpan.start.toString();
	        try {
	            var ast = this._exprParser.parseInterpolation(value, sourceInfo);
	            this._checkPipes(ast, sourceSpan);
	            if (lang_1.isPresent(ast) &&
	                ast.ast.expressions.length > view_utils_1.MAX_INTERPOLATION_VALUES) {
	                throw new exceptions_1.BaseException("Only support at most " + view_utils_1.MAX_INTERPOLATION_VALUES + " interpolation values!");
	            }
	            return ast;
	        }
	        catch (e) {
	            this._reportError("" + e, sourceSpan);
	            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
	        }
	    };
	    TemplateParseVisitor.prototype._parseAction = function (value, sourceSpan) {
	        var sourceInfo = sourceSpan.start.toString();
	        try {
	            var ast = this._exprParser.parseAction(value, sourceInfo);
	            this._checkPipes(ast, sourceSpan);
	            return ast;
	        }
	        catch (e) {
	            this._reportError("" + e, sourceSpan);
	            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
	        }
	    };
	    TemplateParseVisitor.prototype._parseBinding = function (value, sourceSpan) {
	        var sourceInfo = sourceSpan.start.toString();
	        try {
	            var ast = this._exprParser.parseBinding(value, sourceInfo);
	            this._checkPipes(ast, sourceSpan);
	            return ast;
	        }
	        catch (e) {
	            this._reportError("" + e, sourceSpan);
	            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
	        }
	    };
	    TemplateParseVisitor.prototype._parseTemplateBindings = function (value, sourceSpan) {
	        var _this = this;
	        var sourceInfo = sourceSpan.start.toString();
	        try {
	            var bindingsResult = this._exprParser.parseTemplateBindings(value, sourceInfo);
	            bindingsResult.templateBindings.forEach(function (binding) {
	                if (lang_1.isPresent(binding.expression)) {
	                    _this._checkPipes(binding.expression, sourceSpan);
	                }
	            });
	            bindingsResult.warnings.forEach(function (warning) { _this._reportError(warning, sourceSpan, parse_util_1.ParseErrorLevel.WARNING); });
	            return bindingsResult.templateBindings;
	        }
	        catch (e) {
	            this._reportError("" + e, sourceSpan);
	            return [];
	        }
	    };
	    TemplateParseVisitor.prototype._checkPipes = function (ast, sourceSpan) {
	        var _this = this;
	        if (lang_1.isPresent(ast)) {
	            var collector = new PipeCollector();
	            ast.visit(collector);
	            collector.pipes.forEach(function (pipeName) {
	                if (!_this.pipesByName.has(pipeName)) {
	                    _this._reportError("The pipe '" + pipeName + "' could not be found", sourceSpan);
	                }
	            });
	        }
	    };
	    TemplateParseVisitor.prototype.visitExpansion = function (ast, context) { return null; };
	    TemplateParseVisitor.prototype.visitExpansionCase = function (ast, context) { return null; };
	    TemplateParseVisitor.prototype.visitText = function (ast, parent) {
	        var ngContentIndex = parent.findNgContentIndex(TEXT_CSS_SELECTOR);
	        var expr = this._parseInterpolation(ast.value, ast.sourceSpan);
	        if (lang_1.isPresent(expr)) {
	            return new template_ast_1.BoundTextAst(expr, ngContentIndex, ast.sourceSpan);
	        }
	        else {
	            return new template_ast_1.TextAst(ast.value, ngContentIndex, ast.sourceSpan);
	        }
	    };
	    TemplateParseVisitor.prototype.visitAttr = function (ast, contex) {
	        return new template_ast_1.AttrAst(ast.name, ast.value, ast.sourceSpan);
	    };
	    TemplateParseVisitor.prototype.visitComment = function (ast, context) { return null; };
	    TemplateParseVisitor.prototype.visitElement = function (element, parent) {
	        var _this = this;
	        var nodeName = element.name;
	        var preparsedElement = template_preparser_1.preparseElement(element);
	        if (preparsedElement.type === template_preparser_1.PreparsedElementType.SCRIPT ||
	            preparsedElement.type === template_preparser_1.PreparsedElementType.STYLE) {
	            // Skipping <script> for security reasons
	            // Skipping <style> as we already processed them
	            // in the StyleCompiler
	            return null;
	        }
	        if (preparsedElement.type === template_preparser_1.PreparsedElementType.STYLESHEET &&
	            style_url_resolver_1.isStyleUrlResolvable(preparsedElement.hrefAttr)) {
	            // Skipping stylesheets with either relative urls or package scheme as we already processed
	            // them in the StyleCompiler
	            return null;
	        }
	        var matchableAttrs = [];
	        var elementOrDirectiveProps = [];
	        var elementOrDirectiveRefs = [];
	        var elementVars = [];
	        var events = [];
	        var templateElementOrDirectiveProps = [];
	        var templateMatchableAttrs = [];
	        var templateElementVars = [];
	        var hasInlineTemplates = false;
	        var attrs = [];
	        var lcElName = html_tags_1.splitNsName(nodeName.toLowerCase())[1];
	        var isTemplateElement = lcElName == TEMPLATE_ELEMENT;
	        element.attrs.forEach(function (attr) {
	            var hasBinding = _this._parseAttr(isTemplateElement, attr, matchableAttrs, elementOrDirectiveProps, events, elementOrDirectiveRefs, elementVars);
	            var hasTemplateBinding = _this._parseInlineTemplateBinding(attr, templateMatchableAttrs, templateElementOrDirectiveProps, templateElementVars);
	            if (!hasBinding && !hasTemplateBinding) {
	                // don't include the bindings as attributes as well in the AST
	                attrs.push(_this.visitAttr(attr, null));
	                matchableAttrs.push([attr.name, attr.value]);
	            }
	            if (hasTemplateBinding) {
	                hasInlineTemplates = true;
	            }
	        });
	        var elementCssSelector = createElementCssSelector(nodeName, matchableAttrs);
	        var directiveMetas = this._parseDirectives(this.selectorMatcher, elementCssSelector);
	        var references = [];
	        var directiveAsts = this._createDirectiveAsts(isTemplateElement, element.name, directiveMetas, elementOrDirectiveProps, elementOrDirectiveRefs, element.sourceSpan, references);
	        var elementProps = this._createElementPropertyAsts(element.name, elementOrDirectiveProps, directiveAsts);
	        var isViewRoot = parent.isTemplateElement || hasInlineTemplates;
	        var providerContext = new provider_parser_1.ProviderElementContext(this.providerViewContext, parent.providerContext, isViewRoot, directiveAsts, attrs, references, element.sourceSpan);
	        var children = html_ast_1.htmlVisitAll(preparsedElement.nonBindable ? NON_BINDABLE_VISITOR : this, element.children, ElementContext.create(isTemplateElement, directiveAsts, isTemplateElement ? parent.providerContext : providerContext));
	        providerContext.afterElement();
	        // Override the actual selector when the `ngProjectAs` attribute is provided
	        var projectionSelector = lang_1.isPresent(preparsedElement.projectAs) ?
	            selector_1.CssSelector.parse(preparsedElement.projectAs)[0] :
	            elementCssSelector;
	        var ngContentIndex = parent.findNgContentIndex(projectionSelector);
	        var parsedElement;
	        if (preparsedElement.type === template_preparser_1.PreparsedElementType.NG_CONTENT) {
	            if (lang_1.isPresent(element.children) && element.children.length > 0) {
	                this._reportError("<ng-content> element cannot have content. <ng-content> must be immediately followed by </ng-content>", element.sourceSpan);
	            }
	            parsedElement = new template_ast_1.NgContentAst(this.ngContentCount++, hasInlineTemplates ? null : ngContentIndex, element.sourceSpan);
	        }
	        else if (isTemplateElement) {
	            this._assertAllEventsPublishedByDirectives(directiveAsts, events);
	            this._assertNoComponentsNorElementBindingsOnTemplate(directiveAsts, elementProps, element.sourceSpan);
	            parsedElement = new template_ast_1.EmbeddedTemplateAst(attrs, events, references, elementVars, providerContext.transformedDirectiveAsts, providerContext.transformProviders, providerContext.transformedHasViewContainer, children, hasInlineTemplates ? null : ngContentIndex, element.sourceSpan);
	        }
	        else {
	            this._assertOnlyOneComponent(directiveAsts, element.sourceSpan);
	            var ngContentIndex_1 = hasInlineTemplates ? null : parent.findNgContentIndex(projectionSelector);
	            parsedElement = new template_ast_1.ElementAst(nodeName, attrs, elementProps, events, references, providerContext.transformedDirectiveAsts, providerContext.transformProviders, providerContext.transformedHasViewContainer, children, hasInlineTemplates ? null : ngContentIndex_1, element.sourceSpan);
	        }
	        if (hasInlineTemplates) {
	            var templateCssSelector = createElementCssSelector(TEMPLATE_ELEMENT, templateMatchableAttrs);
	            var templateDirectiveMetas = this._parseDirectives(this.selectorMatcher, templateCssSelector);
	            var templateDirectiveAsts = this._createDirectiveAsts(true, element.name, templateDirectiveMetas, templateElementOrDirectiveProps, [], element.sourceSpan, []);
	            var templateElementProps = this._createElementPropertyAsts(element.name, templateElementOrDirectiveProps, templateDirectiveAsts);
	            this._assertNoComponentsNorElementBindingsOnTemplate(templateDirectiveAsts, templateElementProps, element.sourceSpan);
	            var templateProviderContext = new provider_parser_1.ProviderElementContext(this.providerViewContext, parent.providerContext, parent.isTemplateElement, templateDirectiveAsts, [], [], element.sourceSpan);
	            templateProviderContext.afterElement();
	            parsedElement = new template_ast_1.EmbeddedTemplateAst([], [], [], templateElementVars, templateProviderContext.transformedDirectiveAsts, templateProviderContext.transformProviders, templateProviderContext.transformedHasViewContainer, [parsedElement], ngContentIndex, element.sourceSpan);
	        }
	        return parsedElement;
	    };
	    TemplateParseVisitor.prototype._parseInlineTemplateBinding = function (attr, targetMatchableAttrs, targetProps, targetVars) {
	        var templateBindingsSource = null;
	        if (attr.name == TEMPLATE_ATTR) {
	            templateBindingsSource = attr.value;
	        }
	        else if (attr.name.startsWith(TEMPLATE_ATTR_PREFIX)) {
	            var key = attr.name.substring(TEMPLATE_ATTR_PREFIX.length); // remove the star
	            templateBindingsSource = (attr.value.length == 0) ? key : key + ' ' + attr.value;
	        }
	        if (lang_1.isPresent(templateBindingsSource)) {
	            var bindings = this._parseTemplateBindings(templateBindingsSource, attr.sourceSpan);
	            for (var i = 0; i < bindings.length; i++) {
	                var binding = bindings[i];
	                if (binding.keyIsVar) {
	                    targetVars.push(new template_ast_1.VariableAst(binding.key, binding.name, attr.sourceSpan));
	                }
	                else if (lang_1.isPresent(binding.expression)) {
	                    this._parsePropertyAst(binding.key, binding.expression, attr.sourceSpan, targetMatchableAttrs, targetProps);
	                }
	                else {
	                    targetMatchableAttrs.push([binding.key, '']);
	                    this._parseLiteralAttr(binding.key, null, attr.sourceSpan, targetProps);
	                }
	            }
	            return true;
	        }
	        return false;
	    };
	    TemplateParseVisitor.prototype._parseAttr = function (isTemplateElement, attr, targetMatchableAttrs, targetProps, targetEvents, targetRefs, targetVars) {
	        var attrName = this._normalizeAttributeName(attr.name);
	        var attrValue = attr.value;
	        var bindParts = lang_1.RegExpWrapper.firstMatch(BIND_NAME_REGEXP, attrName);
	        var hasBinding = false;
	        if (lang_1.isPresent(bindParts)) {
	            hasBinding = true;
	            if (lang_1.isPresent(bindParts[1])) {
	                this._parseProperty(bindParts[7], attrValue, attr.sourceSpan, targetMatchableAttrs, targetProps);
	            }
	            else if (lang_1.isPresent(bindParts[2])) {
	                var identifier = bindParts[7];
	                if (isTemplateElement) {
	                    this._reportError("\"var-\" on <template> elements is deprecated. Use \"let-\" instead!", attr.sourceSpan, parse_util_1.ParseErrorLevel.WARNING);
	                    this._parseVariable(identifier, attrValue, attr.sourceSpan, targetVars);
	                }
	                else {
	                    this._reportError("\"var-\" on non <template> elements is deprecated. Use \"ref-\" instead!", attr.sourceSpan, parse_util_1.ParseErrorLevel.WARNING);
	                    this._parseReference(identifier, attrValue, attr.sourceSpan, targetRefs);
	                }
	            }
	            else if (lang_1.isPresent(bindParts[3])) {
	                if (isTemplateElement) {
	                    var identifier = bindParts[7];
	                    this._parseVariable(identifier, attrValue, attr.sourceSpan, targetVars);
	                }
	                else {
	                    this._reportError("\"let-\" is only supported on template elements.", attr.sourceSpan);
	                }
	            }
	            else if (lang_1.isPresent(bindParts[4])) {
	                var identifier = bindParts[7];
	                this._parseReference(identifier, attrValue, attr.sourceSpan, targetRefs);
	            }
	            else if (lang_1.isPresent(bindParts[5])) {
	                this._parseEvent(bindParts[7], attrValue, attr.sourceSpan, targetMatchableAttrs, targetEvents);
	            }
	            else if (lang_1.isPresent(bindParts[6])) {
	                this._parseProperty(bindParts[7], attrValue, attr.sourceSpan, targetMatchableAttrs, targetProps);
	                this._parseAssignmentEvent(bindParts[7], attrValue, attr.sourceSpan, targetMatchableAttrs, targetEvents);
	            }
	            else if (lang_1.isPresent(bindParts[8])) {
	                this._parseProperty(bindParts[8], attrValue, attr.sourceSpan, targetMatchableAttrs, targetProps);
	                this._parseAssignmentEvent(bindParts[8], attrValue, attr.sourceSpan, targetMatchableAttrs, targetEvents);
	            }
	            else if (lang_1.isPresent(bindParts[9])) {
	                this._parseProperty(bindParts[9], attrValue, attr.sourceSpan, targetMatchableAttrs, targetProps);
	            }
	            else if (lang_1.isPresent(bindParts[10])) {
	                this._parseEvent(bindParts[10], attrValue, attr.sourceSpan, targetMatchableAttrs, targetEvents);
	            }
	        }
	        else {
	            hasBinding = this._parsePropertyInterpolation(attrName, attrValue, attr.sourceSpan, targetMatchableAttrs, targetProps);
	        }
	        if (!hasBinding) {
	            this._parseLiteralAttr(attrName, attrValue, attr.sourceSpan, targetProps);
	        }
	        return hasBinding;
	    };
	    TemplateParseVisitor.prototype._normalizeAttributeName = function (attrName) {
	        return attrName.toLowerCase().startsWith('data-') ? attrName.substring(5) : attrName;
	    };
	    TemplateParseVisitor.prototype._parseVariable = function (identifier, value, sourceSpan, targetVars) {
	        if (identifier.indexOf('-') > -1) {
	            this._reportError("\"-\" is not allowed in variable names", sourceSpan);
	        }
	        targetVars.push(new template_ast_1.VariableAst(identifier, value, sourceSpan));
	    };
	    TemplateParseVisitor.prototype._parseReference = function (identifier, value, sourceSpan, targetRefs) {
	        if (identifier.indexOf('-') > -1) {
	            this._reportError("\"-\" is not allowed in reference names", sourceSpan);
	        }
	        targetRefs.push(new ElementOrDirectiveRef(identifier, value, sourceSpan));
	    };
	    TemplateParseVisitor.prototype._parseProperty = function (name, expression, sourceSpan, targetMatchableAttrs, targetProps) {
	        this._parsePropertyAst(name, this._parseBinding(expression, sourceSpan), sourceSpan, targetMatchableAttrs, targetProps);
	    };
	    TemplateParseVisitor.prototype._parsePropertyInterpolation = function (name, value, sourceSpan, targetMatchableAttrs, targetProps) {
	        var expr = this._parseInterpolation(value, sourceSpan);
	        if (lang_1.isPresent(expr)) {
	            this._parsePropertyAst(name, expr, sourceSpan, targetMatchableAttrs, targetProps);
	            return true;
	        }
	        return false;
	    };
	    TemplateParseVisitor.prototype._parsePropertyAst = function (name, ast, sourceSpan, targetMatchableAttrs, targetProps) {
	        targetMatchableAttrs.push([name, ast.source]);
	        targetProps.push(new BoundElementOrDirectiveProperty(name, ast, false, sourceSpan));
	    };
	    TemplateParseVisitor.prototype._parseAssignmentEvent = function (name, expression, sourceSpan, targetMatchableAttrs, targetEvents) {
	        this._parseEvent(name + "Change", expression + "=$event", sourceSpan, targetMatchableAttrs, targetEvents);
	    };
	    TemplateParseVisitor.prototype._parseEvent = function (name, expression, sourceSpan, targetMatchableAttrs, targetEvents) {
	        // long format: 'target: eventName'
	        var parts = util_1.splitAtColon(name, [null, name]);
	        var target = parts[0];
	        var eventName = parts[1];
	        var ast = this._parseAction(expression, sourceSpan);
	        targetMatchableAttrs.push([name, ast.source]);
	        targetEvents.push(new template_ast_1.BoundEventAst(eventName, target, ast, sourceSpan));
	        // Don't detect directives for event names for now,
	        // so don't add the event name to the matchableAttrs
	    };
	    TemplateParseVisitor.prototype._parseLiteralAttr = function (name, value, sourceSpan, targetProps) {
	        targetProps.push(new BoundElementOrDirectiveProperty(name, this._exprParser.wrapLiteralPrimitive(value, ''), true, sourceSpan));
	    };
	    TemplateParseVisitor.prototype._parseDirectives = function (selectorMatcher, elementCssSelector) {
	        var _this = this;
	        // Need to sort the directives so that we get consistent results throughout,
	        // as selectorMatcher uses Maps inside.
	        // Also dedupe directives as they might match more than one time!
	        var directives = collection_1.ListWrapper.createFixedSize(this.directivesIndex.size);
	        selectorMatcher.match(elementCssSelector, function (selector, directive) {
	            directives[_this.directivesIndex.get(directive)] = directive;
	        });
	        return directives.filter(function (dir) { return lang_1.isPresent(dir); });
	    };
	    TemplateParseVisitor.prototype._createDirectiveAsts = function (isTemplateElement, elementName, directives, props, elementOrDirectiveRefs, sourceSpan, targetReferences) {
	        var _this = this;
	        var matchedReferences = new Set();
	        var component = null;
	        var directiveAsts = directives.map(function (directive) {
	            if (directive.isComponent) {
	                component = directive;
	            }
	            var hostProperties = [];
	            var hostEvents = [];
	            var directiveProperties = [];
	            _this._createDirectiveHostPropertyAsts(elementName, directive.hostProperties, sourceSpan, hostProperties);
	            _this._createDirectiveHostEventAsts(directive.hostListeners, sourceSpan, hostEvents);
	            _this._createDirectivePropertyAsts(directive.inputs, props, directiveProperties);
	            elementOrDirectiveRefs.forEach(function (elOrDirRef) {
	                if ((elOrDirRef.value.length === 0 && directive.isComponent) ||
	                    (directive.exportAs == elOrDirRef.value)) {
	                    targetReferences.push(new template_ast_1.ReferenceAst(elOrDirRef.name, identifiers_1.identifierToken(directive.type), elOrDirRef.sourceSpan));
	                    matchedReferences.add(elOrDirRef.name);
	                }
	            });
	            return new template_ast_1.DirectiveAst(directive, directiveProperties, hostProperties, hostEvents, sourceSpan);
	        });
	        elementOrDirectiveRefs.forEach(function (elOrDirRef) {
	            if (elOrDirRef.value.length > 0) {
	                if (!collection_1.SetWrapper.has(matchedReferences, elOrDirRef.name)) {
	                    _this._reportError("There is no directive with \"exportAs\" set to \"" + elOrDirRef.value + "\"", elOrDirRef.sourceSpan);
	                }
	                ;
	            }
	            else if (lang_1.isBlank(component)) {
	                var refToken = null;
	                if (isTemplateElement) {
	                    refToken = identifiers_1.identifierToken(identifiers_1.Identifiers.TemplateRef);
	                }
	                targetReferences.push(new template_ast_1.ReferenceAst(elOrDirRef.name, refToken, elOrDirRef.sourceSpan));
	            }
	        });
	        return directiveAsts;
	    };
	    TemplateParseVisitor.prototype._createDirectiveHostPropertyAsts = function (elementName, hostProps, sourceSpan, targetPropertyAsts) {
	        var _this = this;
	        if (lang_1.isPresent(hostProps)) {
	            collection_1.StringMapWrapper.forEach(hostProps, function (expression, propName) {
	                var exprAst = _this._parseBinding(expression, sourceSpan);
	                targetPropertyAsts.push(_this._createElementPropertyAst(elementName, propName, exprAst, sourceSpan));
	            });
	        }
	    };
	    TemplateParseVisitor.prototype._createDirectiveHostEventAsts = function (hostListeners, sourceSpan, targetEventAsts) {
	        var _this = this;
	        if (lang_1.isPresent(hostListeners)) {
	            collection_1.StringMapWrapper.forEach(hostListeners, function (expression, propName) {
	                _this._parseEvent(propName, expression, sourceSpan, [], targetEventAsts);
	            });
	        }
	    };
	    TemplateParseVisitor.prototype._createDirectivePropertyAsts = function (directiveProperties, boundProps, targetBoundDirectiveProps) {
	        if (lang_1.isPresent(directiveProperties)) {
	            var boundPropsByName = new Map();
	            boundProps.forEach(function (boundProp) {
	                var prevValue = boundPropsByName.get(boundProp.name);
	                if (lang_1.isBlank(prevValue) || prevValue.isLiteral) {
	                    // give [a]="b" a higher precedence than a="b" on the same element
	                    boundPropsByName.set(boundProp.name, boundProp);
	                }
	            });
	            collection_1.StringMapWrapper.forEach(directiveProperties, function (elProp, dirProp) {
	                var boundProp = boundPropsByName.get(elProp);
	                // Bindings are optional, so this binding only needs to be set up if an expression is given.
	                if (lang_1.isPresent(boundProp)) {
	                    targetBoundDirectiveProps.push(new template_ast_1.BoundDirectivePropertyAst(dirProp, boundProp.name, boundProp.expression, boundProp.sourceSpan));
	                }
	            });
	        }
	    };
	    TemplateParseVisitor.prototype._createElementPropertyAsts = function (elementName, props, directives) {
	        var _this = this;
	        var boundElementProps = [];
	        var boundDirectivePropsIndex = new Map();
	        directives.forEach(function (directive) {
	            directive.inputs.forEach(function (prop) {
	                boundDirectivePropsIndex.set(prop.templateName, prop);
	            });
	        });
	        props.forEach(function (prop) {
	            if (!prop.isLiteral && lang_1.isBlank(boundDirectivePropsIndex.get(prop.name))) {
	                boundElementProps.push(_this._createElementPropertyAst(elementName, prop.name, prop.expression, prop.sourceSpan));
	            }
	        });
	        return boundElementProps;
	    };
	    TemplateParseVisitor.prototype._createElementPropertyAst = function (elementName, name, ast, sourceSpan) {
	        var unit = null;
	        var bindingType;
	        var boundPropertyName;
	        var parts = name.split(PROPERTY_PARTS_SEPARATOR);
	        if (parts.length === 1) {
	            boundPropertyName = this._schemaRegistry.getMappedPropName(parts[0]);
	            bindingType = template_ast_1.PropertyBindingType.Property;
	            if (!this._schemaRegistry.hasProperty(elementName, boundPropertyName)) {
	                this._reportError("Can't bind to '" + boundPropertyName + "' since it isn't a known native property", sourceSpan);
	            }
	        }
	        else {
	            if (parts[0] == ATTRIBUTE_PREFIX) {
	                boundPropertyName = parts[1];
	                var nsSeparatorIdx = boundPropertyName.indexOf(':');
	                if (nsSeparatorIdx > -1) {
	                    var ns = boundPropertyName.substring(0, nsSeparatorIdx);
	                    var name_1 = boundPropertyName.substring(nsSeparatorIdx + 1);
	                    boundPropertyName = html_tags_1.mergeNsAndName(ns, name_1);
	                }
	                bindingType = template_ast_1.PropertyBindingType.Attribute;
	            }
	            else if (parts[0] == CLASS_PREFIX) {
	                boundPropertyName = parts[1];
	                bindingType = template_ast_1.PropertyBindingType.Class;
	            }
	            else if (parts[0] == STYLE_PREFIX) {
	                unit = parts.length > 2 ? parts[2] : null;
	                boundPropertyName = parts[1];
	                bindingType = template_ast_1.PropertyBindingType.Style;
	            }
	            else {
	                this._reportError("Invalid property name '" + name + "'", sourceSpan);
	                bindingType = null;
	            }
	        }
	        return new template_ast_1.BoundElementPropertyAst(boundPropertyName, bindingType, ast, unit, sourceSpan);
	    };
	    TemplateParseVisitor.prototype._findComponentDirectiveNames = function (directives) {
	        var componentTypeNames = [];
	        directives.forEach(function (directive) {
	            var typeName = directive.directive.type.name;
	            if (directive.directive.isComponent) {
	                componentTypeNames.push(typeName);
	            }
	        });
	        return componentTypeNames;
	    };
	    TemplateParseVisitor.prototype._assertOnlyOneComponent = function (directives, sourceSpan) {
	        var componentTypeNames = this._findComponentDirectiveNames(directives);
	        if (componentTypeNames.length > 1) {
	            this._reportError("More than one component: " + componentTypeNames.join(','), sourceSpan);
	        }
	    };
	    TemplateParseVisitor.prototype._assertNoComponentsNorElementBindingsOnTemplate = function (directives, elementProps, sourceSpan) {
	        var _this = this;
	        var componentTypeNames = this._findComponentDirectiveNames(directives);
	        if (componentTypeNames.length > 0) {
	            this._reportError("Components on an embedded template: " + componentTypeNames.join(','), sourceSpan);
	        }
	        elementProps.forEach(function (prop) {
	            _this._reportError("Property binding " + prop.name + " not used by any directive on an embedded template", sourceSpan);
	        });
	    };
	    TemplateParseVisitor.prototype._assertAllEventsPublishedByDirectives = function (directives, events) {
	        var _this = this;
	        var allDirectiveEvents = new Set();
	        directives.forEach(function (directive) {
	            collection_1.StringMapWrapper.forEach(directive.directive.outputs, function (eventName, _) { allDirectiveEvents.add(eventName); });
	        });
	        events.forEach(function (event) {
	            if (lang_1.isPresent(event.target) || !collection_1.SetWrapper.has(allDirectiveEvents, event.name)) {
	                _this._reportError("Event binding " + event.fullName + " not emitted by any directive on an embedded template", event.sourceSpan);
	            }
	        });
	    };
	    return TemplateParseVisitor;
	}());
	var NonBindableVisitor = (function () {
	    function NonBindableVisitor() {
	    }
	    NonBindableVisitor.prototype.visitElement = function (ast, parent) {
	        var preparsedElement = template_preparser_1.preparseElement(ast);
	        if (preparsedElement.type === template_preparser_1.PreparsedElementType.SCRIPT ||
	            preparsedElement.type === template_preparser_1.PreparsedElementType.STYLE ||
	            preparsedElement.type === template_preparser_1.PreparsedElementType.STYLESHEET) {
	            // Skipping <script> for security reasons
	            // Skipping <style> and stylesheets as we already processed them
	            // in the StyleCompiler
	            return null;
	        }
	        var attrNameAndValues = ast.attrs.map(function (attrAst) { return [attrAst.name, attrAst.value]; });
	        var selector = createElementCssSelector(ast.name, attrNameAndValues);
	        var ngContentIndex = parent.findNgContentIndex(selector);
	        var children = html_ast_1.htmlVisitAll(this, ast.children, EMPTY_ELEMENT_CONTEXT);
	        return new template_ast_1.ElementAst(ast.name, html_ast_1.htmlVisitAll(this, ast.attrs), [], [], [], [], [], false, children, ngContentIndex, ast.sourceSpan);
	    };
	    NonBindableVisitor.prototype.visitComment = function (ast, context) { return null; };
	    NonBindableVisitor.prototype.visitAttr = function (ast, context) {
	        return new template_ast_1.AttrAst(ast.name, ast.value, ast.sourceSpan);
	    };
	    NonBindableVisitor.prototype.visitText = function (ast, parent) {
	        var ngContentIndex = parent.findNgContentIndex(TEXT_CSS_SELECTOR);
	        return new template_ast_1.TextAst(ast.value, ngContentIndex, ast.sourceSpan);
	    };
	    NonBindableVisitor.prototype.visitExpansion = function (ast, context) { return ast; };
	    NonBindableVisitor.prototype.visitExpansionCase = function (ast, context) { return ast; };
	    return NonBindableVisitor;
	}());
	var BoundElementOrDirectiveProperty = (function () {
	    function BoundElementOrDirectiveProperty(name, expression, isLiteral, sourceSpan) {
	        this.name = name;
	        this.expression = expression;
	        this.isLiteral = isLiteral;
	        this.sourceSpan = sourceSpan;
	    }
	    return BoundElementOrDirectiveProperty;
	}());
	var ElementOrDirectiveRef = (function () {
	    function ElementOrDirectiveRef(name, value, sourceSpan) {
	        this.name = name;
	        this.value = value;
	        this.sourceSpan = sourceSpan;
	    }
	    return ElementOrDirectiveRef;
	}());
	function splitClasses(classAttrValue) {
	    return lang_1.StringWrapper.split(classAttrValue.trim(), /\s+/g);
	}
	exports.splitClasses = splitClasses;
	var ElementContext = (function () {
	    function ElementContext(isTemplateElement, _ngContentIndexMatcher, _wildcardNgContentIndex, providerContext) {
	        this.isTemplateElement = isTemplateElement;
	        this._ngContentIndexMatcher = _ngContentIndexMatcher;
	        this._wildcardNgContentIndex = _wildcardNgContentIndex;
	        this.providerContext = providerContext;
	    }
	    ElementContext.create = function (isTemplateElement, directives, providerContext) {
	        var matcher = new selector_1.SelectorMatcher();
	        var wildcardNgContentIndex = null;
	        var component = directives.find(function (directive) { return directive.directive.isComponent; });
	        if (lang_1.isPresent(component)) {
	            var ngContentSelectors = component.directive.template.ngContentSelectors;
	            for (var i = 0; i < ngContentSelectors.length; i++) {
	                var selector = ngContentSelectors[i];
	                if (lang_1.StringWrapper.equals(selector, '*')) {
	                    wildcardNgContentIndex = i;
	                }
	                else {
	                    matcher.addSelectables(selector_1.CssSelector.parse(ngContentSelectors[i]), i);
	                }
	            }
	        }
	        return new ElementContext(isTemplateElement, matcher, wildcardNgContentIndex, providerContext);
	    };
	    ElementContext.prototype.findNgContentIndex = function (selector) {
	        var ngContentIndices = [];
	        this._ngContentIndexMatcher.match(selector, function (selector, ngContentIndex) { ngContentIndices.push(ngContentIndex); });
	        collection_1.ListWrapper.sort(ngContentIndices);
	        if (lang_1.isPresent(this._wildcardNgContentIndex)) {
	            ngContentIndices.push(this._wildcardNgContentIndex);
	        }
	        return ngContentIndices.length > 0 ? ngContentIndices[0] : null;
	    };
	    return ElementContext;
	}());
	function createElementCssSelector(elementName, matchableAttrs) {
	    var cssSelector = new selector_1.CssSelector();
	    var elNameNoNs = html_tags_1.splitNsName(elementName)[1];
	    cssSelector.setElement(elNameNoNs);
	    for (var i = 0; i < matchableAttrs.length; i++) {
	        var attrName = matchableAttrs[i][0];
	        var attrNameNoNs = html_tags_1.splitNsName(attrName)[1];
	        var attrValue = matchableAttrs[i][1];
	        cssSelector.addAttribute(attrNameNoNs, attrValue);
	        if (attrName.toLowerCase() == CLASS_ATTR) {
	            var classes = splitClasses(attrValue);
	            classes.forEach(function (className) { return cssSelector.addClassName(className); });
	        }
	    }
	    return cssSelector;
	}
	var EMPTY_ELEMENT_CONTEXT = new ElementContext(true, new selector_1.SelectorMatcher(), null, null);
	var NON_BINDABLE_VISITOR = new NonBindableVisitor();
	var PipeCollector = (function (_super) {
	    __extends(PipeCollector, _super);
	    function PipeCollector() {
	        _super.apply(this, arguments);
	        this.pipes = new Set();
	    }
	    PipeCollector.prototype.visitPipe = function (ast, context) {
	        this.pipes.add(ast.name);
	        ast.exp.visit(this);
	        this.visitAll(ast.args, context);
	        return null;
	    };
	    return PipeCollector;
	}(ast_1.RecursiveAstVisitor));
	exports.PipeCollector = PipeCollector;
	function removeDuplicates(items) {
	    var res = [];
	    items.forEach(function (item) {
	        var hasMatch = res.filter(function (r) { return r.type.name == item.type.name && r.type.moduleUrl == item.type.moduleUrl &&
	            r.type.runtime == item.type.runtime; })
	            .length > 0;
	        if (!hasMatch) {
	            res.push(item);
	        }
	    });
	    return res;
	}


/***/ },
/* 143 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var collection_1 = __webpack_require__(15);
	var AST = (function () {
	    function AST() {
	    }
	    AST.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return null;
	    };
	    AST.prototype.toString = function () { return "AST"; };
	    return AST;
	}());
	exports.AST = AST;
	/**
	 * Represents a quoted expression of the form:
	 *
	 * quote = prefix `:` uninterpretedExpression
	 * prefix = identifier
	 * uninterpretedExpression = arbitrary string
	 *
	 * A quoted expression is meant to be pre-processed by an AST transformer that
	 * converts it into another AST that no longer contains quoted expressions.
	 * It is meant to allow third-party developers to extend Angular template
	 * expression language. The `uninterpretedExpression` part of the quote is
	 * therefore not interpreted by the Angular's own expression parser.
	 */
	var Quote = (function (_super) {
	    __extends(Quote, _super);
	    function Quote(prefix, uninterpretedExpression, location) {
	        _super.call(this);
	        this.prefix = prefix;
	        this.uninterpretedExpression = uninterpretedExpression;
	        this.location = location;
	    }
	    Quote.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitQuote(this, context);
	    };
	    Quote.prototype.toString = function () { return "Quote"; };
	    return Quote;
	}(AST));
	exports.Quote = Quote;
	var EmptyExpr = (function (_super) {
	    __extends(EmptyExpr, _super);
	    function EmptyExpr() {
	        _super.apply(this, arguments);
	    }
	    EmptyExpr.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        // do nothing
	    };
	    return EmptyExpr;
	}(AST));
	exports.EmptyExpr = EmptyExpr;
	var ImplicitReceiver = (function (_super) {
	    __extends(ImplicitReceiver, _super);
	    function ImplicitReceiver() {
	        _super.apply(this, arguments);
	    }
	    ImplicitReceiver.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitImplicitReceiver(this, context);
	    };
	    return ImplicitReceiver;
	}(AST));
	exports.ImplicitReceiver = ImplicitReceiver;
	/**
	 * Multiple expressions separated by a semicolon.
	 */
	var Chain = (function (_super) {
	    __extends(Chain, _super);
	    function Chain(expressions) {
	        _super.call(this);
	        this.expressions = expressions;
	    }
	    Chain.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitChain(this, context);
	    };
	    return Chain;
	}(AST));
	exports.Chain = Chain;
	var Conditional = (function (_super) {
	    __extends(Conditional, _super);
	    function Conditional(condition, trueExp, falseExp) {
	        _super.call(this);
	        this.condition = condition;
	        this.trueExp = trueExp;
	        this.falseExp = falseExp;
	    }
	    Conditional.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitConditional(this, context);
	    };
	    return Conditional;
	}(AST));
	exports.Conditional = Conditional;
	var PropertyRead = (function (_super) {
	    __extends(PropertyRead, _super);
	    function PropertyRead(receiver, name) {
	        _super.call(this);
	        this.receiver = receiver;
	        this.name = name;
	    }
	    PropertyRead.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitPropertyRead(this, context);
	    };
	    return PropertyRead;
	}(AST));
	exports.PropertyRead = PropertyRead;
	var PropertyWrite = (function (_super) {
	    __extends(PropertyWrite, _super);
	    function PropertyWrite(receiver, name, value) {
	        _super.call(this);
	        this.receiver = receiver;
	        this.name = name;
	        this.value = value;
	    }
	    PropertyWrite.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitPropertyWrite(this, context);
	    };
	    return PropertyWrite;
	}(AST));
	exports.PropertyWrite = PropertyWrite;
	var SafePropertyRead = (function (_super) {
	    __extends(SafePropertyRead, _super);
	    function SafePropertyRead(receiver, name) {
	        _super.call(this);
	        this.receiver = receiver;
	        this.name = name;
	    }
	    SafePropertyRead.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitSafePropertyRead(this, context);
	    };
	    return SafePropertyRead;
	}(AST));
	exports.SafePropertyRead = SafePropertyRead;
	var KeyedRead = (function (_super) {
	    __extends(KeyedRead, _super);
	    function KeyedRead(obj, key) {
	        _super.call(this);
	        this.obj = obj;
	        this.key = key;
	    }
	    KeyedRead.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitKeyedRead(this, context);
	    };
	    return KeyedRead;
	}(AST));
	exports.KeyedRead = KeyedRead;
	var KeyedWrite = (function (_super) {
	    __extends(KeyedWrite, _super);
	    function KeyedWrite(obj, key, value) {
	        _super.call(this);
	        this.obj = obj;
	        this.key = key;
	        this.value = value;
	    }
	    KeyedWrite.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitKeyedWrite(this, context);
	    };
	    return KeyedWrite;
	}(AST));
	exports.KeyedWrite = KeyedWrite;
	var BindingPipe = (function (_super) {
	    __extends(BindingPipe, _super);
	    function BindingPipe(exp, name, args) {
	        _super.call(this);
	        this.exp = exp;
	        this.name = name;
	        this.args = args;
	    }
	    BindingPipe.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitPipe(this, context);
	    };
	    return BindingPipe;
	}(AST));
	exports.BindingPipe = BindingPipe;
	var LiteralPrimitive = (function (_super) {
	    __extends(LiteralPrimitive, _super);
	    function LiteralPrimitive(value) {
	        _super.call(this);
	        this.value = value;
	    }
	    LiteralPrimitive.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitLiteralPrimitive(this, context);
	    };
	    return LiteralPrimitive;
	}(AST));
	exports.LiteralPrimitive = LiteralPrimitive;
	var LiteralArray = (function (_super) {
	    __extends(LiteralArray, _super);
	    function LiteralArray(expressions) {
	        _super.call(this);
	        this.expressions = expressions;
	    }
	    LiteralArray.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitLiteralArray(this, context);
	    };
	    return LiteralArray;
	}(AST));
	exports.LiteralArray = LiteralArray;
	var LiteralMap = (function (_super) {
	    __extends(LiteralMap, _super);
	    function LiteralMap(keys, values) {
	        _super.call(this);
	        this.keys = keys;
	        this.values = values;
	    }
	    LiteralMap.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitLiteralMap(this, context);
	    };
	    return LiteralMap;
	}(AST));
	exports.LiteralMap = LiteralMap;
	var Interpolation = (function (_super) {
	    __extends(Interpolation, _super);
	    function Interpolation(strings, expressions) {
	        _super.call(this);
	        this.strings = strings;
	        this.expressions = expressions;
	    }
	    Interpolation.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitInterpolation(this, context);
	    };
	    return Interpolation;
	}(AST));
	exports.Interpolation = Interpolation;
	var Binary = (function (_super) {
	    __extends(Binary, _super);
	    function Binary(operation, left, right) {
	        _super.call(this);
	        this.operation = operation;
	        this.left = left;
	        this.right = right;
	    }
	    Binary.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitBinary(this, context);
	    };
	    return Binary;
	}(AST));
	exports.Binary = Binary;
	var PrefixNot = (function (_super) {
	    __extends(PrefixNot, _super);
	    function PrefixNot(expression) {
	        _super.call(this);
	        this.expression = expression;
	    }
	    PrefixNot.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitPrefixNot(this, context);
	    };
	    return PrefixNot;
	}(AST));
	exports.PrefixNot = PrefixNot;
	var MethodCall = (function (_super) {
	    __extends(MethodCall, _super);
	    function MethodCall(receiver, name, args) {
	        _super.call(this);
	        this.receiver = receiver;
	        this.name = name;
	        this.args = args;
	    }
	    MethodCall.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitMethodCall(this, context);
	    };
	    return MethodCall;
	}(AST));
	exports.MethodCall = MethodCall;
	var SafeMethodCall = (function (_super) {
	    __extends(SafeMethodCall, _super);
	    function SafeMethodCall(receiver, name, args) {
	        _super.call(this);
	        this.receiver = receiver;
	        this.name = name;
	        this.args = args;
	    }
	    SafeMethodCall.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitSafeMethodCall(this, context);
	    };
	    return SafeMethodCall;
	}(AST));
	exports.SafeMethodCall = SafeMethodCall;
	var FunctionCall = (function (_super) {
	    __extends(FunctionCall, _super);
	    function FunctionCall(target, args) {
	        _super.call(this);
	        this.target = target;
	        this.args = args;
	    }
	    FunctionCall.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return visitor.visitFunctionCall(this, context);
	    };
	    return FunctionCall;
	}(AST));
	exports.FunctionCall = FunctionCall;
	var ASTWithSource = (function (_super) {
	    __extends(ASTWithSource, _super);
	    function ASTWithSource(ast, source, location) {
	        _super.call(this);
	        this.ast = ast;
	        this.source = source;
	        this.location = location;
	    }
	    ASTWithSource.prototype.visit = function (visitor, context) {
	        if (context === void 0) { context = null; }
	        return this.ast.visit(visitor, context);
	    };
	    ASTWithSource.prototype.toString = function () { return this.source + " in " + this.location; };
	    return ASTWithSource;
	}(AST));
	exports.ASTWithSource = ASTWithSource;
	var TemplateBinding = (function () {
	    function TemplateBinding(key, keyIsVar, name, expression) {
	        this.key = key;
	        this.keyIsVar = keyIsVar;
	        this.name = name;
	        this.expression = expression;
	    }
	    return TemplateBinding;
	}());
	exports.TemplateBinding = TemplateBinding;
	var RecursiveAstVisitor = (function () {
	    function RecursiveAstVisitor() {
	    }
	    RecursiveAstVisitor.prototype.visitBinary = function (ast, context) {
	        ast.left.visit(this);
	        ast.right.visit(this);
	        return null;
	    };
	    RecursiveAstVisitor.prototype.visitChain = function (ast, context) { return this.visitAll(ast.expressions, context); };
	    RecursiveAstVisitor.prototype.visitConditional = function (ast, context) {
	        ast.condition.visit(this);
	        ast.trueExp.visit(this);
	        ast.falseExp.visit(this);
	        return null;
	    };
	    RecursiveAstVisitor.prototype.visitPipe = function (ast, context) {
	        ast.exp.visit(this);
	        this.visitAll(ast.args, context);
	        return null;
	    };
	    RecursiveAstVisitor.prototype.visitFunctionCall = function (ast, context) {
	        ast.target.visit(this);
	        this.visitAll(ast.args, context);
	        return null;
	    };
	    RecursiveAstVisitor.prototype.visitImplicitReceiver = function (ast, context) { return null; };
	    RecursiveAstVisitor.prototype.visitInterpolation = function (ast, context) {
	        return this.visitAll(ast.expressions, context);
	    };
	    RecursiveAstVisitor.prototype.visitKeyedRead = function (ast, context) {
	        ast.obj.visit(this);
	        ast.key.visit(this);
	        return null;
	    };
	    RecursiveAstVisitor.prototype.visitKeyedWrite = function (ast, context) {
	        ast.obj.visit(this);
	        ast.key.visit(this);
	        ast.value.visit(this);
	        return null;
	    };
	    RecursiveAstVisitor.prototype.visitLiteralArray = function (ast, context) {
	        return this.visitAll(ast.expressions, context);
	    };
	    RecursiveAstVisitor.prototype.visitLiteralMap = function (ast, context) { return this.visitAll(ast.values, context); };
	    RecursiveAstVisitor.prototype.visitLiteralPrimitive = function (ast, context) { return null; };
	    RecursiveAstVisitor.prototype.visitMethodCall = function (ast, context) {
	        ast.receiver.visit(this);
	        return this.visitAll(ast.args, context);
	    };
	    RecursiveAstVisitor.prototype.visitPrefixNot = function (ast, context) {
	        ast.expression.visit(this);
	        return null;
	    };
	    RecursiveAstVisitor.prototype.visitPropertyRead = function (ast, context) {
	        ast.receiver.visit(this);
	        return null;
	    };
	    RecursiveAstVisitor.prototype.visitPropertyWrite = function (ast, context) {
	        ast.receiver.visit(this);
	        ast.value.visit(this);
	        return null;
	    };
	    RecursiveAstVisitor.prototype.visitSafePropertyRead = function (ast, context) {
	        ast.receiver.visit(this);
	        return null;
	    };
	    RecursiveAstVisitor.prototype.visitSafeMethodCall = function (ast, context) {
	        ast.receiver.visit(this);
	        return this.visitAll(ast.args, context);
	    };
	    RecursiveAstVisitor.prototype.visitAll = function (asts, context) {
	        var _this = this;
	        asts.forEach(function (ast) { return ast.visit(_this, context); });
	        return null;
	    };
	    RecursiveAstVisitor.prototype.visitQuote = function (ast, context) { return null; };
	    return RecursiveAstVisitor;
	}());
	exports.RecursiveAstVisitor = RecursiveAstVisitor;
	var AstTransformer = (function () {
	    function AstTransformer() {
	    }
	    AstTransformer.prototype.visitImplicitReceiver = function (ast, context) { return ast; };
	    AstTransformer.prototype.visitInterpolation = function (ast, context) {
	        return new Interpolation(ast.strings, this.visitAll(ast.expressions));
	    };
	    AstTransformer.prototype.visitLiteralPrimitive = function (ast, context) {
	        return new LiteralPrimitive(ast.value);
	    };
	    AstTransformer.prototype.visitPropertyRead = function (ast, context) {
	        return new PropertyRead(ast.receiver.visit(this), ast.name);
	    };
	    AstTransformer.prototype.visitPropertyWrite = function (ast, context) {
	        return new PropertyWrite(ast.receiver.visit(this), ast.name, ast.value);
	    };
	    AstTransformer.prototype.visitSafePropertyRead = function (ast, context) {
	        return new SafePropertyRead(ast.receiver.visit(this), ast.name);
	    };
	    AstTransformer.prototype.visitMethodCall = function (ast, context) {
	        return new MethodCall(ast.receiver.visit(this), ast.name, this.visitAll(ast.args));
	    };
	    AstTransformer.prototype.visitSafeMethodCall = function (ast, context) {
	        return new SafeMethodCall(ast.receiver.visit(this), ast.name, this.visitAll(ast.args));
	    };
	    AstTransformer.prototype.visitFunctionCall = function (ast, context) {
	        return new FunctionCall(ast.target.visit(this), this.visitAll(ast.args));
	    };
	    AstTransformer.prototype.visitLiteralArray = function (ast, context) {
	        return new LiteralArray(this.visitAll(ast.expressions));
	    };
	    AstTransformer.prototype.visitLiteralMap = function (ast, context) {
	        return new LiteralMap(ast.keys, this.visitAll(ast.values));
	    };
	    AstTransformer.prototype.visitBinary = function (ast, context) {
	        return new Binary(ast.operation, ast.left.visit(this), ast.right.visit(this));
	    };
	    AstTransformer.prototype.visitPrefixNot = function (ast, context) {
	        return new PrefixNot(ast.expression.visit(this));
	    };
	    AstTransformer.prototype.visitConditional = function (ast, context) {
	        return new Conditional(ast.condition.visit(this), ast.trueExp.visit(this), ast.falseExp.visit(this));
	    };
	    AstTransformer.prototype.visitPipe = function (ast, context) {
	        return new BindingPipe(ast.exp.visit(this), ast.name, this.visitAll(ast.args));
	    };
	    AstTransformer.prototype.visitKeyedRead = function (ast, context) {
	        return new KeyedRead(ast.obj.visit(this), ast.key.visit(this));
	    };
	    AstTransformer.prototype.visitKeyedWrite = function (ast, context) {
	        return new KeyedWrite(ast.obj.visit(this), ast.key.visit(this), ast.value.visit(this));
	    };
	    AstTransformer.prototype.visitAll = function (asts) {
	        var res = collection_1.ListWrapper.createFixedSize(asts.length);
	        for (var i = 0; i < asts.length; ++i) {
	            res[i] = asts[i].visit(this);
	        }
	        return res;
	    };
	    AstTransformer.prototype.visitChain = function (ast, context) { return new Chain(this.visitAll(ast.expressions)); };
	    AstTransformer.prototype.visitQuote = function (ast, context) {
	        return new Quote(ast.prefix, ast.uninterpretedExpression, ast.location);
	    };
	    return AstTransformer;
	}());
	exports.AstTransformer = AstTransformer;


/***/ },
/* 144 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var decorators_1 = __webpack_require__(8);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var collection_1 = __webpack_require__(15);
	var lexer_1 = __webpack_require__(145);
	var ast_1 = __webpack_require__(143);
	var _implicitReceiver = new ast_1.ImplicitReceiver();
	// TODO(tbosch): Cannot make this const/final right now because of the transpiler...
	var INTERPOLATION_REGEXP = /\{\{([\s\S]*?)\}\}/g;
	var ParseException = (function (_super) {
	    __extends(ParseException, _super);
	    function ParseException(message, input, errLocation, ctxLocation) {
	        _super.call(this, "Parser Error: " + message + " " + errLocation + " [" + input + "] in " + ctxLocation);
	    }
	    return ParseException;
	}(exceptions_1.BaseException));
	var SplitInterpolation = (function () {
	    function SplitInterpolation(strings, expressions) {
	        this.strings = strings;
	        this.expressions = expressions;
	    }
	    return SplitInterpolation;
	}());
	exports.SplitInterpolation = SplitInterpolation;
	var TemplateBindingParseResult = (function () {
	    function TemplateBindingParseResult(templateBindings, warnings) {
	        this.templateBindings = templateBindings;
	        this.warnings = warnings;
	    }
	    return TemplateBindingParseResult;
	}());
	exports.TemplateBindingParseResult = TemplateBindingParseResult;
	var Parser = (function () {
	    function Parser(/** @internal */ _lexer) {
	        this._lexer = _lexer;
	    }
	    Parser.prototype.parseAction = function (input, location) {
	        this._checkNoInterpolation(input, location);
	        var tokens = this._lexer.tokenize(this._stripComments(input));
	        var ast = new _ParseAST(input, location, tokens, true).parseChain();
	        return new ast_1.ASTWithSource(ast, input, location);
	    };
	    Parser.prototype.parseBinding = function (input, location) {
	        var ast = this._parseBindingAst(input, location);
	        return new ast_1.ASTWithSource(ast, input, location);
	    };
	    Parser.prototype.parseSimpleBinding = function (input, location) {
	        var ast = this._parseBindingAst(input, location);
	        if (!SimpleExpressionChecker.check(ast)) {
	            throw new ParseException('Host binding expression can only contain field access and constants', input, location);
	        }
	        return new ast_1.ASTWithSource(ast, input, location);
	    };
	    Parser.prototype._parseBindingAst = function (input, location) {
	        // Quotes expressions use 3rd-party expression language. We don't want to use
	        // our lexer or parser for that, so we check for that ahead of time.
	        var quote = this._parseQuote(input, location);
	        if (lang_1.isPresent(quote)) {
	            return quote;
	        }
	        this._checkNoInterpolation(input, location);
	        var tokens = this._lexer.tokenize(this._stripComments(input));
	        return new _ParseAST(input, location, tokens, false).parseChain();
	    };
	    Parser.prototype._parseQuote = function (input, location) {
	        if (lang_1.isBlank(input))
	            return null;
	        var prefixSeparatorIndex = input.indexOf(':');
	        if (prefixSeparatorIndex == -1)
	            return null;
	        var prefix = input.substring(0, prefixSeparatorIndex).trim();
	        if (!lexer_1.isIdentifier(prefix))
	            return null;
	        var uninterpretedExpression = input.substring(prefixSeparatorIndex + 1);
	        return new ast_1.Quote(prefix, uninterpretedExpression, location);
	    };
	    Parser.prototype.parseTemplateBindings = function (input, location) {
	        var tokens = this._lexer.tokenize(input);
	        return new _ParseAST(input, location, tokens, false).parseTemplateBindings();
	    };
	    Parser.prototype.parseInterpolation = function (input, location) {
	        var split = this.splitInterpolation(input, location);
	        if (split == null)
	            return null;
	        var expressions = [];
	        for (var i = 0; i < split.expressions.length; ++i) {
	            var tokens = this._lexer.tokenize(this._stripComments(split.expressions[i]));
	            var ast = new _ParseAST(input, location, tokens, false).parseChain();
	            expressions.push(ast);
	        }
	        return new ast_1.ASTWithSource(new ast_1.Interpolation(split.strings, expressions), input, location);
	    };
	    Parser.prototype.splitInterpolation = function (input, location) {
	        var parts = lang_1.StringWrapper.split(input, INTERPOLATION_REGEXP);
	        if (parts.length <= 1) {
	            return null;
	        }
	        var strings = [];
	        var expressions = [];
	        for (var i = 0; i < parts.length; i++) {
	            var part = parts[i];
	            if (i % 2 === 0) {
	                // fixed string
	                strings.push(part);
	            }
	            else if (part.trim().length > 0) {
	                expressions.push(part);
	            }
	            else {
	                throw new ParseException('Blank expressions are not allowed in interpolated strings', input, "at column " + this._findInterpolationErrorColumn(parts, i) + " in", location);
	            }
	        }
	        return new SplitInterpolation(strings, expressions);
	    };
	    Parser.prototype.wrapLiteralPrimitive = function (input, location) {
	        return new ast_1.ASTWithSource(new ast_1.LiteralPrimitive(input), input, location);
	    };
	    Parser.prototype._stripComments = function (input) {
	        var i = this._commentStart(input);
	        return lang_1.isPresent(i) ? input.substring(0, i).trim() : input;
	    };
	    Parser.prototype._commentStart = function (input) {
	        var outerQuote = null;
	        for (var i = 0; i < input.length - 1; i++) {
	            var char = lang_1.StringWrapper.charCodeAt(input, i);
	            var nextChar = lang_1.StringWrapper.charCodeAt(input, i + 1);
	            if (char === lexer_1.$SLASH && nextChar == lexer_1.$SLASH && lang_1.isBlank(outerQuote))
	                return i;
	            if (outerQuote === char) {
	                outerQuote = null;
	            }
	            else if (lang_1.isBlank(outerQuote) && lexer_1.isQuote(char)) {
	                outerQuote = char;
	            }
	        }
	        return null;
	    };
	    Parser.prototype._checkNoInterpolation = function (input, location) {
	        var parts = lang_1.StringWrapper.split(input, INTERPOLATION_REGEXP);
	        if (parts.length > 1) {
	            throw new ParseException('Got interpolation ({{}}) where expression was expected', input, "at column " + this._findInterpolationErrorColumn(parts, 1) + " in", location);
	        }
	    };
	    Parser.prototype._findInterpolationErrorColumn = function (parts, partInErrIdx) {
	        var errLocation = '';
	        for (var j = 0; j < partInErrIdx; j++) {
	            errLocation += j % 2 === 0 ? parts[j] : "{{" + parts[j] + "}}";
	        }
	        return errLocation.length;
	    };
	    Parser = __decorate([
	        decorators_1.Injectable(), 
	        __metadata('design:paramtypes', [lexer_1.Lexer])
	    ], Parser);
	    return Parser;
	}());
	exports.Parser = Parser;
	var _ParseAST = (function () {
	    function _ParseAST(input, location, tokens, parseAction) {
	        this.input = input;
	        this.location = location;
	        this.tokens = tokens;
	        this.parseAction = parseAction;
	        this.index = 0;
	    }
	    _ParseAST.prototype.peek = function (offset) {
	        var i = this.index + offset;
	        return i < this.tokens.length ? this.tokens[i] : lexer_1.EOF;
	    };
	    Object.defineProperty(_ParseAST.prototype, "next", {
	        get: function () { return this.peek(0); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(_ParseAST.prototype, "inputIndex", {
	        get: function () {
	            return (this.index < this.tokens.length) ? this.next.index : this.input.length;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    _ParseAST.prototype.advance = function () { this.index++; };
	    _ParseAST.prototype.optionalCharacter = function (code) {
	        if (this.next.isCharacter(code)) {
	            this.advance();
	            return true;
	        }
	        else {
	            return false;
	        }
	    };
	    _ParseAST.prototype.peekKeywordLet = function () { return this.next.isKeywordLet(); };
	    _ParseAST.prototype.peekDeprecatedKeywordVar = function () { return this.next.isKeywordDeprecatedVar(); };
	    _ParseAST.prototype.peekDeprecatedOperatorHash = function () { return this.next.isOperator('#'); };
	    _ParseAST.prototype.expectCharacter = function (code) {
	        if (this.optionalCharacter(code))
	            return;
	        this.error("Missing expected " + lang_1.StringWrapper.fromCharCode(code));
	    };
	    _ParseAST.prototype.optionalOperator = function (op) {
	        if (this.next.isOperator(op)) {
	            this.advance();
	            return true;
	        }
	        else {
	            return false;
	        }
	    };
	    _ParseAST.prototype.expectOperator = function (operator) {
	        if (this.optionalOperator(operator))
	            return;
	        this.error("Missing expected operator " + operator);
	    };
	    _ParseAST.prototype.expectIdentifierOrKeyword = function () {
	        var n = this.next;
	        if (!n.isIdentifier() && !n.isKeyword()) {
	            this.error("Unexpected token " + n + ", expected identifier or keyword");
	        }
	        this.advance();
	        return n.toString();
	    };
	    _ParseAST.prototype.expectIdentifierOrKeywordOrString = function () {
	        var n = this.next;
	        if (!n.isIdentifier() && !n.isKeyword() && !n.isString()) {
	            this.error("Unexpected token " + n + ", expected identifier, keyword, or string");
	        }
	        this.advance();
	        return n.toString();
	    };
	    _ParseAST.prototype.parseChain = function () {
	        var exprs = [];
	        while (this.index < this.tokens.length) {
	            var expr = this.parsePipe();
	            exprs.push(expr);
	            if (this.optionalCharacter(lexer_1.$SEMICOLON)) {
	                if (!this.parseAction) {
	                    this.error("Binding expression cannot contain chained expression");
	                }
	                while (this.optionalCharacter(lexer_1.$SEMICOLON)) {
	                } // read all semicolons
	            }
	            else if (this.index < this.tokens.length) {
	                this.error("Unexpected token '" + this.next + "'");
	            }
	        }
	        if (exprs.length == 0)
	            return new ast_1.EmptyExpr();
	        if (exprs.length == 1)
	            return exprs[0];
	        return new ast_1.Chain(exprs);
	    };
	    _ParseAST.prototype.parsePipe = function () {
	        var result = this.parseExpression();
	        if (this.optionalOperator("|")) {
	            if (this.parseAction) {
	                this.error("Cannot have a pipe in an action expression");
	            }
	            do {
	                var name = this.expectIdentifierOrKeyword();
	                var args = [];
	                while (this.optionalCharacter(lexer_1.$COLON)) {
	                    args.push(this.parseExpression());
	                }
	                result = new ast_1.BindingPipe(result, name, args);
	            } while (this.optionalOperator("|"));
	        }
	        return result;
	    };
	    _ParseAST.prototype.parseExpression = function () { return this.parseConditional(); };
	    _ParseAST.prototype.parseConditional = function () {
	        var start = this.inputIndex;
	        var result = this.parseLogicalOr();
	        if (this.optionalOperator('?')) {
	            var yes = this.parsePipe();
	            if (!this.optionalCharacter(lexer_1.$COLON)) {
	                var end = this.inputIndex;
	                var expression = this.input.substring(start, end);
	                this.error("Conditional expression " + expression + " requires all 3 expressions");
	            }
	            var no = this.parsePipe();
	            return new ast_1.Conditional(result, yes, no);
	        }
	        else {
	            return result;
	        }
	    };
	    _ParseAST.prototype.parseLogicalOr = function () {
	        // '||'
	        var result = this.parseLogicalAnd();
	        while (this.optionalOperator('||')) {
	            result = new ast_1.Binary('||', result, this.parseLogicalAnd());
	        }
	        return result;
	    };
	    _ParseAST.prototype.parseLogicalAnd = function () {
	        // '&&'
	        var result = this.parseEquality();
	        while (this.optionalOperator('&&')) {
	            result = new ast_1.Binary('&&', result, this.parseEquality());
	        }
	        return result;
	    };
	    _ParseAST.prototype.parseEquality = function () {
	        // '==','!=','===','!=='
	        var result = this.parseRelational();
	        while (true) {
	            if (this.optionalOperator('==')) {
	                result = new ast_1.Binary('==', result, this.parseRelational());
	            }
	            else if (this.optionalOperator('===')) {
	                result = new ast_1.Binary('===', result, this.parseRelational());
	            }
	            else if (this.optionalOperator('!=')) {
	                result = new ast_1.Binary('!=', result, this.parseRelational());
	            }
	            else if (this.optionalOperator('!==')) {
	                result = new ast_1.Binary('!==', result, this.parseRelational());
	            }
	            else {
	                return result;
	            }
	        }
	    };
	    _ParseAST.prototype.parseRelational = function () {
	        // '<', '>', '<=', '>='
	        var result = this.parseAdditive();
	        while (true) {
	            if (this.optionalOperator('<')) {
	                result = new ast_1.Binary('<', result, this.parseAdditive());
	            }
	            else if (this.optionalOperator('>')) {
	                result = new ast_1.Binary('>', result, this.parseAdditive());
	            }
	            else if (this.optionalOperator('<=')) {
	                result = new ast_1.Binary('<=', result, this.parseAdditive());
	            }
	            else if (this.optionalOperator('>=')) {
	                result = new ast_1.Binary('>=', result, this.parseAdditive());
	            }
	            else {
	                return result;
	            }
	        }
	    };
	    _ParseAST.prototype.parseAdditive = function () {
	        // '+', '-'
	        var result = this.parseMultiplicative();
	        while (true) {
	            if (this.optionalOperator('+')) {
	                result = new ast_1.Binary('+', result, this.parseMultiplicative());
	            }
	            else if (this.optionalOperator('-')) {
	                result = new ast_1.Binary('-', result, this.parseMultiplicative());
	            }
	            else {
	                return result;
	            }
	        }
	    };
	    _ParseAST.prototype.parseMultiplicative = function () {
	        // '*', '%', '/'
	        var result = this.parsePrefix();
	        while (true) {
	            if (this.optionalOperator('*')) {
	                result = new ast_1.Binary('*', result, this.parsePrefix());
	            }
	            else if (this.optionalOperator('%')) {
	                result = new ast_1.Binary('%', result, this.parsePrefix());
	            }
	            else if (this.optionalOperator('/')) {
	                result = new ast_1.Binary('/', result, this.parsePrefix());
	            }
	            else {
	                return result;
	            }
	        }
	    };
	    _ParseAST.prototype.parsePrefix = function () {
	        if (this.optionalOperator('+')) {
	            return this.parsePrefix();
	        }
	        else if (this.optionalOperator('-')) {
	            return new ast_1.Binary('-', new ast_1.LiteralPrimitive(0), this.parsePrefix());
	        }
	        else if (this.optionalOperator('!')) {
	            return new ast_1.PrefixNot(this.parsePrefix());
	        }
	        else {
	            return this.parseCallChain();
	        }
	    };
	    _ParseAST.prototype.parseCallChain = function () {
	        var result = this.parsePrimary();
	        while (true) {
	            if (this.optionalCharacter(lexer_1.$PERIOD)) {
	                result = this.parseAccessMemberOrMethodCall(result, false);
	            }
	            else if (this.optionalOperator('?.')) {
	                result = this.parseAccessMemberOrMethodCall(result, true);
	            }
	            else if (this.optionalCharacter(lexer_1.$LBRACKET)) {
	                var key = this.parsePipe();
	                this.expectCharacter(lexer_1.$RBRACKET);
	                if (this.optionalOperator("=")) {
	                    var value = this.parseConditional();
	                    result = new ast_1.KeyedWrite(result, key, value);
	                }
	                else {
	                    result = new ast_1.KeyedRead(result, key);
	                }
	            }
	            else if (this.optionalCharacter(lexer_1.$LPAREN)) {
	                var args = this.parseCallArguments();
	                this.expectCharacter(lexer_1.$RPAREN);
	                result = new ast_1.FunctionCall(result, args);
	            }
	            else {
	                return result;
	            }
	        }
	    };
	    _ParseAST.prototype.parsePrimary = function () {
	        if (this.optionalCharacter(lexer_1.$LPAREN)) {
	            var result = this.parsePipe();
	            this.expectCharacter(lexer_1.$RPAREN);
	            return result;
	        }
	        else if (this.next.isKeywordNull() || this.next.isKeywordUndefined()) {
	            this.advance();
	            return new ast_1.LiteralPrimitive(null);
	        }
	        else if (this.next.isKeywordTrue()) {
	            this.advance();
	            return new ast_1.LiteralPrimitive(true);
	        }
	        else if (this.next.isKeywordFalse()) {
	            this.advance();
	            return new ast_1.LiteralPrimitive(false);
	        }
	        else if (this.optionalCharacter(lexer_1.$LBRACKET)) {
	            var elements = this.parseExpressionList(lexer_1.$RBRACKET);
	            this.expectCharacter(lexer_1.$RBRACKET);
	            return new ast_1.LiteralArray(elements);
	        }
	        else if (this.next.isCharacter(lexer_1.$LBRACE)) {
	            return this.parseLiteralMap();
	        }
	        else if (this.next.isIdentifier()) {
	            return this.parseAccessMemberOrMethodCall(_implicitReceiver, false);
	        }
	        else if (this.next.isNumber()) {
	            var value = this.next.toNumber();
	            this.advance();
	            return new ast_1.LiteralPrimitive(value);
	        }
	        else if (this.next.isString()) {
	            var literalValue = this.next.toString();
	            this.advance();
	            return new ast_1.LiteralPrimitive(literalValue);
	        }
	        else if (this.index >= this.tokens.length) {
	            this.error("Unexpected end of expression: " + this.input);
	        }
	        else {
	            this.error("Unexpected token " + this.next);
	        }
	        // error() throws, so we don't reach here.
	        throw new exceptions_1.BaseException("Fell through all cases in parsePrimary");
	    };
	    _ParseAST.prototype.parseExpressionList = function (terminator) {
	        var result = [];
	        if (!this.next.isCharacter(terminator)) {
	            do {
	                result.push(this.parsePipe());
	            } while (this.optionalCharacter(lexer_1.$COMMA));
	        }
	        return result;
	    };
	    _ParseAST.prototype.parseLiteralMap = function () {
	        var keys = [];
	        var values = [];
	        this.expectCharacter(lexer_1.$LBRACE);
	        if (!this.optionalCharacter(lexer_1.$RBRACE)) {
	            do {
	                var key = this.expectIdentifierOrKeywordOrString();
	                keys.push(key);
	                this.expectCharacter(lexer_1.$COLON);
	                values.push(this.parsePipe());
	            } while (this.optionalCharacter(lexer_1.$COMMA));
	            this.expectCharacter(lexer_1.$RBRACE);
	        }
	        return new ast_1.LiteralMap(keys, values);
	    };
	    _ParseAST.prototype.parseAccessMemberOrMethodCall = function (receiver, isSafe) {
	        if (isSafe === void 0) { isSafe = false; }
	        var id = this.expectIdentifierOrKeyword();
	        if (this.optionalCharacter(lexer_1.$LPAREN)) {
	            var args = this.parseCallArguments();
	            this.expectCharacter(lexer_1.$RPAREN);
	            return isSafe ? new ast_1.SafeMethodCall(receiver, id, args) : new ast_1.MethodCall(receiver, id, args);
	        }
	        else {
	            if (isSafe) {
	                if (this.optionalOperator("=")) {
	                    this.error("The '?.' operator cannot be used in the assignment");
	                }
	                else {
	                    return new ast_1.SafePropertyRead(receiver, id);
	                }
	            }
	            else {
	                if (this.optionalOperator("=")) {
	                    if (!this.parseAction) {
	                        this.error("Bindings cannot contain assignments");
	                    }
	                    var value = this.parseConditional();
	                    return new ast_1.PropertyWrite(receiver, id, value);
	                }
	                else {
	                    return new ast_1.PropertyRead(receiver, id);
	                }
	            }
	        }
	        return null;
	    };
	    _ParseAST.prototype.parseCallArguments = function () {
	        if (this.next.isCharacter(lexer_1.$RPAREN))
	            return [];
	        var positionals = [];
	        do {
	            positionals.push(this.parsePipe());
	        } while (this.optionalCharacter(lexer_1.$COMMA));
	        return positionals;
	    };
	    _ParseAST.prototype.parseBlockContent = function () {
	        if (!this.parseAction) {
	            this.error("Binding expression cannot contain chained expression");
	        }
	        var exprs = [];
	        while (this.index < this.tokens.length && !this.next.isCharacter(lexer_1.$RBRACE)) {
	            var expr = this.parseExpression();
	            exprs.push(expr);
	            if (this.optionalCharacter(lexer_1.$SEMICOLON)) {
	                while (this.optionalCharacter(lexer_1.$SEMICOLON)) {
	                } // read all semicolons
	            }
	        }
	        if (exprs.length == 0)
	            return new ast_1.EmptyExpr();
	        if (exprs.length == 1)
	            return exprs[0];
	        return new ast_1.Chain(exprs);
	    };
	    /**
	     * An identifier, a keyword, a string with an optional `-` inbetween.
	     */
	    _ParseAST.prototype.expectTemplateBindingKey = function () {
	        var result = '';
	        var operatorFound = false;
	        do {
	            result += this.expectIdentifierOrKeywordOrString();
	            operatorFound = this.optionalOperator('-');
	            if (operatorFound) {
	                result += '-';
	            }
	        } while (operatorFound);
	        return result.toString();
	    };
	    _ParseAST.prototype.parseTemplateBindings = function () {
	        var bindings = [];
	        var prefix = null;
	        var warnings = [];
	        while (this.index < this.tokens.length) {
	            var keyIsVar = this.peekKeywordLet();
	            if (!keyIsVar && this.peekDeprecatedKeywordVar()) {
	                keyIsVar = true;
	                warnings.push("\"var\" inside of expressions is deprecated. Use \"let\" instead!");
	            }
	            if (!keyIsVar && this.peekDeprecatedOperatorHash()) {
	                keyIsVar = true;
	                warnings.push("\"#\" inside of expressions is deprecated. Use \"let\" instead!");
	            }
	            if (keyIsVar) {
	                this.advance();
	            }
	            var key = this.expectTemplateBindingKey();
	            if (!keyIsVar) {
	                if (prefix == null) {
	                    prefix = key;
	                }
	                else {
	                    key = prefix + key[0].toUpperCase() + key.substring(1);
	                }
	            }
	            this.optionalCharacter(lexer_1.$COLON);
	            var name = null;
	            var expression = null;
	            if (keyIsVar) {
	                if (this.optionalOperator("=")) {
	                    name = this.expectTemplateBindingKey();
	                }
	                else {
	                    name = '\$implicit';
	                }
	            }
	            else if (this.next !== lexer_1.EOF && !this.peekKeywordLet() && !this.peekDeprecatedKeywordVar() &&
	                !this.peekDeprecatedOperatorHash()) {
	                var start = this.inputIndex;
	                var ast = this.parsePipe();
	                var source = this.input.substring(start, this.inputIndex);
	                expression = new ast_1.ASTWithSource(ast, source, this.location);
	            }
	            bindings.push(new ast_1.TemplateBinding(key, keyIsVar, name, expression));
	            if (!this.optionalCharacter(lexer_1.$SEMICOLON)) {
	                this.optionalCharacter(lexer_1.$COMMA);
	            }
	        }
	        return new TemplateBindingParseResult(bindings, warnings);
	    };
	    _ParseAST.prototype.error = function (message, index) {
	        if (index === void 0) { index = null; }
	        if (lang_1.isBlank(index))
	            index = this.index;
	        var location = (index < this.tokens.length) ? "at column " + (this.tokens[index].index + 1) + " in" :
	            "at the end of the expression";
	        throw new ParseException(message, this.input, location, this.location);
	    };
	    return _ParseAST;
	}());
	exports._ParseAST = _ParseAST;
	var SimpleExpressionChecker = (function () {
	    function SimpleExpressionChecker() {
	        this.simple = true;
	    }
	    SimpleExpressionChecker.check = function (ast) {
	        var s = new SimpleExpressionChecker();
	        ast.visit(s);
	        return s.simple;
	    };
	    SimpleExpressionChecker.prototype.visitImplicitReceiver = function (ast, context) { };
	    SimpleExpressionChecker.prototype.visitInterpolation = function (ast, context) { this.simple = false; };
	    SimpleExpressionChecker.prototype.visitLiteralPrimitive = function (ast, context) { };
	    SimpleExpressionChecker.prototype.visitPropertyRead = function (ast, context) { };
	    SimpleExpressionChecker.prototype.visitPropertyWrite = function (ast, context) { this.simple = false; };
	    SimpleExpressionChecker.prototype.visitSafePropertyRead = function (ast, context) { this.simple = false; };
	    SimpleExpressionChecker.prototype.visitMethodCall = function (ast, context) { this.simple = false; };
	    SimpleExpressionChecker.prototype.visitSafeMethodCall = function (ast, context) { this.simple = false; };
	    SimpleExpressionChecker.prototype.visitFunctionCall = function (ast, context) { this.simple = false; };
	    SimpleExpressionChecker.prototype.visitLiteralArray = function (ast, context) { this.visitAll(ast.expressions); };
	    SimpleExpressionChecker.prototype.visitLiteralMap = function (ast, context) { this.visitAll(ast.values); };
	    SimpleExpressionChecker.prototype.visitBinary = function (ast, context) { this.simple = false; };
	    SimpleExpressionChecker.prototype.visitPrefixNot = function (ast, context) { this.simple = false; };
	    SimpleExpressionChecker.prototype.visitConditional = function (ast, context) { this.simple = false; };
	    SimpleExpressionChecker.prototype.visitPipe = function (ast, context) { this.simple = false; };
	    SimpleExpressionChecker.prototype.visitKeyedRead = function (ast, context) { this.simple = false; };
	    SimpleExpressionChecker.prototype.visitKeyedWrite = function (ast, context) { this.simple = false; };
	    SimpleExpressionChecker.prototype.visitAll = function (asts) {
	        var res = collection_1.ListWrapper.createFixedSize(asts.length);
	        for (var i = 0; i < asts.length; ++i) {
	            res[i] = asts[i].visit(this);
	        }
	        return res;
	    };
	    SimpleExpressionChecker.prototype.visitChain = function (ast, context) { this.simple = false; };
	    SimpleExpressionChecker.prototype.visitQuote = function (ast, context) { this.simple = false; };
	    return SimpleExpressionChecker;
	}());


/***/ },
/* 145 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var decorators_1 = __webpack_require__(8);
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	(function (TokenType) {
	    TokenType[TokenType["Character"] = 0] = "Character";
	    TokenType[TokenType["Identifier"] = 1] = "Identifier";
	    TokenType[TokenType["Keyword"] = 2] = "Keyword";
	    TokenType[TokenType["String"] = 3] = "String";
	    TokenType[TokenType["Operator"] = 4] = "Operator";
	    TokenType[TokenType["Number"] = 5] = "Number";
	})(exports.TokenType || (exports.TokenType = {}));
	var TokenType = exports.TokenType;
	var Lexer = (function () {
	    function Lexer() {
	    }
	    Lexer.prototype.tokenize = function (text) {
	        var scanner = new _Scanner(text);
	        var tokens = [];
	        var token = scanner.scanToken();
	        while (token != null) {
	            tokens.push(token);
	            token = scanner.scanToken();
	        }
	        return tokens;
	    };
	    Lexer = __decorate([
	        decorators_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], Lexer);
	    return Lexer;
	}());
	exports.Lexer = Lexer;
	var Token = (function () {
	    function Token(index, type, numValue, strValue) {
	        this.index = index;
	        this.type = type;
	        this.numValue = numValue;
	        this.strValue = strValue;
	    }
	    Token.prototype.isCharacter = function (code) {
	        return (this.type == TokenType.Character && this.numValue == code);
	    };
	    Token.prototype.isNumber = function () { return (this.type == TokenType.Number); };
	    Token.prototype.isString = function () { return (this.type == TokenType.String); };
	    Token.prototype.isOperator = function (operater) {
	        return (this.type == TokenType.Operator && this.strValue == operater);
	    };
	    Token.prototype.isIdentifier = function () { return (this.type == TokenType.Identifier); };
	    Token.prototype.isKeyword = function () { return (this.type == TokenType.Keyword); };
	    Token.prototype.isKeywordDeprecatedVar = function () {
	        return (this.type == TokenType.Keyword && this.strValue == "var");
	    };
	    Token.prototype.isKeywordLet = function () { return (this.type == TokenType.Keyword && this.strValue == "let"); };
	    Token.prototype.isKeywordNull = function () { return (this.type == TokenType.Keyword && this.strValue == "null"); };
	    Token.prototype.isKeywordUndefined = function () {
	        return (this.type == TokenType.Keyword && this.strValue == "undefined");
	    };
	    Token.prototype.isKeywordTrue = function () { return (this.type == TokenType.Keyword && this.strValue == "true"); };
	    Token.prototype.isKeywordFalse = function () { return (this.type == TokenType.Keyword && this.strValue == "false"); };
	    Token.prototype.toNumber = function () {
	        // -1 instead of NULL ok?
	        return (this.type == TokenType.Number) ? this.numValue : -1;
	    };
	    Token.prototype.toString = function () {
	        switch (this.type) {
	            case TokenType.Character:
	            case TokenType.Identifier:
	            case TokenType.Keyword:
	            case TokenType.Operator:
	            case TokenType.String:
	                return this.strValue;
	            case TokenType.Number:
	                return this.numValue.toString();
	            default:
	                return null;
	        }
	    };
	    return Token;
	}());
	exports.Token = Token;
	function newCharacterToken(index, code) {
	    return new Token(index, TokenType.Character, code, lang_1.StringWrapper.fromCharCode(code));
	}
	function newIdentifierToken(index, text) {
	    return new Token(index, TokenType.Identifier, 0, text);
	}
	function newKeywordToken(index, text) {
	    return new Token(index, TokenType.Keyword, 0, text);
	}
	function newOperatorToken(index, text) {
	    return new Token(index, TokenType.Operator, 0, text);
	}
	function newStringToken(index, text) {
	    return new Token(index, TokenType.String, 0, text);
	}
	function newNumberToken(index, n) {
	    return new Token(index, TokenType.Number, n, "");
	}
	exports.EOF = new Token(-1, TokenType.Character, 0, "");
	exports.$EOF = 0;
	exports.$TAB = 9;
	exports.$LF = 10;
	exports.$VTAB = 11;
	exports.$FF = 12;
	exports.$CR = 13;
	exports.$SPACE = 32;
	exports.$BANG = 33;
	exports.$DQ = 34;
	exports.$HASH = 35;
	exports.$$ = 36;
	exports.$PERCENT = 37;
	exports.$AMPERSAND = 38;
	exports.$SQ = 39;
	exports.$LPAREN = 40;
	exports.$RPAREN = 41;
	exports.$STAR = 42;
	exports.$PLUS = 43;
	exports.$COMMA = 44;
	exports.$MINUS = 45;
	exports.$PERIOD = 46;
	exports.$SLASH = 47;
	exports.$COLON = 58;
	exports.$SEMICOLON = 59;
	exports.$LT = 60;
	exports.$EQ = 61;
	exports.$GT = 62;
	exports.$QUESTION = 63;
	var $0 = 48;
	var $9 = 57;
	var $A = 65, $E = 69, $Z = 90;
	exports.$LBRACKET = 91;
	exports.$BACKSLASH = 92;
	exports.$RBRACKET = 93;
	var $CARET = 94;
	var $_ = 95;
	exports.$BT = 96;
	var $a = 97, $e = 101, $f = 102;
	var $n = 110, $r = 114, $t = 116, $u = 117, $v = 118, $z = 122;
	exports.$LBRACE = 123;
	exports.$BAR = 124;
	exports.$RBRACE = 125;
	var $NBSP = 160;
	var ScannerError = (function (_super) {
	    __extends(ScannerError, _super);
	    function ScannerError(message) {
	        _super.call(this);
	        this.message = message;
	    }
	    ScannerError.prototype.toString = function () { return this.message; };
	    return ScannerError;
	}(exceptions_1.BaseException));
	exports.ScannerError = ScannerError;
	var _Scanner = (function () {
	    function _Scanner(input) {
	        this.input = input;
	        this.peek = 0;
	        this.index = -1;
	        this.length = input.length;
	        this.advance();
	    }
	    _Scanner.prototype.advance = function () {
	        this.peek =
	            ++this.index >= this.length ? exports.$EOF : lang_1.StringWrapper.charCodeAt(this.input, this.index);
	    };
	    _Scanner.prototype.scanToken = function () {
	        var input = this.input, length = this.length, peek = this.peek, index = this.index;
	        // Skip whitespace.
	        while (peek <= exports.$SPACE) {
	            if (++index >= length) {
	                peek = exports.$EOF;
	                break;
	            }
	            else {
	                peek = lang_1.StringWrapper.charCodeAt(input, index);
	            }
	        }
	        this.peek = peek;
	        this.index = index;
	        if (index >= length) {
	            return null;
	        }
	        // Handle identifiers and numbers.
	        if (isIdentifierStart(peek))
	            return this.scanIdentifier();
	        if (isDigit(peek))
	            return this.scanNumber(index);
	        var start = index;
	        switch (peek) {
	            case exports.$PERIOD:
	                this.advance();
	                return isDigit(this.peek) ? this.scanNumber(start) : newCharacterToken(start, exports.$PERIOD);
	            case exports.$LPAREN:
	            case exports.$RPAREN:
	            case exports.$LBRACE:
	            case exports.$RBRACE:
	            case exports.$LBRACKET:
	            case exports.$RBRACKET:
	            case exports.$COMMA:
	            case exports.$COLON:
	            case exports.$SEMICOLON:
	                return this.scanCharacter(start, peek);
	            case exports.$SQ:
	            case exports.$DQ:
	                return this.scanString();
	            case exports.$HASH:
	            case exports.$PLUS:
	            case exports.$MINUS:
	            case exports.$STAR:
	            case exports.$SLASH:
	            case exports.$PERCENT:
	            case $CARET:
	                return this.scanOperator(start, lang_1.StringWrapper.fromCharCode(peek));
	            case exports.$QUESTION:
	                return this.scanComplexOperator(start, '?', exports.$PERIOD, '.');
	            case exports.$LT:
	            case exports.$GT:
	                return this.scanComplexOperator(start, lang_1.StringWrapper.fromCharCode(peek), exports.$EQ, '=');
	            case exports.$BANG:
	            case exports.$EQ:
	                return this.scanComplexOperator(start, lang_1.StringWrapper.fromCharCode(peek), exports.$EQ, '=', exports.$EQ, '=');
	            case exports.$AMPERSAND:
	                return this.scanComplexOperator(start, '&', exports.$AMPERSAND, '&');
	            case exports.$BAR:
	                return this.scanComplexOperator(start, '|', exports.$BAR, '|');
	            case $NBSP:
	                while (isWhitespace(this.peek))
	                    this.advance();
	                return this.scanToken();
	        }
	        this.error("Unexpected character [" + lang_1.StringWrapper.fromCharCode(peek) + "]", 0);
	        return null;
	    };
	    _Scanner.prototype.scanCharacter = function (start, code) {
	        this.advance();
	        return newCharacterToken(start, code);
	    };
	    _Scanner.prototype.scanOperator = function (start, str) {
	        this.advance();
	        return newOperatorToken(start, str);
	    };
	    /**
	     * Tokenize a 2/3 char long operator
	     *
	     * @param start start index in the expression
	     * @param one first symbol (always part of the operator)
	     * @param twoCode code point for the second symbol
	     * @param two second symbol (part of the operator when the second code point matches)
	     * @param threeCode code point for the third symbol
	     * @param three third symbol (part of the operator when provided and matches source expression)
	     * @returns {Token}
	     */
	    _Scanner.prototype.scanComplexOperator = function (start, one, twoCode, two, threeCode, three) {
	        this.advance();
	        var str = one;
	        if (this.peek == twoCode) {
	            this.advance();
	            str += two;
	        }
	        if (lang_1.isPresent(threeCode) && this.peek == threeCode) {
	            this.advance();
	            str += three;
	        }
	        return newOperatorToken(start, str);
	    };
	    _Scanner.prototype.scanIdentifier = function () {
	        var start = this.index;
	        this.advance();
	        while (isIdentifierPart(this.peek))
	            this.advance();
	        var str = this.input.substring(start, this.index);
	        if (collection_1.SetWrapper.has(KEYWORDS, str)) {
	            return newKeywordToken(start, str);
	        }
	        else {
	            return newIdentifierToken(start, str);
	        }
	    };
	    _Scanner.prototype.scanNumber = function (start) {
	        var simple = (this.index === start);
	        this.advance(); // Skip initial digit.
	        while (true) {
	            if (isDigit(this.peek)) {
	            }
	            else if (this.peek == exports.$PERIOD) {
	                simple = false;
	            }
	            else if (isExponentStart(this.peek)) {
	                this.advance();
	                if (isExponentSign(this.peek))
	                    this.advance();
	                if (!isDigit(this.peek))
	                    this.error('Invalid exponent', -1);
	                simple = false;
	            }
	            else {
	                break;
	            }
	            this.advance();
	        }
	        var str = this.input.substring(start, this.index);
	        // TODO
	        var value = simple ? lang_1.NumberWrapper.parseIntAutoRadix(str) : lang_1.NumberWrapper.parseFloat(str);
	        return newNumberToken(start, value);
	    };
	    _Scanner.prototype.scanString = function () {
	        var start = this.index;
	        var quote = this.peek;
	        this.advance(); // Skip initial quote.
	        var buffer;
	        var marker = this.index;
	        var input = this.input;
	        while (this.peek != quote) {
	            if (this.peek == exports.$BACKSLASH) {
	                if (buffer == null)
	                    buffer = new lang_1.StringJoiner();
	                buffer.add(input.substring(marker, this.index));
	                this.advance();
	                var unescapedCode;
	                if (this.peek == $u) {
	                    // 4 character hex code for unicode character.
	                    var hex = input.substring(this.index + 1, this.index + 5);
	                    try {
	                        unescapedCode = lang_1.NumberWrapper.parseInt(hex, 16);
	                    }
	                    catch (e) {
	                        this.error("Invalid unicode escape [\\u" + hex + "]", 0);
	                    }
	                    for (var i = 0; i < 5; i++) {
	                        this.advance();
	                    }
	                }
	                else {
	                    unescapedCode = unescape(this.peek);
	                    this.advance();
	                }
	                buffer.add(lang_1.StringWrapper.fromCharCode(unescapedCode));
	                marker = this.index;
	            }
	            else if (this.peek == exports.$EOF) {
	                this.error('Unterminated quote', 0);
	            }
	            else {
	                this.advance();
	            }
	        }
	        var last = input.substring(marker, this.index);
	        this.advance(); // Skip terminating quote.
	        // Compute the unescaped string value.
	        var unescaped = last;
	        if (buffer != null) {
	            buffer.add(last);
	            unescaped = buffer.toString();
	        }
	        return newStringToken(start, unescaped);
	    };
	    _Scanner.prototype.error = function (message, offset) {
	        var position = this.index + offset;
	        throw new ScannerError("Lexer Error: " + message + " at column " + position + " in expression [" + this.input + "]");
	    };
	    return _Scanner;
	}());
	function isWhitespace(code) {
	    return (code >= exports.$TAB && code <= exports.$SPACE) || (code == $NBSP);
	}
	function isIdentifierStart(code) {
	    return ($a <= code && code <= $z) || ($A <= code && code <= $Z) || (code == $_) || (code == exports.$$);
	}
	function isIdentifier(input) {
	    if (input.length == 0)
	        return false;
	    var scanner = new _Scanner(input);
	    if (!isIdentifierStart(scanner.peek))
	        return false;
	    scanner.advance();
	    while (scanner.peek !== exports.$EOF) {
	        if (!isIdentifierPart(scanner.peek))
	            return false;
	        scanner.advance();
	    }
	    return true;
	}
	exports.isIdentifier = isIdentifier;
	function isIdentifierPart(code) {
	    return ($a <= code && code <= $z) || ($A <= code && code <= $Z) || ($0 <= code && code <= $9) ||
	        (code == $_) || (code == exports.$$);
	}
	function isDigit(code) {
	    return $0 <= code && code <= $9;
	}
	function isExponentStart(code) {
	    return code == $e || code == $E;
	}
	function isExponentSign(code) {
	    return code == exports.$MINUS || code == exports.$PLUS;
	}
	function isQuote(code) {
	    return code === exports.$SQ || code === exports.$DQ || code === exports.$BT;
	}
	exports.isQuote = isQuote;
	function unescape(code) {
	    switch (code) {
	        case $n:
	            return exports.$LF;
	        case $f:
	            return exports.$FF;
	        case $r:
	            return exports.$CR;
	        case $t:
	            return exports.$TAB;
	        case $v:
	            return exports.$VTAB;
	        default:
	            return code;
	    }
	}
	var OPERATORS = collection_1.SetWrapper.createFromList([
	    '+',
	    '-',
	    '*',
	    '/',
	    '%',
	    '^',
	    '=',
	    '==',
	    '!=',
	    '===',
	    '!==',
	    '<',
	    '>',
	    '<=',
	    '>=',
	    '&&',
	    '||',
	    '&',
	    '|',
	    '!',
	    '?',
	    '#',
	    '?.'
	]);
	var KEYWORDS = collection_1.SetWrapper.createFromList(['var', 'let', 'null', 'undefined', 'true', 'false', 'if', 'else']);


/***/ },
/* 146 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var html_ast_1 = __webpack_require__(147);
	var di_1 = __webpack_require__(6);
	var html_lexer_1 = __webpack_require__(148);
	var parse_util_1 = __webpack_require__(149);
	var html_tags_1 = __webpack_require__(150);
	var HtmlTreeError = (function (_super) {
	    __extends(HtmlTreeError, _super);
	    function HtmlTreeError(elementName, span, msg) {
	        _super.call(this, span, msg);
	        this.elementName = elementName;
	    }
	    HtmlTreeError.create = function (elementName, span, msg) {
	        return new HtmlTreeError(elementName, span, msg);
	    };
	    return HtmlTreeError;
	}(parse_util_1.ParseError));
	exports.HtmlTreeError = HtmlTreeError;
	var HtmlParseTreeResult = (function () {
	    function HtmlParseTreeResult(rootNodes, errors) {
	        this.rootNodes = rootNodes;
	        this.errors = errors;
	    }
	    return HtmlParseTreeResult;
	}());
	exports.HtmlParseTreeResult = HtmlParseTreeResult;
	var HtmlParser = (function () {
	    function HtmlParser() {
	    }
	    HtmlParser.prototype.parse = function (sourceContent, sourceUrl, parseExpansionForms) {
	        if (parseExpansionForms === void 0) { parseExpansionForms = false; }
	        var tokensAndErrors = html_lexer_1.tokenizeHtml(sourceContent, sourceUrl, parseExpansionForms);
	        var treeAndErrors = new TreeBuilder(tokensAndErrors.tokens).build();
	        return new HtmlParseTreeResult(treeAndErrors.rootNodes, tokensAndErrors.errors
	            .concat(treeAndErrors.errors));
	    };
	    HtmlParser = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], HtmlParser);
	    return HtmlParser;
	}());
	exports.HtmlParser = HtmlParser;
	var TreeBuilder = (function () {
	    function TreeBuilder(tokens) {
	        this.tokens = tokens;
	        this.index = -1;
	        this.rootNodes = [];
	        this.errors = [];
	        this.elementStack = [];
	        this._advance();
	    }
	    TreeBuilder.prototype.build = function () {
	        while (this.peek.type !== html_lexer_1.HtmlTokenType.EOF) {
	            if (this.peek.type === html_lexer_1.HtmlTokenType.TAG_OPEN_START) {
	                this._consumeStartTag(this._advance());
	            }
	            else if (this.peek.type === html_lexer_1.HtmlTokenType.TAG_CLOSE) {
	                this._consumeEndTag(this._advance());
	            }
	            else if (this.peek.type === html_lexer_1.HtmlTokenType.CDATA_START) {
	                this._closeVoidElement();
	                this._consumeCdata(this._advance());
	            }
	            else if (this.peek.type === html_lexer_1.HtmlTokenType.COMMENT_START) {
	                this._closeVoidElement();
	                this._consumeComment(this._advance());
	            }
	            else if (this.peek.type === html_lexer_1.HtmlTokenType.TEXT ||
	                this.peek.type === html_lexer_1.HtmlTokenType.RAW_TEXT ||
	                this.peek.type === html_lexer_1.HtmlTokenType.ESCAPABLE_RAW_TEXT) {
	                this._closeVoidElement();
	                this._consumeText(this._advance());
	            }
	            else if (this.peek.type === html_lexer_1.HtmlTokenType.EXPANSION_FORM_START) {
	                this._consumeExpansion(this._advance());
	            }
	            else {
	                // Skip all other tokens...
	                this._advance();
	            }
	        }
	        return new HtmlParseTreeResult(this.rootNodes, this.errors);
	    };
	    TreeBuilder.prototype._advance = function () {
	        var prev = this.peek;
	        if (this.index < this.tokens.length - 1) {
	            // Note: there is always an EOF token at the end
	            this.index++;
	        }
	        this.peek = this.tokens[this.index];
	        return prev;
	    };
	    TreeBuilder.prototype._advanceIf = function (type) {
	        if (this.peek.type === type) {
	            return this._advance();
	        }
	        return null;
	    };
	    TreeBuilder.prototype._consumeCdata = function (startToken) {
	        this._consumeText(this._advance());
	        this._advanceIf(html_lexer_1.HtmlTokenType.CDATA_END);
	    };
	    TreeBuilder.prototype._consumeComment = function (token) {
	        var text = this._advanceIf(html_lexer_1.HtmlTokenType.RAW_TEXT);
	        this._advanceIf(html_lexer_1.HtmlTokenType.COMMENT_END);
	        var value = lang_1.isPresent(text) ? text.parts[0].trim() : null;
	        this._addToParent(new html_ast_1.HtmlCommentAst(value, token.sourceSpan));
	    };
	    TreeBuilder.prototype._consumeExpansion = function (token) {
	        var switchValue = this._advance();
	        var type = this._advance();
	        var cases = [];
	        // read =
	        while (this.peek.type === html_lexer_1.HtmlTokenType.EXPANSION_CASE_VALUE) {
	            var expCase = this._parseExpansionCase();
	            if (lang_1.isBlank(expCase))
	                return; // error
	            cases.push(expCase);
	        }
	        // read the final }
	        if (this.peek.type !== html_lexer_1.HtmlTokenType.EXPANSION_FORM_END) {
	            this.errors.push(HtmlTreeError.create(null, this.peek.sourceSpan, "Invalid expansion form. Missing '}'."));
	            return;
	        }
	        this._advance();
	        var mainSourceSpan = new parse_util_1.ParseSourceSpan(token.sourceSpan.start, this.peek.sourceSpan.end);
	        this._addToParent(new html_ast_1.HtmlExpansionAst(switchValue.parts[0], type.parts[0], cases, mainSourceSpan, switchValue.sourceSpan));
	    };
	    TreeBuilder.prototype._parseExpansionCase = function () {
	        var value = this._advance();
	        // read {
	        if (this.peek.type !== html_lexer_1.HtmlTokenType.EXPANSION_CASE_EXP_START) {
	            this.errors.push(HtmlTreeError.create(null, this.peek.sourceSpan, "Invalid expansion form. Missing '{'.,"));
	            return null;
	        }
	        // read until }
	        var start = this._advance();
	        var exp = this._collectExpansionExpTokens(start);
	        if (lang_1.isBlank(exp))
	            return null;
	        var end = this._advance();
	        exp.push(new html_lexer_1.HtmlToken(html_lexer_1.HtmlTokenType.EOF, [], end.sourceSpan));
	        // parse everything in between { and }
	        var parsedExp = new TreeBuilder(exp).build();
	        if (parsedExp.errors.length > 0) {
	            this.errors = this.errors.concat(parsedExp.errors);
	            return null;
	        }
	        var sourceSpan = new parse_util_1.ParseSourceSpan(value.sourceSpan.start, end.sourceSpan.end);
	        var expSourceSpan = new parse_util_1.ParseSourceSpan(start.sourceSpan.start, end.sourceSpan.end);
	        return new html_ast_1.HtmlExpansionCaseAst(value.parts[0], parsedExp.rootNodes, sourceSpan, value.sourceSpan, expSourceSpan);
	    };
	    TreeBuilder.prototype._collectExpansionExpTokens = function (start) {
	        var exp = [];
	        var expansionFormStack = [html_lexer_1.HtmlTokenType.EXPANSION_CASE_EXP_START];
	        while (true) {
	            if (this.peek.type === html_lexer_1.HtmlTokenType.EXPANSION_FORM_START ||
	                this.peek.type === html_lexer_1.HtmlTokenType.EXPANSION_CASE_EXP_START) {
	                expansionFormStack.push(this.peek.type);
	            }
	            if (this.peek.type === html_lexer_1.HtmlTokenType.EXPANSION_CASE_EXP_END) {
	                if (lastOnStack(expansionFormStack, html_lexer_1.HtmlTokenType.EXPANSION_CASE_EXP_START)) {
	                    expansionFormStack.pop();
	                    if (expansionFormStack.length == 0)
	                        return exp;
	                }
	                else {
	                    this.errors.push(HtmlTreeError.create(null, start.sourceSpan, "Invalid expansion form. Missing '}'."));
	                    return null;
	                }
	            }
	            if (this.peek.type === html_lexer_1.HtmlTokenType.EXPANSION_FORM_END) {
	                if (lastOnStack(expansionFormStack, html_lexer_1.HtmlTokenType.EXPANSION_FORM_START)) {
	                    expansionFormStack.pop();
	                }
	                else {
	                    this.errors.push(HtmlTreeError.create(null, start.sourceSpan, "Invalid expansion form. Missing '}'."));
	                    return null;
	                }
	            }
	            if (this.peek.type === html_lexer_1.HtmlTokenType.EOF) {
	                this.errors.push(HtmlTreeError.create(null, start.sourceSpan, "Invalid expansion form. Missing '}'."));
	                return null;
	            }
	            exp.push(this._advance());
	        }
	    };
	    TreeBuilder.prototype._consumeText = function (token) {
	        var text = token.parts[0];
	        if (text.length > 0 && text[0] == '\n') {
	            var parent_1 = this._getParentElement();
	            if (lang_1.isPresent(parent_1) && parent_1.children.length == 0 &&
	                html_tags_1.getHtmlTagDefinition(parent_1.name).ignoreFirstLf) {
	                text = text.substring(1);
	            }
	        }
	        if (text.length > 0) {
	            this._addToParent(new html_ast_1.HtmlTextAst(text, token.sourceSpan));
	        }
	    };
	    TreeBuilder.prototype._closeVoidElement = function () {
	        if (this.elementStack.length > 0) {
	            var el = collection_1.ListWrapper.last(this.elementStack);
	            if (html_tags_1.getHtmlTagDefinition(el.name).isVoid) {
	                this.elementStack.pop();
	            }
	        }
	    };
	    TreeBuilder.prototype._consumeStartTag = function (startTagToken) {
	        var prefix = startTagToken.parts[0];
	        var name = startTagToken.parts[1];
	        var attrs = [];
	        while (this.peek.type === html_lexer_1.HtmlTokenType.ATTR_NAME) {
	            attrs.push(this._consumeAttr(this._advance()));
	        }
	        var fullName = getElementFullName(prefix, name, this._getParentElement());
	        var selfClosing = false;
	        // Note: There could have been a tokenizer error
	        // so that we don't get a token for the end tag...
	        if (this.peek.type === html_lexer_1.HtmlTokenType.TAG_OPEN_END_VOID) {
	            this._advance();
	            selfClosing = true;
	            if (html_tags_1.getNsPrefix(fullName) == null && !html_tags_1.getHtmlTagDefinition(fullName).isVoid) {
	                this.errors.push(HtmlTreeError.create(fullName, startTagToken.sourceSpan, "Only void and foreign elements can be self closed \"" + startTagToken.parts[1] + "\""));
	            }
	        }
	        else if (this.peek.type === html_lexer_1.HtmlTokenType.TAG_OPEN_END) {
	            this._advance();
	            selfClosing = false;
	        }
	        var end = this.peek.sourceSpan.start;
	        var span = new parse_util_1.ParseSourceSpan(startTagToken.sourceSpan.start, end);
	        var el = new html_ast_1.HtmlElementAst(fullName, attrs, [], span, span, null);
	        this._pushElement(el);
	        if (selfClosing) {
	            this._popElement(fullName);
	            el.endSourceSpan = span;
	        }
	    };
	    TreeBuilder.prototype._pushElement = function (el) {
	        if (this.elementStack.length > 0) {
	            var parentEl = collection_1.ListWrapper.last(this.elementStack);
	            if (html_tags_1.getHtmlTagDefinition(parentEl.name).isClosedByChild(el.name)) {
	                this.elementStack.pop();
	            }
	        }
	        var tagDef = html_tags_1.getHtmlTagDefinition(el.name);
	        var parentEl = this._getParentElement();
	        if (tagDef.requireExtraParent(lang_1.isPresent(parentEl) ? parentEl.name : null)) {
	            var newParent = new html_ast_1.HtmlElementAst(tagDef.parentToAdd, [], [el], el.sourceSpan, el.startSourceSpan, el.endSourceSpan);
	            this._addToParent(newParent);
	            this.elementStack.push(newParent);
	            this.elementStack.push(el);
	        }
	        else {
	            this._addToParent(el);
	            this.elementStack.push(el);
	        }
	    };
	    TreeBuilder.prototype._consumeEndTag = function (endTagToken) {
	        var fullName = getElementFullName(endTagToken.parts[0], endTagToken.parts[1], this._getParentElement());
	        this._getParentElement().endSourceSpan = endTagToken.sourceSpan;
	        if (html_tags_1.getHtmlTagDefinition(fullName).isVoid) {
	            this.errors.push(HtmlTreeError.create(fullName, endTagToken.sourceSpan, "Void elements do not have end tags \"" + endTagToken.parts[1] + "\""));
	        }
	        else if (!this._popElement(fullName)) {
	            this.errors.push(HtmlTreeError.create(fullName, endTagToken.sourceSpan, "Unexpected closing tag \"" + endTagToken.parts[1] + "\""));
	        }
	    };
	    TreeBuilder.prototype._popElement = function (fullName) {
	        for (var stackIndex = this.elementStack.length - 1; stackIndex >= 0; stackIndex--) {
	            var el = this.elementStack[stackIndex];
	            if (el.name == fullName) {
	                collection_1.ListWrapper.splice(this.elementStack, stackIndex, this.elementStack.length - stackIndex);
	                return true;
	            }
	            if (!html_tags_1.getHtmlTagDefinition(el.name).closedByParent) {
	                return false;
	            }
	        }
	        return false;
	    };
	    TreeBuilder.prototype._consumeAttr = function (attrName) {
	        var fullName = html_tags_1.mergeNsAndName(attrName.parts[0], attrName.parts[1]);
	        var end = attrName.sourceSpan.end;
	        var value = '';
	        if (this.peek.type === html_lexer_1.HtmlTokenType.ATTR_VALUE) {
	            var valueToken = this._advance();
	            value = valueToken.parts[0];
	            end = valueToken.sourceSpan.end;
	        }
	        return new html_ast_1.HtmlAttrAst(fullName, value, new parse_util_1.ParseSourceSpan(attrName.sourceSpan.start, end));
	    };
	    TreeBuilder.prototype._getParentElement = function () {
	        return this.elementStack.length > 0 ? collection_1.ListWrapper.last(this.elementStack) : null;
	    };
	    TreeBuilder.prototype._addToParent = function (node) {
	        var parent = this._getParentElement();
	        if (lang_1.isPresent(parent)) {
	            parent.children.push(node);
	        }
	        else {
	            this.rootNodes.push(node);
	        }
	    };
	    return TreeBuilder;
	}());
	function getElementFullName(prefix, localName, parentElement) {
	    if (lang_1.isBlank(prefix)) {
	        prefix = html_tags_1.getHtmlTagDefinition(localName).implicitNamespacePrefix;
	        if (lang_1.isBlank(prefix) && lang_1.isPresent(parentElement)) {
	            prefix = html_tags_1.getNsPrefix(parentElement.name);
	        }
	    }
	    return html_tags_1.mergeNsAndName(prefix, localName);
	}
	function lastOnStack(stack, element) {
	    return stack.length > 0 && stack[stack.length - 1] === element;
	}


/***/ },
/* 147 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var HtmlTextAst = (function () {
	    function HtmlTextAst(value, sourceSpan) {
	        this.value = value;
	        this.sourceSpan = sourceSpan;
	    }
	    HtmlTextAst.prototype.visit = function (visitor, context) { return visitor.visitText(this, context); };
	    return HtmlTextAst;
	}());
	exports.HtmlTextAst = HtmlTextAst;
	var HtmlExpansionAst = (function () {
	    function HtmlExpansionAst(switchValue, type, cases, sourceSpan, switchValueSourceSpan) {
	        this.switchValue = switchValue;
	        this.type = type;
	        this.cases = cases;
	        this.sourceSpan = sourceSpan;
	        this.switchValueSourceSpan = switchValueSourceSpan;
	    }
	    HtmlExpansionAst.prototype.visit = function (visitor, context) {
	        return visitor.visitExpansion(this, context);
	    };
	    return HtmlExpansionAst;
	}());
	exports.HtmlExpansionAst = HtmlExpansionAst;
	var HtmlExpansionCaseAst = (function () {
	    function HtmlExpansionCaseAst(value, expression, sourceSpan, valueSourceSpan, expSourceSpan) {
	        this.value = value;
	        this.expression = expression;
	        this.sourceSpan = sourceSpan;
	        this.valueSourceSpan = valueSourceSpan;
	        this.expSourceSpan = expSourceSpan;
	    }
	    HtmlExpansionCaseAst.prototype.visit = function (visitor, context) {
	        return visitor.visitExpansionCase(this, context);
	    };
	    return HtmlExpansionCaseAst;
	}());
	exports.HtmlExpansionCaseAst = HtmlExpansionCaseAst;
	var HtmlAttrAst = (function () {
	    function HtmlAttrAst(name, value, sourceSpan) {
	        this.name = name;
	        this.value = value;
	        this.sourceSpan = sourceSpan;
	    }
	    HtmlAttrAst.prototype.visit = function (visitor, context) { return visitor.visitAttr(this, context); };
	    return HtmlAttrAst;
	}());
	exports.HtmlAttrAst = HtmlAttrAst;
	var HtmlElementAst = (function () {
	    function HtmlElementAst(name, attrs, children, sourceSpan, startSourceSpan, endSourceSpan) {
	        this.name = name;
	        this.attrs = attrs;
	        this.children = children;
	        this.sourceSpan = sourceSpan;
	        this.startSourceSpan = startSourceSpan;
	        this.endSourceSpan = endSourceSpan;
	    }
	    HtmlElementAst.prototype.visit = function (visitor, context) { return visitor.visitElement(this, context); };
	    return HtmlElementAst;
	}());
	exports.HtmlElementAst = HtmlElementAst;
	var HtmlCommentAst = (function () {
	    function HtmlCommentAst(value, sourceSpan) {
	        this.value = value;
	        this.sourceSpan = sourceSpan;
	    }
	    HtmlCommentAst.prototype.visit = function (visitor, context) { return visitor.visitComment(this, context); };
	    return HtmlCommentAst;
	}());
	exports.HtmlCommentAst = HtmlCommentAst;
	function htmlVisitAll(visitor, asts, context) {
	    if (context === void 0) { context = null; }
	    var result = [];
	    asts.forEach(function (ast) {
	        var astResult = ast.visit(visitor, context);
	        if (lang_1.isPresent(astResult)) {
	            result.push(astResult);
	        }
	    });
	    return result;
	}
	exports.htmlVisitAll = htmlVisitAll;


/***/ },
/* 148 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var parse_util_1 = __webpack_require__(149);
	var html_tags_1 = __webpack_require__(150);
	(function (HtmlTokenType) {
	    HtmlTokenType[HtmlTokenType["TAG_OPEN_START"] = 0] = "TAG_OPEN_START";
	    HtmlTokenType[HtmlTokenType["TAG_OPEN_END"] = 1] = "TAG_OPEN_END";
	    HtmlTokenType[HtmlTokenType["TAG_OPEN_END_VOID"] = 2] = "TAG_OPEN_END_VOID";
	    HtmlTokenType[HtmlTokenType["TAG_CLOSE"] = 3] = "TAG_CLOSE";
	    HtmlTokenType[HtmlTokenType["TEXT"] = 4] = "TEXT";
	    HtmlTokenType[HtmlTokenType["ESCAPABLE_RAW_TEXT"] = 5] = "ESCAPABLE_RAW_TEXT";
	    HtmlTokenType[HtmlTokenType["RAW_TEXT"] = 6] = "RAW_TEXT";
	    HtmlTokenType[HtmlTokenType["COMMENT_START"] = 7] = "COMMENT_START";
	    HtmlTokenType[HtmlTokenType["COMMENT_END"] = 8] = "COMMENT_END";
	    HtmlTokenType[HtmlTokenType["CDATA_START"] = 9] = "CDATA_START";
	    HtmlTokenType[HtmlTokenType["CDATA_END"] = 10] = "CDATA_END";
	    HtmlTokenType[HtmlTokenType["ATTR_NAME"] = 11] = "ATTR_NAME";
	    HtmlTokenType[HtmlTokenType["ATTR_VALUE"] = 12] = "ATTR_VALUE";
	    HtmlTokenType[HtmlTokenType["DOC_TYPE"] = 13] = "DOC_TYPE";
	    HtmlTokenType[HtmlTokenType["EXPANSION_FORM_START"] = 14] = "EXPANSION_FORM_START";
	    HtmlTokenType[HtmlTokenType["EXPANSION_CASE_VALUE"] = 15] = "EXPANSION_CASE_VALUE";
	    HtmlTokenType[HtmlTokenType["EXPANSION_CASE_EXP_START"] = 16] = "EXPANSION_CASE_EXP_START";
	    HtmlTokenType[HtmlTokenType["EXPANSION_CASE_EXP_END"] = 17] = "EXPANSION_CASE_EXP_END";
	    HtmlTokenType[HtmlTokenType["EXPANSION_FORM_END"] = 18] = "EXPANSION_FORM_END";
	    HtmlTokenType[HtmlTokenType["EOF"] = 19] = "EOF";
	})(exports.HtmlTokenType || (exports.HtmlTokenType = {}));
	var HtmlTokenType = exports.HtmlTokenType;
	var HtmlToken = (function () {
	    function HtmlToken(type, parts, sourceSpan) {
	        this.type = type;
	        this.parts = parts;
	        this.sourceSpan = sourceSpan;
	    }
	    return HtmlToken;
	}());
	exports.HtmlToken = HtmlToken;
	var HtmlTokenError = (function (_super) {
	    __extends(HtmlTokenError, _super);
	    function HtmlTokenError(errorMsg, tokenType, span) {
	        _super.call(this, span, errorMsg);
	        this.tokenType = tokenType;
	    }
	    return HtmlTokenError;
	}(parse_util_1.ParseError));
	exports.HtmlTokenError = HtmlTokenError;
	var HtmlTokenizeResult = (function () {
	    function HtmlTokenizeResult(tokens, errors) {
	        this.tokens = tokens;
	        this.errors = errors;
	    }
	    return HtmlTokenizeResult;
	}());
	exports.HtmlTokenizeResult = HtmlTokenizeResult;
	function tokenizeHtml(sourceContent, sourceUrl, tokenizeExpansionForms) {
	    if (tokenizeExpansionForms === void 0) { tokenizeExpansionForms = false; }
	    return new _HtmlTokenizer(new parse_util_1.ParseSourceFile(sourceContent, sourceUrl), tokenizeExpansionForms)
	        .tokenize();
	}
	exports.tokenizeHtml = tokenizeHtml;
	var $EOF = 0;
	var $TAB = 9;
	var $LF = 10;
	var $FF = 12;
	var $CR = 13;
	var $SPACE = 32;
	var $BANG = 33;
	var $DQ = 34;
	var $HASH = 35;
	var $$ = 36;
	var $AMPERSAND = 38;
	var $SQ = 39;
	var $MINUS = 45;
	var $SLASH = 47;
	var $0 = 48;
	var $SEMICOLON = 59;
	var $9 = 57;
	var $COLON = 58;
	var $LT = 60;
	var $EQ = 61;
	var $GT = 62;
	var $QUESTION = 63;
	var $LBRACKET = 91;
	var $RBRACKET = 93;
	var $LBRACE = 123;
	var $RBRACE = 125;
	var $COMMA = 44;
	var $A = 65;
	var $F = 70;
	var $X = 88;
	var $Z = 90;
	var $a = 97;
	var $f = 102;
	var $z = 122;
	var $x = 120;
	var $NBSP = 160;
	var CR_OR_CRLF_REGEXP = /\r\n?/g;
	function unexpectedCharacterErrorMsg(charCode) {
	    var char = charCode === $EOF ? 'EOF' : lang_1.StringWrapper.fromCharCode(charCode);
	    return "Unexpected character \"" + char + "\"";
	}
	function unknownEntityErrorMsg(entitySrc) {
	    return "Unknown entity \"" + entitySrc + "\" - use the \"&#<decimal>;\" or  \"&#x<hex>;\" syntax";
	}
	var ControlFlowError = (function () {
	    function ControlFlowError(error) {
	        this.error = error;
	    }
	    return ControlFlowError;
	}());
	// See http://www.w3.org/TR/html51/syntax.html#writing
	var _HtmlTokenizer = (function () {
	    function _HtmlTokenizer(file, tokenizeExpansionForms) {
	        this.file = file;
	        this.tokenizeExpansionForms = tokenizeExpansionForms;
	        // Note: this is always lowercase!
	        this.peek = -1;
	        this.nextPeek = -1;
	        this.index = -1;
	        this.line = 0;
	        this.column = -1;
	        this.expansionCaseStack = [];
	        this.tokens = [];
	        this.errors = [];
	        this.input = file.content;
	        this.length = file.content.length;
	        this._advance();
	    }
	    _HtmlTokenizer.prototype._processCarriageReturns = function (content) {
	        // http://www.w3.org/TR/html5/syntax.html#preprocessing-the-input-stream
	        // In order to keep the original position in the source, we can not
	        // pre-process it.
	        // Instead CRs are processed right before instantiating the tokens.
	        return lang_1.StringWrapper.replaceAll(content, CR_OR_CRLF_REGEXP, '\n');
	    };
	    _HtmlTokenizer.prototype.tokenize = function () {
	        while (this.peek !== $EOF) {
	            var start = this._getLocation();
	            try {
	                if (this._attemptCharCode($LT)) {
	                    if (this._attemptCharCode($BANG)) {
	                        if (this._attemptCharCode($LBRACKET)) {
	                            this._consumeCdata(start);
	                        }
	                        else if (this._attemptCharCode($MINUS)) {
	                            this._consumeComment(start);
	                        }
	                        else {
	                            this._consumeDocType(start);
	                        }
	                    }
	                    else if (this._attemptCharCode($SLASH)) {
	                        this._consumeTagClose(start);
	                    }
	                    else {
	                        this._consumeTagOpen(start);
	                    }
	                }
	                else if (isSpecialFormStart(this.peek, this.nextPeek) && this.tokenizeExpansionForms) {
	                    this._consumeExpansionFormStart();
	                }
	                else if (this.peek === $EQ && this.tokenizeExpansionForms) {
	                    this._consumeExpansionCaseStart();
	                }
	                else if (this.peek === $RBRACE && this.isInExpansionCase() &&
	                    this.tokenizeExpansionForms) {
	                    this._consumeExpansionCaseEnd();
	                }
	                else if (this.peek === $RBRACE && this.isInExpansionForm() &&
	                    this.tokenizeExpansionForms) {
	                    this._consumeExpansionFormEnd();
	                }
	                else {
	                    this._consumeText();
	                }
	            }
	            catch (e) {
	                if (e instanceof ControlFlowError) {
	                    this.errors.push(e.error);
	                }
	                else {
	                    throw e;
	                }
	            }
	        }
	        this._beginToken(HtmlTokenType.EOF);
	        this._endToken([]);
	        return new HtmlTokenizeResult(mergeTextTokens(this.tokens), this.errors);
	    };
	    _HtmlTokenizer.prototype._getLocation = function () {
	        return new parse_util_1.ParseLocation(this.file, this.index, this.line, this.column);
	    };
	    _HtmlTokenizer.prototype._getSpan = function (start, end) {
	        if (lang_1.isBlank(start)) {
	            start = this._getLocation();
	        }
	        if (lang_1.isBlank(end)) {
	            end = this._getLocation();
	        }
	        return new parse_util_1.ParseSourceSpan(start, end);
	    };
	    _HtmlTokenizer.prototype._beginToken = function (type, start) {
	        if (start === void 0) { start = null; }
	        if (lang_1.isBlank(start)) {
	            start = this._getLocation();
	        }
	        this.currentTokenStart = start;
	        this.currentTokenType = type;
	    };
	    _HtmlTokenizer.prototype._endToken = function (parts, end) {
	        if (end === void 0) { end = null; }
	        if (lang_1.isBlank(end)) {
	            end = this._getLocation();
	        }
	        var token = new HtmlToken(this.currentTokenType, parts, new parse_util_1.ParseSourceSpan(this.currentTokenStart, end));
	        this.tokens.push(token);
	        this.currentTokenStart = null;
	        this.currentTokenType = null;
	        return token;
	    };
	    _HtmlTokenizer.prototype._createError = function (msg, span) {
	        var error = new HtmlTokenError(msg, this.currentTokenType, span);
	        this.currentTokenStart = null;
	        this.currentTokenType = null;
	        return new ControlFlowError(error);
	    };
	    _HtmlTokenizer.prototype._advance = function () {
	        if (this.index >= this.length) {
	            throw this._createError(unexpectedCharacterErrorMsg($EOF), this._getSpan());
	        }
	        if (this.peek === $LF) {
	            this.line++;
	            this.column = 0;
	        }
	        else if (this.peek !== $LF && this.peek !== $CR) {
	            this.column++;
	        }
	        this.index++;
	        this.peek = this.index >= this.length ? $EOF : lang_1.StringWrapper.charCodeAt(this.input, this.index);
	        this.nextPeek =
	            this.index + 1 >= this.length ? $EOF : lang_1.StringWrapper.charCodeAt(this.input, this.index + 1);
	    };
	    _HtmlTokenizer.prototype._attemptCharCode = function (charCode) {
	        if (this.peek === charCode) {
	            this._advance();
	            return true;
	        }
	        return false;
	    };
	    _HtmlTokenizer.prototype._attemptCharCodeCaseInsensitive = function (charCode) {
	        if (compareCharCodeCaseInsensitive(this.peek, charCode)) {
	            this._advance();
	            return true;
	        }
	        return false;
	    };
	    _HtmlTokenizer.prototype._requireCharCode = function (charCode) {
	        var location = this._getLocation();
	        if (!this._attemptCharCode(charCode)) {
	            throw this._createError(unexpectedCharacterErrorMsg(this.peek), this._getSpan(location, location));
	        }
	    };
	    _HtmlTokenizer.prototype._attemptStr = function (chars) {
	        for (var i = 0; i < chars.length; i++) {
	            if (!this._attemptCharCode(lang_1.StringWrapper.charCodeAt(chars, i))) {
	                return false;
	            }
	        }
	        return true;
	    };
	    _HtmlTokenizer.prototype._attemptStrCaseInsensitive = function (chars) {
	        for (var i = 0; i < chars.length; i++) {
	            if (!this._attemptCharCodeCaseInsensitive(lang_1.StringWrapper.charCodeAt(chars, i))) {
	                return false;
	            }
	        }
	        return true;
	    };
	    _HtmlTokenizer.prototype._requireStr = function (chars) {
	        var location = this._getLocation();
	        if (!this._attemptStr(chars)) {
	            throw this._createError(unexpectedCharacterErrorMsg(this.peek), this._getSpan(location));
	        }
	    };
	    _HtmlTokenizer.prototype._attemptCharCodeUntilFn = function (predicate) {
	        while (!predicate(this.peek)) {
	            this._advance();
	        }
	    };
	    _HtmlTokenizer.prototype._requireCharCodeUntilFn = function (predicate, len) {
	        var start = this._getLocation();
	        this._attemptCharCodeUntilFn(predicate);
	        if (this.index - start.offset < len) {
	            throw this._createError(unexpectedCharacterErrorMsg(this.peek), this._getSpan(start, start));
	        }
	    };
	    _HtmlTokenizer.prototype._attemptUntilChar = function (char) {
	        while (this.peek !== char) {
	            this._advance();
	        }
	    };
	    _HtmlTokenizer.prototype._readChar = function (decodeEntities) {
	        if (decodeEntities && this.peek === $AMPERSAND) {
	            return this._decodeEntity();
	        }
	        else {
	            var index = this.index;
	            this._advance();
	            return this.input[index];
	        }
	    };
	    _HtmlTokenizer.prototype._decodeEntity = function () {
	        var start = this._getLocation();
	        this._advance();
	        if (this._attemptCharCode($HASH)) {
	            var isHex = this._attemptCharCode($x) || this._attemptCharCode($X);
	            var numberStart = this._getLocation().offset;
	            this._attemptCharCodeUntilFn(isDigitEntityEnd);
	            if (this.peek != $SEMICOLON) {
	                throw this._createError(unexpectedCharacterErrorMsg(this.peek), this._getSpan());
	            }
	            this._advance();
	            var strNum = this.input.substring(numberStart, this.index - 1);
	            try {
	                var charCode = lang_1.NumberWrapper.parseInt(strNum, isHex ? 16 : 10);
	                return lang_1.StringWrapper.fromCharCode(charCode);
	            }
	            catch (e) {
	                var entity = this.input.substring(start.offset + 1, this.index - 1);
	                throw this._createError(unknownEntityErrorMsg(entity), this._getSpan(start));
	            }
	        }
	        else {
	            var startPosition = this._savePosition();
	            this._attemptCharCodeUntilFn(isNamedEntityEnd);
	            if (this.peek != $SEMICOLON) {
	                this._restorePosition(startPosition);
	                return '&';
	            }
	            this._advance();
	            var name_1 = this.input.substring(start.offset + 1, this.index - 1);
	            var char = html_tags_1.NAMED_ENTITIES[name_1];
	            if (lang_1.isBlank(char)) {
	                throw this._createError(unknownEntityErrorMsg(name_1), this._getSpan(start));
	            }
	            return char;
	        }
	    };
	    _HtmlTokenizer.prototype._consumeRawText = function (decodeEntities, firstCharOfEnd, attemptEndRest) {
	        var tagCloseStart;
	        var textStart = this._getLocation();
	        this._beginToken(decodeEntities ? HtmlTokenType.ESCAPABLE_RAW_TEXT : HtmlTokenType.RAW_TEXT, textStart);
	        var parts = [];
	        while (true) {
	            tagCloseStart = this._getLocation();
	            if (this._attemptCharCode(firstCharOfEnd) && attemptEndRest()) {
	                break;
	            }
	            if (this.index > tagCloseStart.offset) {
	                parts.push(this.input.substring(tagCloseStart.offset, this.index));
	            }
	            while (this.peek !== firstCharOfEnd) {
	                parts.push(this._readChar(decodeEntities));
	            }
	        }
	        return this._endToken([this._processCarriageReturns(parts.join(''))], tagCloseStart);
	    };
	    _HtmlTokenizer.prototype._consumeComment = function (start) {
	        var _this = this;
	        this._beginToken(HtmlTokenType.COMMENT_START, start);
	        this._requireCharCode($MINUS);
	        this._endToken([]);
	        var textToken = this._consumeRawText(false, $MINUS, function () { return _this._attemptStr('->'); });
	        this._beginToken(HtmlTokenType.COMMENT_END, textToken.sourceSpan.end);
	        this._endToken([]);
	    };
	    _HtmlTokenizer.prototype._consumeCdata = function (start) {
	        var _this = this;
	        this._beginToken(HtmlTokenType.CDATA_START, start);
	        this._requireStr('CDATA[');
	        this._endToken([]);
	        var textToken = this._consumeRawText(false, $RBRACKET, function () { return _this._attemptStr(']>'); });
	        this._beginToken(HtmlTokenType.CDATA_END, textToken.sourceSpan.end);
	        this._endToken([]);
	    };
	    _HtmlTokenizer.prototype._consumeDocType = function (start) {
	        this._beginToken(HtmlTokenType.DOC_TYPE, start);
	        this._attemptUntilChar($GT);
	        this._advance();
	        this._endToken([this.input.substring(start.offset + 2, this.index - 1)]);
	    };
	    _HtmlTokenizer.prototype._consumePrefixAndName = function () {
	        var nameOrPrefixStart = this.index;
	        var prefix = null;
	        while (this.peek !== $COLON && !isPrefixEnd(this.peek)) {
	            this._advance();
	        }
	        var nameStart;
	        if (this.peek === $COLON) {
	            this._advance();
	            prefix = this.input.substring(nameOrPrefixStart, this.index - 1);
	            nameStart = this.index;
	        }
	        else {
	            nameStart = nameOrPrefixStart;
	        }
	        this._requireCharCodeUntilFn(isNameEnd, this.index === nameStart ? 1 : 0);
	        var name = this.input.substring(nameStart, this.index);
	        return [prefix, name];
	    };
	    _HtmlTokenizer.prototype._consumeTagOpen = function (start) {
	        var savedPos = this._savePosition();
	        var lowercaseTagName;
	        try {
	            if (!isAsciiLetter(this.peek)) {
	                throw this._createError(unexpectedCharacterErrorMsg(this.peek), this._getSpan());
	            }
	            var nameStart = this.index;
	            this._consumeTagOpenStart(start);
	            lowercaseTagName = this.input.substring(nameStart, this.index).toLowerCase();
	            this._attemptCharCodeUntilFn(isNotWhitespace);
	            while (this.peek !== $SLASH && this.peek !== $GT) {
	                this._consumeAttributeName();
	                this._attemptCharCodeUntilFn(isNotWhitespace);
	                if (this._attemptCharCode($EQ)) {
	                    this._attemptCharCodeUntilFn(isNotWhitespace);
	                    this._consumeAttributeValue();
	                }
	                this._attemptCharCodeUntilFn(isNotWhitespace);
	            }
	            this._consumeTagOpenEnd();
	        }
	        catch (e) {
	            if (e instanceof ControlFlowError) {
	                // When the start tag is invalid, assume we want a "<"
	                this._restorePosition(savedPos);
	                // Back to back text tokens are merged at the end
	                this._beginToken(HtmlTokenType.TEXT, start);
	                this._endToken(['<']);
	                return;
	            }
	            throw e;
	        }
	        var contentTokenType = html_tags_1.getHtmlTagDefinition(lowercaseTagName).contentType;
	        if (contentTokenType === html_tags_1.HtmlTagContentType.RAW_TEXT) {
	            this._consumeRawTextWithTagClose(lowercaseTagName, false);
	        }
	        else if (contentTokenType === html_tags_1.HtmlTagContentType.ESCAPABLE_RAW_TEXT) {
	            this._consumeRawTextWithTagClose(lowercaseTagName, true);
	        }
	    };
	    _HtmlTokenizer.prototype._consumeRawTextWithTagClose = function (lowercaseTagName, decodeEntities) {
	        var _this = this;
	        var textToken = this._consumeRawText(decodeEntities, $LT, function () {
	            if (!_this._attemptCharCode($SLASH))
	                return false;
	            _this._attemptCharCodeUntilFn(isNotWhitespace);
	            if (!_this._attemptStrCaseInsensitive(lowercaseTagName))
	                return false;
	            _this._attemptCharCodeUntilFn(isNotWhitespace);
	            if (!_this._attemptCharCode($GT))
	                return false;
	            return true;
	        });
	        this._beginToken(HtmlTokenType.TAG_CLOSE, textToken.sourceSpan.end);
	        this._endToken([null, lowercaseTagName]);
	    };
	    _HtmlTokenizer.prototype._consumeTagOpenStart = function (start) {
	        this._beginToken(HtmlTokenType.TAG_OPEN_START, start);
	        var parts = this._consumePrefixAndName();
	        this._endToken(parts);
	    };
	    _HtmlTokenizer.prototype._consumeAttributeName = function () {
	        this._beginToken(HtmlTokenType.ATTR_NAME);
	        var prefixAndName = this._consumePrefixAndName();
	        this._endToken(prefixAndName);
	    };
	    _HtmlTokenizer.prototype._consumeAttributeValue = function () {
	        this._beginToken(HtmlTokenType.ATTR_VALUE);
	        var value;
	        if (this.peek === $SQ || this.peek === $DQ) {
	            var quoteChar = this.peek;
	            this._advance();
	            var parts = [];
	            while (this.peek !== quoteChar) {
	                parts.push(this._readChar(true));
	            }
	            value = parts.join('');
	            this._advance();
	        }
	        else {
	            var valueStart = this.index;
	            this._requireCharCodeUntilFn(isNameEnd, 1);
	            value = this.input.substring(valueStart, this.index);
	        }
	        this._endToken([this._processCarriageReturns(value)]);
	    };
	    _HtmlTokenizer.prototype._consumeTagOpenEnd = function () {
	        var tokenType = this._attemptCharCode($SLASH) ? HtmlTokenType.TAG_OPEN_END_VOID :
	            HtmlTokenType.TAG_OPEN_END;
	        this._beginToken(tokenType);
	        this._requireCharCode($GT);
	        this._endToken([]);
	    };
	    _HtmlTokenizer.prototype._consumeTagClose = function (start) {
	        this._beginToken(HtmlTokenType.TAG_CLOSE, start);
	        this._attemptCharCodeUntilFn(isNotWhitespace);
	        var prefixAndName;
	        prefixAndName = this._consumePrefixAndName();
	        this._attemptCharCodeUntilFn(isNotWhitespace);
	        this._requireCharCode($GT);
	        this._endToken(prefixAndName);
	    };
	    _HtmlTokenizer.prototype._consumeExpansionFormStart = function () {
	        this._beginToken(HtmlTokenType.EXPANSION_FORM_START, this._getLocation());
	        this._requireCharCode($LBRACE);
	        this._endToken([]);
	        this._beginToken(HtmlTokenType.RAW_TEXT, this._getLocation());
	        var condition = this._readUntil($COMMA);
	        this._endToken([condition], this._getLocation());
	        this._requireCharCode($COMMA);
	        this._attemptCharCodeUntilFn(isNotWhitespace);
	        this._beginToken(HtmlTokenType.RAW_TEXT, this._getLocation());
	        var type = this._readUntil($COMMA);
	        this._endToken([type], this._getLocation());
	        this._requireCharCode($COMMA);
	        this._attemptCharCodeUntilFn(isNotWhitespace);
	        this.expansionCaseStack.push(HtmlTokenType.EXPANSION_FORM_START);
	    };
	    _HtmlTokenizer.prototype._consumeExpansionCaseStart = function () {
	        this._requireCharCode($EQ);
	        this._beginToken(HtmlTokenType.EXPANSION_CASE_VALUE, this._getLocation());
	        var value = this._readUntil($LBRACE).trim();
	        this._endToken([value], this._getLocation());
	        this._attemptCharCodeUntilFn(isNotWhitespace);
	        this._beginToken(HtmlTokenType.EXPANSION_CASE_EXP_START, this._getLocation());
	        this._requireCharCode($LBRACE);
	        this._endToken([], this._getLocation());
	        this._attemptCharCodeUntilFn(isNotWhitespace);
	        this.expansionCaseStack.push(HtmlTokenType.EXPANSION_CASE_EXP_START);
	    };
	    _HtmlTokenizer.prototype._consumeExpansionCaseEnd = function () {
	        this._beginToken(HtmlTokenType.EXPANSION_CASE_EXP_END, this._getLocation());
	        this._requireCharCode($RBRACE);
	        this._endToken([], this._getLocation());
	        this._attemptCharCodeUntilFn(isNotWhitespace);
	        this.expansionCaseStack.pop();
	    };
	    _HtmlTokenizer.prototype._consumeExpansionFormEnd = function () {
	        this._beginToken(HtmlTokenType.EXPANSION_FORM_END, this._getLocation());
	        this._requireCharCode($RBRACE);
	        this._endToken([]);
	        this.expansionCaseStack.pop();
	    };
	    _HtmlTokenizer.prototype._consumeText = function () {
	        var start = this._getLocation();
	        this._beginToken(HtmlTokenType.TEXT, start);
	        var parts = [];
	        var interpolation = false;
	        if (this.peek === $LBRACE && this.nextPeek === $LBRACE) {
	            parts.push(this._readChar(true));
	            parts.push(this._readChar(true));
	            interpolation = true;
	        }
	        else {
	            parts.push(this._readChar(true));
	        }
	        while (!this.isTextEnd(interpolation)) {
	            if (this.peek === $LBRACE && this.nextPeek === $LBRACE) {
	                parts.push(this._readChar(true));
	                parts.push(this._readChar(true));
	                interpolation = true;
	            }
	            else if (this.peek === $RBRACE && this.nextPeek === $RBRACE && interpolation) {
	                parts.push(this._readChar(true));
	                parts.push(this._readChar(true));
	                interpolation = false;
	            }
	            else {
	                parts.push(this._readChar(true));
	            }
	        }
	        this._endToken([this._processCarriageReturns(parts.join(''))]);
	    };
	    _HtmlTokenizer.prototype.isTextEnd = function (interpolation) {
	        if (this.peek === $LT || this.peek === $EOF)
	            return true;
	        if (this.tokenizeExpansionForms) {
	            if (isSpecialFormStart(this.peek, this.nextPeek))
	                return true;
	            if (this.peek === $RBRACE && !interpolation &&
	                (this.isInExpansionCase() || this.isInExpansionForm()))
	                return true;
	        }
	        return false;
	    };
	    _HtmlTokenizer.prototype._savePosition = function () {
	        return [this.peek, this.index, this.column, this.line, this.tokens.length];
	    };
	    _HtmlTokenizer.prototype._readUntil = function (char) {
	        var start = this.index;
	        this._attemptUntilChar(char);
	        return this.input.substring(start, this.index);
	    };
	    _HtmlTokenizer.prototype._restorePosition = function (position) {
	        this.peek = position[0];
	        this.index = position[1];
	        this.column = position[2];
	        this.line = position[3];
	        var nbTokens = position[4];
	        if (nbTokens < this.tokens.length) {
	            // remove any extra tokens
	            this.tokens = collection_1.ListWrapper.slice(this.tokens, 0, nbTokens);
	        }
	    };
	    _HtmlTokenizer.prototype.isInExpansionCase = function () {
	        return this.expansionCaseStack.length > 0 &&
	            this.expansionCaseStack[this.expansionCaseStack.length - 1] ===
	                HtmlTokenType.EXPANSION_CASE_EXP_START;
	    };
	    _HtmlTokenizer.prototype.isInExpansionForm = function () {
	        return this.expansionCaseStack.length > 0 &&
	            this.expansionCaseStack[this.expansionCaseStack.length - 1] ===
	                HtmlTokenType.EXPANSION_FORM_START;
	    };
	    return _HtmlTokenizer;
	}());
	function isNotWhitespace(code) {
	    return !isWhitespace(code) || code === $EOF;
	}
	function isWhitespace(code) {
	    return (code >= $TAB && code <= $SPACE) || (code === $NBSP);
	}
	function isNameEnd(code) {
	    return isWhitespace(code) || code === $GT || code === $SLASH || code === $SQ || code === $DQ ||
	        code === $EQ;
	}
	function isPrefixEnd(code) {
	    return (code < $a || $z < code) && (code < $A || $Z < code) && (code < $0 || code > $9);
	}
	function isDigitEntityEnd(code) {
	    return code == $SEMICOLON || code == $EOF || !isAsciiHexDigit(code);
	}
	function isNamedEntityEnd(code) {
	    return code == $SEMICOLON || code == $EOF || !isAsciiLetter(code);
	}
	function isSpecialFormStart(peek, nextPeek) {
	    return peek === $LBRACE && nextPeek != $LBRACE;
	}
	function isAsciiLetter(code) {
	    return code >= $a && code <= $z || code >= $A && code <= $Z;
	}
	function isAsciiHexDigit(code) {
	    return code >= $a && code <= $f || code >= $A && code <= $F || code >= $0 && code <= $9;
	}
	function compareCharCodeCaseInsensitive(code1, code2) {
	    return toUpperCaseCharCode(code1) == toUpperCaseCharCode(code2);
	}
	function toUpperCaseCharCode(code) {
	    return code >= $a && code <= $z ? code - $a + $A : code;
	}
	function mergeTextTokens(srcTokens) {
	    var dstTokens = [];
	    var lastDstToken;
	    for (var i = 0; i < srcTokens.length; i++) {
	        var token = srcTokens[i];
	        if (lang_1.isPresent(lastDstToken) && lastDstToken.type == HtmlTokenType.TEXT &&
	            token.type == HtmlTokenType.TEXT) {
	            lastDstToken.parts[0] += token.parts[0];
	            lastDstToken.sourceSpan.end = token.sourceSpan.end;
	        }
	        else {
	            lastDstToken = token;
	            dstTokens.push(lastDstToken);
	        }
	    }
	    return dstTokens;
	}


/***/ },
/* 149 */
/***/ function(module, exports) {

	"use strict";
	var ParseLocation = (function () {
	    function ParseLocation(file, offset, line, col) {
	        this.file = file;
	        this.offset = offset;
	        this.line = line;
	        this.col = col;
	    }
	    ParseLocation.prototype.toString = function () { return this.file.url + "@" + this.line + ":" + this.col; };
	    return ParseLocation;
	}());
	exports.ParseLocation = ParseLocation;
	var ParseSourceFile = (function () {
	    function ParseSourceFile(content, url) {
	        this.content = content;
	        this.url = url;
	    }
	    return ParseSourceFile;
	}());
	exports.ParseSourceFile = ParseSourceFile;
	var ParseSourceSpan = (function () {
	    function ParseSourceSpan(start, end) {
	        this.start = start;
	        this.end = end;
	    }
	    ParseSourceSpan.prototype.toString = function () {
	        return this.start.file.content.substring(this.start.offset, this.end.offset);
	    };
	    return ParseSourceSpan;
	}());
	exports.ParseSourceSpan = ParseSourceSpan;
	(function (ParseErrorLevel) {
	    ParseErrorLevel[ParseErrorLevel["WARNING"] = 0] = "WARNING";
	    ParseErrorLevel[ParseErrorLevel["FATAL"] = 1] = "FATAL";
	})(exports.ParseErrorLevel || (exports.ParseErrorLevel = {}));
	var ParseErrorLevel = exports.ParseErrorLevel;
	var ParseError = (function () {
	    function ParseError(span, msg, level) {
	        if (level === void 0) { level = ParseErrorLevel.FATAL; }
	        this.span = span;
	        this.msg = msg;
	        this.level = level;
	    }
	    ParseError.prototype.toString = function () {
	        var source = this.span.start.file.content;
	        var ctxStart = this.span.start.offset;
	        if (ctxStart > source.length - 1) {
	            ctxStart = source.length - 1;
	        }
	        var ctxEnd = ctxStart;
	        var ctxLen = 0;
	        var ctxLines = 0;
	        while (ctxLen < 100 && ctxStart > 0) {
	            ctxStart--;
	            ctxLen++;
	            if (source[ctxStart] == "\n") {
	                if (++ctxLines == 3) {
	                    break;
	                }
	            }
	        }
	        ctxLen = 0;
	        ctxLines = 0;
	        while (ctxLen < 100 && ctxEnd < source.length - 1) {
	            ctxEnd++;
	            ctxLen++;
	            if (source[ctxEnd] == "\n") {
	                if (++ctxLines == 3) {
	                    break;
	                }
	            }
	        }
	        var context = source.substring(ctxStart, this.span.start.offset) + '[ERROR ->]' +
	            source.substring(this.span.start.offset, ctxEnd + 1);
	        return this.msg + " (\"" + context + "\"): " + this.span.start;
	    };
	    return ParseError;
	}());
	exports.ParseError = ParseError;


/***/ },
/* 150 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	// see http://www.w3.org/TR/html51/syntax.html#named-character-references
	// see https://html.spec.whatwg.org/multipage/entities.json
	// This list is not exhaustive to keep the compiler footprint low.
	// The `&#123;` / `&#x1ab;` syntax should be used when the named character reference does not exist.
	exports.NAMED_ENTITIES = {
	    'Aacute': '\u00C1',
	    'aacute': '\u00E1',
	    'Acirc': '\u00C2',
	    'acirc': '\u00E2',
	    'acute': '\u00B4',
	    'AElig': '\u00C6',
	    'aelig': '\u00E6',
	    'Agrave': '\u00C0',
	    'agrave': '\u00E0',
	    'alefsym': '\u2135',
	    'Alpha': '\u0391',
	    'alpha': '\u03B1',
	    'amp': '&',
	    'and': '\u2227',
	    'ang': '\u2220',
	    'apos': '\u0027',
	    'Aring': '\u00C5',
	    'aring': '\u00E5',
	    'asymp': '\u2248',
	    'Atilde': '\u00C3',
	    'atilde': '\u00E3',
	    'Auml': '\u00C4',
	    'auml': '\u00E4',
	    'bdquo': '\u201E',
	    'Beta': '\u0392',
	    'beta': '\u03B2',
	    'brvbar': '\u00A6',
	    'bull': '\u2022',
	    'cap': '\u2229',
	    'Ccedil': '\u00C7',
	    'ccedil': '\u00E7',
	    'cedil': '\u00B8',
	    'cent': '\u00A2',
	    'Chi': '\u03A7',
	    'chi': '\u03C7',
	    'circ': '\u02C6',
	    'clubs': '\u2663',
	    'cong': '\u2245',
	    'copy': '\u00A9',
	    'crarr': '\u21B5',
	    'cup': '\u222A',
	    'curren': '\u00A4',
	    'dagger': '\u2020',
	    'Dagger': '\u2021',
	    'darr': '\u2193',
	    'dArr': '\u21D3',
	    'deg': '\u00B0',
	    'Delta': '\u0394',
	    'delta': '\u03B4',
	    'diams': '\u2666',
	    'divide': '\u00F7',
	    'Eacute': '\u00C9',
	    'eacute': '\u00E9',
	    'Ecirc': '\u00CA',
	    'ecirc': '\u00EA',
	    'Egrave': '\u00C8',
	    'egrave': '\u00E8',
	    'empty': '\u2205',
	    'emsp': '\u2003',
	    'ensp': '\u2002',
	    'Epsilon': '\u0395',
	    'epsilon': '\u03B5',
	    'equiv': '\u2261',
	    'Eta': '\u0397',
	    'eta': '\u03B7',
	    'ETH': '\u00D0',
	    'eth': '\u00F0',
	    'Euml': '\u00CB',
	    'euml': '\u00EB',
	    'euro': '\u20AC',
	    'exist': '\u2203',
	    'fnof': '\u0192',
	    'forall': '\u2200',
	    'frac12': '\u00BD',
	    'frac14': '\u00BC',
	    'frac34': '\u00BE',
	    'frasl': '\u2044',
	    'Gamma': '\u0393',
	    'gamma': '\u03B3',
	    'ge': '\u2265',
	    'gt': '>',
	    'harr': '\u2194',
	    'hArr': '\u21D4',
	    'hearts': '\u2665',
	    'hellip': '\u2026',
	    'Iacute': '\u00CD',
	    'iacute': '\u00ED',
	    'Icirc': '\u00CE',
	    'icirc': '\u00EE',
	    'iexcl': '\u00A1',
	    'Igrave': '\u00CC',
	    'igrave': '\u00EC',
	    'image': '\u2111',
	    'infin': '\u221E',
	    'int': '\u222B',
	    'Iota': '\u0399',
	    'iota': '\u03B9',
	    'iquest': '\u00BF',
	    'isin': '\u2208',
	    'Iuml': '\u00CF',
	    'iuml': '\u00EF',
	    'Kappa': '\u039A',
	    'kappa': '\u03BA',
	    'Lambda': '\u039B',
	    'lambda': '\u03BB',
	    'lang': '\u27E8',
	    'laquo': '\u00AB',
	    'larr': '\u2190',
	    'lArr': '\u21D0',
	    'lceil': '\u2308',
	    'ldquo': '\u201C',
	    'le': '\u2264',
	    'lfloor': '\u230A',
	    'lowast': '\u2217',
	    'loz': '\u25CA',
	    'lrm': '\u200E',
	    'lsaquo': '\u2039',
	    'lsquo': '\u2018',
	    'lt': '<',
	    'macr': '\u00AF',
	    'mdash': '\u2014',
	    'micro': '\u00B5',
	    'middot': '\u00B7',
	    'minus': '\u2212',
	    'Mu': '\u039C',
	    'mu': '\u03BC',
	    'nabla': '\u2207',
	    'nbsp': '\u00A0',
	    'ndash': '\u2013',
	    'ne': '\u2260',
	    'ni': '\u220B',
	    'not': '\u00AC',
	    'notin': '\u2209',
	    'nsub': '\u2284',
	    'Ntilde': '\u00D1',
	    'ntilde': '\u00F1',
	    'Nu': '\u039D',
	    'nu': '\u03BD',
	    'Oacute': '\u00D3',
	    'oacute': '\u00F3',
	    'Ocirc': '\u00D4',
	    'ocirc': '\u00F4',
	    'OElig': '\u0152',
	    'oelig': '\u0153',
	    'Ograve': '\u00D2',
	    'ograve': '\u00F2',
	    'oline': '\u203E',
	    'Omega': '\u03A9',
	    'omega': '\u03C9',
	    'Omicron': '\u039F',
	    'omicron': '\u03BF',
	    'oplus': '\u2295',
	    'or': '\u2228',
	    'ordf': '\u00AA',
	    'ordm': '\u00BA',
	    'Oslash': '\u00D8',
	    'oslash': '\u00F8',
	    'Otilde': '\u00D5',
	    'otilde': '\u00F5',
	    'otimes': '\u2297',
	    'Ouml': '\u00D6',
	    'ouml': '\u00F6',
	    'para': '\u00B6',
	    'permil': '\u2030',
	    'perp': '\u22A5',
	    'Phi': '\u03A6',
	    'phi': '\u03C6',
	    'Pi': '\u03A0',
	    'pi': '\u03C0',
	    'piv': '\u03D6',
	    'plusmn': '\u00B1',
	    'pound': '\u00A3',
	    'prime': '\u2032',
	    'Prime': '\u2033',
	    'prod': '\u220F',
	    'prop': '\u221D',
	    'Psi': '\u03A8',
	    'psi': '\u03C8',
	    'quot': '\u0022',
	    'radic': '\u221A',
	    'rang': '\u27E9',
	    'raquo': '\u00BB',
	    'rarr': '\u2192',
	    'rArr': '\u21D2',
	    'rceil': '\u2309',
	    'rdquo': '\u201D',
	    'real': '\u211C',
	    'reg': '\u00AE',
	    'rfloor': '\u230B',
	    'Rho': '\u03A1',
	    'rho': '\u03C1',
	    'rlm': '\u200F',
	    'rsaquo': '\u203A',
	    'rsquo': '\u2019',
	    'sbquo': '\u201A',
	    'Scaron': '\u0160',
	    'scaron': '\u0161',
	    'sdot': '\u22C5',
	    'sect': '\u00A7',
	    'shy': '\u00AD',
	    'Sigma': '\u03A3',
	    'sigma': '\u03C3',
	    'sigmaf': '\u03C2',
	    'sim': '\u223C',
	    'spades': '\u2660',
	    'sub': '\u2282',
	    'sube': '\u2286',
	    'sum': '\u2211',
	    'sup': '\u2283',
	    'sup1': '\u00B9',
	    'sup2': '\u00B2',
	    'sup3': '\u00B3',
	    'supe': '\u2287',
	    'szlig': '\u00DF',
	    'Tau': '\u03A4',
	    'tau': '\u03C4',
	    'there4': '\u2234',
	    'Theta': '\u0398',
	    'theta': '\u03B8',
	    'thetasym': '\u03D1',
	    'thinsp': '\u2009',
	    'THORN': '\u00DE',
	    'thorn': '\u00FE',
	    'tilde': '\u02DC',
	    'times': '\u00D7',
	    'trade': '\u2122',
	    'Uacute': '\u00DA',
	    'uacute': '\u00FA',
	    'uarr': '\u2191',
	    'uArr': '\u21D1',
	    'Ucirc': '\u00DB',
	    'ucirc': '\u00FB',
	    'Ugrave': '\u00D9',
	    'ugrave': '\u00F9',
	    'uml': '\u00A8',
	    'upsih': '\u03D2',
	    'Upsilon': '\u03A5',
	    'upsilon': '\u03C5',
	    'Uuml': '\u00DC',
	    'uuml': '\u00FC',
	    'weierp': '\u2118',
	    'Xi': '\u039E',
	    'xi': '\u03BE',
	    'Yacute': '\u00DD',
	    'yacute': '\u00FD',
	    'yen': '\u00A5',
	    'yuml': '\u00FF',
	    'Yuml': '\u0178',
	    'Zeta': '\u0396',
	    'zeta': '\u03B6',
	    'zwj': '\u200D',
	    'zwnj': '\u200C',
	};
	(function (HtmlTagContentType) {
	    HtmlTagContentType[HtmlTagContentType["RAW_TEXT"] = 0] = "RAW_TEXT";
	    HtmlTagContentType[HtmlTagContentType["ESCAPABLE_RAW_TEXT"] = 1] = "ESCAPABLE_RAW_TEXT";
	    HtmlTagContentType[HtmlTagContentType["PARSABLE_DATA"] = 2] = "PARSABLE_DATA";
	})(exports.HtmlTagContentType || (exports.HtmlTagContentType = {}));
	var HtmlTagContentType = exports.HtmlTagContentType;
	var HtmlTagDefinition = (function () {
	    function HtmlTagDefinition(_a) {
	        var _this = this;
	        var _b = _a === void 0 ? {} : _a, closedByChildren = _b.closedByChildren, requiredParents = _b.requiredParents, implicitNamespacePrefix = _b.implicitNamespacePrefix, contentType = _b.contentType, closedByParent = _b.closedByParent, isVoid = _b.isVoid, ignoreFirstLf = _b.ignoreFirstLf;
	        this.closedByChildren = {};
	        this.closedByParent = false;
	        if (lang_1.isPresent(closedByChildren) && closedByChildren.length > 0) {
	            closedByChildren.forEach(function (tagName) { return _this.closedByChildren[tagName] = true; });
	        }
	        this.isVoid = lang_1.normalizeBool(isVoid);
	        this.closedByParent = lang_1.normalizeBool(closedByParent) || this.isVoid;
	        if (lang_1.isPresent(requiredParents) && requiredParents.length > 0) {
	            this.requiredParents = {};
	            this.parentToAdd = requiredParents[0];
	            requiredParents.forEach(function (tagName) { return _this.requiredParents[tagName] = true; });
	        }
	        this.implicitNamespacePrefix = implicitNamespacePrefix;
	        this.contentType = lang_1.isPresent(contentType) ? contentType : HtmlTagContentType.PARSABLE_DATA;
	        this.ignoreFirstLf = lang_1.normalizeBool(ignoreFirstLf);
	    }
	    HtmlTagDefinition.prototype.requireExtraParent = function (currentParent) {
	        if (lang_1.isBlank(this.requiredParents)) {
	            return false;
	        }
	        if (lang_1.isBlank(currentParent)) {
	            return true;
	        }
	        var lcParent = currentParent.toLowerCase();
	        return this.requiredParents[lcParent] != true && lcParent != 'template';
	    };
	    HtmlTagDefinition.prototype.isClosedByChild = function (name) {
	        return this.isVoid || lang_1.normalizeBool(this.closedByChildren[name.toLowerCase()]);
	    };
	    return HtmlTagDefinition;
	}());
	exports.HtmlTagDefinition = HtmlTagDefinition;
	// see http://www.w3.org/TR/html51/syntax.html#optional-tags
	// This implementation does not fully conform to the HTML5 spec.
	var TAG_DEFINITIONS = {
	    'base': new HtmlTagDefinition({ isVoid: true }),
	    'meta': new HtmlTagDefinition({ isVoid: true }),
	    'area': new HtmlTagDefinition({ isVoid: true }),
	    'embed': new HtmlTagDefinition({ isVoid: true }),
	    'link': new HtmlTagDefinition({ isVoid: true }),
	    'img': new HtmlTagDefinition({ isVoid: true }),
	    'input': new HtmlTagDefinition({ isVoid: true }),
	    'param': new HtmlTagDefinition({ isVoid: true }),
	    'hr': new HtmlTagDefinition({ isVoid: true }),
	    'br': new HtmlTagDefinition({ isVoid: true }),
	    'source': new HtmlTagDefinition({ isVoid: true }),
	    'track': new HtmlTagDefinition({ isVoid: true }),
	    'wbr': new HtmlTagDefinition({ isVoid: true }),
	    'p': new HtmlTagDefinition({
	        closedByChildren: [
	            'address',
	            'article',
	            'aside',
	            'blockquote',
	            'div',
	            'dl',
	            'fieldset',
	            'footer',
	            'form',
	            'h1',
	            'h2',
	            'h3',
	            'h4',
	            'h5',
	            'h6',
	            'header',
	            'hgroup',
	            'hr',
	            'main',
	            'nav',
	            'ol',
	            'p',
	            'pre',
	            'section',
	            'table',
	            'ul'
	        ],
	        closedByParent: true
	    }),
	    'thead': new HtmlTagDefinition({ closedByChildren: ['tbody', 'tfoot'] }),
	    'tbody': new HtmlTagDefinition({ closedByChildren: ['tbody', 'tfoot'], closedByParent: true }),
	    'tfoot': new HtmlTagDefinition({ closedByChildren: ['tbody'], closedByParent: true }),
	    'tr': new HtmlTagDefinition({
	        closedByChildren: ['tr'],
	        requiredParents: ['tbody', 'tfoot', 'thead'],
	        closedByParent: true
	    }),
	    'td': new HtmlTagDefinition({ closedByChildren: ['td', 'th'], closedByParent: true }),
	    'th': new HtmlTagDefinition({ closedByChildren: ['td', 'th'], closedByParent: true }),
	    'col': new HtmlTagDefinition({ requiredParents: ['colgroup'], isVoid: true }),
	    'svg': new HtmlTagDefinition({ implicitNamespacePrefix: 'svg' }),
	    'math': new HtmlTagDefinition({ implicitNamespacePrefix: 'math' }),
	    'li': new HtmlTagDefinition({ closedByChildren: ['li'], closedByParent: true }),
	    'dt': new HtmlTagDefinition({ closedByChildren: ['dt', 'dd'] }),
	    'dd': new HtmlTagDefinition({ closedByChildren: ['dt', 'dd'], closedByParent: true }),
	    'rb': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }),
	    'rt': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }),
	    'rtc': new HtmlTagDefinition({ closedByChildren: ['rb', 'rtc', 'rp'], closedByParent: true }),
	    'rp': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }),
	    'optgroup': new HtmlTagDefinition({ closedByChildren: ['optgroup'], closedByParent: true }),
	    'option': new HtmlTagDefinition({ closedByChildren: ['option', 'optgroup'], closedByParent: true }),
	    'pre': new HtmlTagDefinition({ ignoreFirstLf: true }),
	    'listing': new HtmlTagDefinition({ ignoreFirstLf: true }),
	    'style': new HtmlTagDefinition({ contentType: HtmlTagContentType.RAW_TEXT }),
	    'script': new HtmlTagDefinition({ contentType: HtmlTagContentType.RAW_TEXT }),
	    'title': new HtmlTagDefinition({ contentType: HtmlTagContentType.ESCAPABLE_RAW_TEXT }),
	    'textarea': new HtmlTagDefinition({ contentType: HtmlTagContentType.ESCAPABLE_RAW_TEXT, ignoreFirstLf: true }),
	};
	var DEFAULT_TAG_DEFINITION = new HtmlTagDefinition();
	function getHtmlTagDefinition(tagName) {
	    var result = TAG_DEFINITIONS[tagName.toLowerCase()];
	    return lang_1.isPresent(result) ? result : DEFAULT_TAG_DEFINITION;
	}
	exports.getHtmlTagDefinition = getHtmlTagDefinition;
	var NS_PREFIX_RE = /^@([^:]+):(.+)/g;
	function splitNsName(elementName) {
	    if (elementName[0] != '@') {
	        return [null, elementName];
	    }
	    var match = lang_1.RegExpWrapper.firstMatch(NS_PREFIX_RE, elementName);
	    return [match[1], match[2]];
	}
	exports.splitNsName = splitNsName;
	function getNsPrefix(elementName) {
	    return splitNsName(elementName)[0];
	}
	exports.getNsPrefix = getNsPrefix;
	function mergeNsAndName(prefix, localName) {
	    return lang_1.isPresent(prefix) ? "@" + prefix + ":" + localName : localName;
	}
	exports.mergeNsAndName = mergeNsAndName;


/***/ },
/* 151 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var _EMPTY_ATTR_VALUE = '';
	// TODO: Can't use `const` here as
	// in Dart this is not transpiled into `final` yet...
	var _SELECTOR_REGEXP = lang_1.RegExpWrapper.create('(\\:not\\()|' +
	    '([-\\w]+)|' +
	    '(?:\\.([-\\w]+))|' +
	    '(?:\\[([-\\w*]+)(?:=([^\\]]*))?\\])|' +
	    '(\\))|' +
	    '(\\s*,\\s*)'); // ","
	/**
	 * A css selector contains an element name,
	 * css classes and attribute/value pairs with the purpose
	 * of selecting subsets out of them.
	 */
	var CssSelector = (function () {
	    function CssSelector() {
	        this.element = null;
	        this.classNames = [];
	        this.attrs = [];
	        this.notSelectors = [];
	    }
	    CssSelector.parse = function (selector) {
	        var results = [];
	        var _addResult = function (res, cssSel) {
	            if (cssSel.notSelectors.length > 0 && lang_1.isBlank(cssSel.element) &&
	                collection_1.ListWrapper.isEmpty(cssSel.classNames) && collection_1.ListWrapper.isEmpty(cssSel.attrs)) {
	                cssSel.element = "*";
	            }
	            res.push(cssSel);
	        };
	        var cssSelector = new CssSelector();
	        var matcher = lang_1.RegExpWrapper.matcher(_SELECTOR_REGEXP, selector);
	        var match;
	        var current = cssSelector;
	        var inNot = false;
	        while (lang_1.isPresent(match = lang_1.RegExpMatcherWrapper.next(matcher))) {
	            if (lang_1.isPresent(match[1])) {
	                if (inNot) {
	                    throw new exceptions_1.BaseException('Nesting :not is not allowed in a selector');
	                }
	                inNot = true;
	                current = new CssSelector();
	                cssSelector.notSelectors.push(current);
	            }
	            if (lang_1.isPresent(match[2])) {
	                current.setElement(match[2]);
	            }
	            if (lang_1.isPresent(match[3])) {
	                current.addClassName(match[3]);
	            }
	            if (lang_1.isPresent(match[4])) {
	                current.addAttribute(match[4], match[5]);
	            }
	            if (lang_1.isPresent(match[6])) {
	                inNot = false;
	                current = cssSelector;
	            }
	            if (lang_1.isPresent(match[7])) {
	                if (inNot) {
	                    throw new exceptions_1.BaseException('Multiple selectors in :not are not supported');
	                }
	                _addResult(results, cssSelector);
	                cssSelector = current = new CssSelector();
	            }
	        }
	        _addResult(results, cssSelector);
	        return results;
	    };
	    CssSelector.prototype.isElementSelector = function () {
	        return lang_1.isPresent(this.element) && collection_1.ListWrapper.isEmpty(this.classNames) &&
	            collection_1.ListWrapper.isEmpty(this.attrs) && this.notSelectors.length === 0;
	    };
	    CssSelector.prototype.setElement = function (element) {
	        if (element === void 0) { element = null; }
	        this.element = element;
	    };
	    /** Gets a template string for an element that matches the selector. */
	    CssSelector.prototype.getMatchingElementTemplate = function () {
	        var tagName = lang_1.isPresent(this.element) ? this.element : 'div';
	        var classAttr = this.classNames.length > 0 ? " class=\"" + this.classNames.join(' ') + "\"" : '';
	        var attrs = '';
	        for (var i = 0; i < this.attrs.length; i += 2) {
	            var attrName = this.attrs[i];
	            var attrValue = this.attrs[i + 1] !== '' ? "=\"" + this.attrs[i + 1] + "\"" : '';
	            attrs += " " + attrName + attrValue;
	        }
	        return "<" + tagName + classAttr + attrs + "></" + tagName + ">";
	    };
	    CssSelector.prototype.addAttribute = function (name, value) {
	        if (value === void 0) { value = _EMPTY_ATTR_VALUE; }
	        this.attrs.push(name);
	        if (lang_1.isPresent(value)) {
	            value = value.toLowerCase();
	        }
	        else {
	            value = _EMPTY_ATTR_VALUE;
	        }
	        this.attrs.push(value);
	    };
	    CssSelector.prototype.addClassName = function (name) { this.classNames.push(name.toLowerCase()); };
	    CssSelector.prototype.toString = function () {
	        var res = '';
	        if (lang_1.isPresent(this.element)) {
	            res += this.element;
	        }
	        if (lang_1.isPresent(this.classNames)) {
	            for (var i = 0; i < this.classNames.length; i++) {
	                res += '.' + this.classNames[i];
	            }
	        }
	        if (lang_1.isPresent(this.attrs)) {
	            for (var i = 0; i < this.attrs.length;) {
	                var attrName = this.attrs[i++];
	                var attrValue = this.attrs[i++];
	                res += '[' + attrName;
	                if (attrValue.length > 0) {
	                    res += '=' + attrValue;
	                }
	                res += ']';
	            }
	        }
	        this.notSelectors.forEach(function (notSelector) { return res += ":not(" + notSelector + ")"; });
	        return res;
	    };
	    return CssSelector;
	}());
	exports.CssSelector = CssSelector;
	/**
	 * Reads a list of CssSelectors and allows to calculate which ones
	 * are contained in a given CssSelector.
	 */
	var SelectorMatcher = (function () {
	    function SelectorMatcher() {
	        this._elementMap = new collection_1.Map();
	        this._elementPartialMap = new collection_1.Map();
	        this._classMap = new collection_1.Map();
	        this._classPartialMap = new collection_1.Map();
	        this._attrValueMap = new collection_1.Map();
	        this._attrValuePartialMap = new collection_1.Map();
	        this._listContexts = [];
	    }
	    SelectorMatcher.createNotMatcher = function (notSelectors) {
	        var notMatcher = new SelectorMatcher();
	        notMatcher.addSelectables(notSelectors, null);
	        return notMatcher;
	    };
	    SelectorMatcher.prototype.addSelectables = function (cssSelectors, callbackCtxt) {
	        var listContext = null;
	        if (cssSelectors.length > 1) {
	            listContext = new SelectorListContext(cssSelectors);
	            this._listContexts.push(listContext);
	        }
	        for (var i = 0; i < cssSelectors.length; i++) {
	            this._addSelectable(cssSelectors[i], callbackCtxt, listContext);
	        }
	    };
	    /**
	     * Add an object that can be found later on by calling `match`.
	     * @param cssSelector A css selector
	     * @param callbackCtxt An opaque object that will be given to the callback of the `match` function
	     */
	    SelectorMatcher.prototype._addSelectable = function (cssSelector, callbackCtxt, listContext) {
	        var matcher = this;
	        var element = cssSelector.element;
	        var classNames = cssSelector.classNames;
	        var attrs = cssSelector.attrs;
	        var selectable = new SelectorContext(cssSelector, callbackCtxt, listContext);
	        if (lang_1.isPresent(element)) {
	            var isTerminal = attrs.length === 0 && classNames.length === 0;
	            if (isTerminal) {
	                this._addTerminal(matcher._elementMap, element, selectable);
	            }
	            else {
	                matcher = this._addPartial(matcher._elementPartialMap, element);
	            }
	        }
	        if (lang_1.isPresent(classNames)) {
	            for (var index = 0; index < classNames.length; index++) {
	                var isTerminal = attrs.length === 0 && index === classNames.length - 1;
	                var className = classNames[index];
	                if (isTerminal) {
	                    this._addTerminal(matcher._classMap, className, selectable);
	                }
	                else {
	                    matcher = this._addPartial(matcher._classPartialMap, className);
	                }
	            }
	        }
	        if (lang_1.isPresent(attrs)) {
	            for (var index = 0; index < attrs.length;) {
	                var isTerminal = index === attrs.length - 2;
	                var attrName = attrs[index++];
	                var attrValue = attrs[index++];
	                if (isTerminal) {
	                    var terminalMap = matcher._attrValueMap;
	                    var terminalValuesMap = terminalMap.get(attrName);
	                    if (lang_1.isBlank(terminalValuesMap)) {
	                        terminalValuesMap = new collection_1.Map();
	                        terminalMap.set(attrName, terminalValuesMap);
	                    }
	                    this._addTerminal(terminalValuesMap, attrValue, selectable);
	                }
	                else {
	                    var parttialMap = matcher._attrValuePartialMap;
	                    var partialValuesMap = parttialMap.get(attrName);
	                    if (lang_1.isBlank(partialValuesMap)) {
	                        partialValuesMap = new collection_1.Map();
	                        parttialMap.set(attrName, partialValuesMap);
	                    }
	                    matcher = this._addPartial(partialValuesMap, attrValue);
	                }
	            }
	        }
	    };
	    SelectorMatcher.prototype._addTerminal = function (map, name, selectable) {
	        var terminalList = map.get(name);
	        if (lang_1.isBlank(terminalList)) {
	            terminalList = [];
	            map.set(name, terminalList);
	        }
	        terminalList.push(selectable);
	    };
	    SelectorMatcher.prototype._addPartial = function (map, name) {
	        var matcher = map.get(name);
	        if (lang_1.isBlank(matcher)) {
	            matcher = new SelectorMatcher();
	            map.set(name, matcher);
	        }
	        return matcher;
	    };
	    /**
	     * Find the objects that have been added via `addSelectable`
	     * whose css selector is contained in the given css selector.
	     * @param cssSelector A css selector
	     * @param matchedCallback This callback will be called with the object handed into `addSelectable`
	     * @return boolean true if a match was found
	    */
	    SelectorMatcher.prototype.match = function (cssSelector, matchedCallback) {
	        var result = false;
	        var element = cssSelector.element;
	        var classNames = cssSelector.classNames;
	        var attrs = cssSelector.attrs;
	        for (var i = 0; i < this._listContexts.length; i++) {
	            this._listContexts[i].alreadyMatched = false;
	        }
	        result = this._matchTerminal(this._elementMap, element, cssSelector, matchedCallback) || result;
	        result = this._matchPartial(this._elementPartialMap, element, cssSelector, matchedCallback) ||
	            result;
	        if (lang_1.isPresent(classNames)) {
	            for (var index = 0; index < classNames.length; index++) {
	                var className = classNames[index];
	                result =
	                    this._matchTerminal(this._classMap, className, cssSelector, matchedCallback) || result;
	                result =
	                    this._matchPartial(this._classPartialMap, className, cssSelector, matchedCallback) ||
	                        result;
	            }
	        }
	        if (lang_1.isPresent(attrs)) {
	            for (var index = 0; index < attrs.length;) {
	                var attrName = attrs[index++];
	                var attrValue = attrs[index++];
	                var terminalValuesMap = this._attrValueMap.get(attrName);
	                if (!lang_1.StringWrapper.equals(attrValue, _EMPTY_ATTR_VALUE)) {
	                    result = this._matchTerminal(terminalValuesMap, _EMPTY_ATTR_VALUE, cssSelector, matchedCallback) ||
	                        result;
	                }
	                result = this._matchTerminal(terminalValuesMap, attrValue, cssSelector, matchedCallback) ||
	                    result;
	                var partialValuesMap = this._attrValuePartialMap.get(attrName);
	                if (!lang_1.StringWrapper.equals(attrValue, _EMPTY_ATTR_VALUE)) {
	                    result = this._matchPartial(partialValuesMap, _EMPTY_ATTR_VALUE, cssSelector, matchedCallback) ||
	                        result;
	                }
	                result =
	                    this._matchPartial(partialValuesMap, attrValue, cssSelector, matchedCallback) || result;
	            }
	        }
	        return result;
	    };
	    /** @internal */
	    SelectorMatcher.prototype._matchTerminal = function (map, name, cssSelector, matchedCallback) {
	        if (lang_1.isBlank(map) || lang_1.isBlank(name)) {
	            return false;
	        }
	        var selectables = map.get(name);
	        var starSelectables = map.get("*");
	        if (lang_1.isPresent(starSelectables)) {
	            selectables = selectables.concat(starSelectables);
	        }
	        if (lang_1.isBlank(selectables)) {
	            return false;
	        }
	        var selectable;
	        var result = false;
	        for (var index = 0; index < selectables.length; index++) {
	            selectable = selectables[index];
	            result = selectable.finalize(cssSelector, matchedCallback) || result;
	        }
	        return result;
	    };
	    /** @internal */
	    SelectorMatcher.prototype._matchPartial = function (map, name, cssSelector, matchedCallback /*: (c: CssSelector, a: any) => void*/) {
	        if (lang_1.isBlank(map) || lang_1.isBlank(name)) {
	            return false;
	        }
	        var nestedSelector = map.get(name);
	        if (lang_1.isBlank(nestedSelector)) {
	            return false;
	        }
	        // TODO(perf): get rid of recursion and measure again
	        // TODO(perf): don't pass the whole selector into the recursion,
	        // but only the not processed parts
	        return nestedSelector.match(cssSelector, matchedCallback);
	    };
	    return SelectorMatcher;
	}());
	exports.SelectorMatcher = SelectorMatcher;
	var SelectorListContext = (function () {
	    function SelectorListContext(selectors) {
	        this.selectors = selectors;
	        this.alreadyMatched = false;
	    }
	    return SelectorListContext;
	}());
	exports.SelectorListContext = SelectorListContext;
	// Store context to pass back selector and context when a selector is matched
	var SelectorContext = (function () {
	    function SelectorContext(selector, cbContext, listContext) {
	        this.selector = selector;
	        this.cbContext = cbContext;
	        this.listContext = listContext;
	        this.notSelectors = selector.notSelectors;
	    }
	    SelectorContext.prototype.finalize = function (cssSelector, callback) {
	        var result = true;
	        if (this.notSelectors.length > 0 &&
	            (lang_1.isBlank(this.listContext) || !this.listContext.alreadyMatched)) {
	            var notMatcher = SelectorMatcher.createNotMatcher(this.notSelectors);
	            result = !notMatcher.match(cssSelector, null);
	        }
	        if (result && lang_1.isPresent(callback) &&
	            (lang_1.isBlank(this.listContext) || !this.listContext.alreadyMatched)) {
	            if (lang_1.isPresent(this.listContext)) {
	                this.listContext.alreadyMatched = true;
	            }
	            callback(this.selector, this.cbContext);
	        }
	        return result;
	    };
	    return SelectorContext;
	}());
	exports.SelectorContext = SelectorContext;


/***/ },
/* 152 */
/***/ function(module, exports) {

	"use strict";
	var ElementSchemaRegistry = (function () {
	    function ElementSchemaRegistry() {
	    }
	    ElementSchemaRegistry.prototype.hasProperty = function (tagName, propName) { return true; };
	    ElementSchemaRegistry.prototype.getMappedPropName = function (propName) { return propName; };
	    return ElementSchemaRegistry;
	}());
	exports.ElementSchemaRegistry = ElementSchemaRegistry;


/***/ },
/* 153 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var html_tags_1 = __webpack_require__(150);
	var NG_CONTENT_SELECT_ATTR = 'select';
	var NG_CONTENT_ELEMENT = 'ng-content';
	var LINK_ELEMENT = 'link';
	var LINK_STYLE_REL_ATTR = 'rel';
	var LINK_STYLE_HREF_ATTR = 'href';
	var LINK_STYLE_REL_VALUE = 'stylesheet';
	var STYLE_ELEMENT = 'style';
	var SCRIPT_ELEMENT = 'script';
	var NG_NON_BINDABLE_ATTR = 'ngNonBindable';
	var NG_PROJECT_AS = 'ngProjectAs';
	function preparseElement(ast) {
	    var selectAttr = null;
	    var hrefAttr = null;
	    var relAttr = null;
	    var nonBindable = false;
	    var projectAs = null;
	    ast.attrs.forEach(function (attr) {
	        var lcAttrName = attr.name.toLowerCase();
	        if (lcAttrName == NG_CONTENT_SELECT_ATTR) {
	            selectAttr = attr.value;
	        }
	        else if (lcAttrName == LINK_STYLE_HREF_ATTR) {
	            hrefAttr = attr.value;
	        }
	        else if (lcAttrName == LINK_STYLE_REL_ATTR) {
	            relAttr = attr.value;
	        }
	        else if (attr.name == NG_NON_BINDABLE_ATTR) {
	            nonBindable = true;
	        }
	        else if (attr.name == NG_PROJECT_AS) {
	            if (attr.value.length > 0) {
	                projectAs = attr.value;
	            }
	        }
	    });
	    selectAttr = normalizeNgContentSelect(selectAttr);
	    var nodeName = ast.name.toLowerCase();
	    var type = PreparsedElementType.OTHER;
	    if (html_tags_1.splitNsName(nodeName)[1] == NG_CONTENT_ELEMENT) {
	        type = PreparsedElementType.NG_CONTENT;
	    }
	    else if (nodeName == STYLE_ELEMENT) {
	        type = PreparsedElementType.STYLE;
	    }
	    else if (nodeName == SCRIPT_ELEMENT) {
	        type = PreparsedElementType.SCRIPT;
	    }
	    else if (nodeName == LINK_ELEMENT && relAttr == LINK_STYLE_REL_VALUE) {
	        type = PreparsedElementType.STYLESHEET;
	    }
	    return new PreparsedElement(type, selectAttr, hrefAttr, nonBindable, projectAs);
	}
	exports.preparseElement = preparseElement;
	(function (PreparsedElementType) {
	    PreparsedElementType[PreparsedElementType["NG_CONTENT"] = 0] = "NG_CONTENT";
	    PreparsedElementType[PreparsedElementType["STYLE"] = 1] = "STYLE";
	    PreparsedElementType[PreparsedElementType["STYLESHEET"] = 2] = "STYLESHEET";
	    PreparsedElementType[PreparsedElementType["SCRIPT"] = 3] = "SCRIPT";
	    PreparsedElementType[PreparsedElementType["OTHER"] = 4] = "OTHER";
	})(exports.PreparsedElementType || (exports.PreparsedElementType = {}));
	var PreparsedElementType = exports.PreparsedElementType;
	var PreparsedElement = (function () {
	    function PreparsedElement(type, selectAttr, hrefAttr, nonBindable, projectAs) {
	        this.type = type;
	        this.selectAttr = selectAttr;
	        this.hrefAttr = hrefAttr;
	        this.nonBindable = nonBindable;
	        this.projectAs = projectAs;
	    }
	    return PreparsedElement;
	}());
	exports.PreparsedElement = PreparsedElement;
	function normalizeNgContentSelect(selectAttr) {
	    if (lang_1.isBlank(selectAttr) || selectAttr.length === 0) {
	        return '*';
	    }
	    return selectAttr;
	}


/***/ },
/* 154 */
/***/ function(module, exports, __webpack_require__) {

	// Some of the code comes from WebComponents.JS
	// https://github.com/webcomponents/webcomponentsjs/blob/master/src/HTMLImports/path.js
	"use strict";
	var lang_1 = __webpack_require__(5);
	var StyleWithImports = (function () {
	    function StyleWithImports(style, styleUrls) {
	        this.style = style;
	        this.styleUrls = styleUrls;
	    }
	    return StyleWithImports;
	}());
	exports.StyleWithImports = StyleWithImports;
	function isStyleUrlResolvable(url) {
	    if (lang_1.isBlank(url) || url.length === 0 || url[0] == '/')
	        return false;
	    var schemeMatch = lang_1.RegExpWrapper.firstMatch(_urlWithSchemaRe, url);
	    return lang_1.isBlank(schemeMatch) || schemeMatch[1] == 'package' || schemeMatch[1] == 'asset';
	}
	exports.isStyleUrlResolvable = isStyleUrlResolvable;
	/**
	 * Rewrites stylesheets by resolving and removing the @import urls that
	 * are either relative or don't have a `package:` scheme
	 */
	function extractStyleUrls(resolver, baseUrl, cssText) {
	    var foundUrls = [];
	    var modifiedCssText = lang_1.StringWrapper.replaceAllMapped(cssText, _cssImportRe, function (m) {
	        var url = lang_1.isPresent(m[1]) ? m[1] : m[2];
	        if (!isStyleUrlResolvable(url)) {
	            // Do not attempt to resolve non-package absolute URLs with URI scheme
	            return m[0];
	        }
	        foundUrls.push(resolver.resolve(baseUrl, url));
	        return '';
	    });
	    return new StyleWithImports(modifiedCssText, foundUrls);
	}
	exports.extractStyleUrls = extractStyleUrls;
	var _cssImportRe = /@import\s+(?:url\()?\s*(?:(?:['"]([^'"]*))|([^;\)\s]*))[^;]*;?/g;
	// TODO: can't use /^[^:/?#.]+:/g due to clang-format bug:
	//       https://github.com/angular/angular/issues/4596
	var _urlWithSchemaRe = /^([a-zA-Z\-\+\.]+):/g;


/***/ },
/* 155 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	exports.MODULE_SUFFIX = lang_1.IS_DART ? '.dart' : '';
	var CAMEL_CASE_REGEXP = /([A-Z])/g;
	var DASH_CASE_REGEXP = /-([a-z])/g;
	function camelCaseToDashCase(input) {
	    return lang_1.StringWrapper.replaceAllMapped(input, CAMEL_CASE_REGEXP, function (m) { return '-' + m[1].toLowerCase(); });
	}
	exports.camelCaseToDashCase = camelCaseToDashCase;
	function dashCaseToCamelCase(input) {
	    return lang_1.StringWrapper.replaceAllMapped(input, DASH_CASE_REGEXP, function (m) { return m[1].toUpperCase(); });
	}
	exports.dashCaseToCamelCase = dashCaseToCamelCase;
	function splitAtColon(input, defaultValues) {
	    var parts = lang_1.StringWrapper.split(input.trim(), /\s*:\s*/g);
	    if (parts.length > 1) {
	        return parts;
	    }
	    else {
	        return defaultValues;
	    }
	}
	exports.splitAtColon = splitAtColon;
	function sanitizeIdentifier(name) {
	    return lang_1.StringWrapper.replaceAll(name, /\W/g, '_');
	}
	exports.sanitizeIdentifier = sanitizeIdentifier;
	function visitValue(value, visitor, context) {
	    if (lang_1.isArray(value)) {
	        return visitor.visitArray(value, context);
	    }
	    else if (lang_1.isStrictStringMap(value)) {
	        return visitor.visitStringMap(value, context);
	    }
	    else if (lang_1.isBlank(value) || lang_1.isPrimitive(value)) {
	        return visitor.visitPrimitive(value, context);
	    }
	    else {
	        return visitor.visitOther(value, context);
	    }
	}
	exports.visitValue = visitValue;
	var ValueTransformer = (function () {
	    function ValueTransformer() {
	    }
	    ValueTransformer.prototype.visitArray = function (arr, context) {
	        var _this = this;
	        return arr.map(function (value) { return visitValue(value, _this, context); });
	    };
	    ValueTransformer.prototype.visitStringMap = function (map, context) {
	        var _this = this;
	        var result = {};
	        collection_1.StringMapWrapper.forEach(map, function (value, key) { result[key] = visitValue(value, _this, context); });
	        return result;
	    };
	    ValueTransformer.prototype.visitPrimitive = function (value, context) { return value; };
	    ValueTransformer.prototype.visitOther = function (value, context) { return value; };
	    return ValueTransformer;
	}());
	exports.ValueTransformer = ValueTransformer;


/***/ },
/* 156 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var compile_metadata_1 = __webpack_require__(157);
	var view_1 = __webpack_require__(160);
	var debug_context_1 = __webpack_require__(161);
	var view_utils_1 = __webpack_require__(68);
	var change_detection_1 = __webpack_require__(29);
	var element_1 = __webpack_require__(69);
	var element_ref_1 = __webpack_require__(71);
	var view_container_ref_1 = __webpack_require__(72);
	var api_1 = __webpack_require__(76);
	var view_2 = __webpack_require__(37);
	var view_type_1 = __webpack_require__(70);
	var linker_1 = __webpack_require__(80);
	var injector_1 = __webpack_require__(11);
	var template_ref_1 = __webpack_require__(83);
	var util_1 = __webpack_require__(155);
	var APP_VIEW_MODULE_URL = 'asset:angular2/lib/src/core/linker/view' + util_1.MODULE_SUFFIX;
	var VIEW_UTILS_MODULE_URL = 'asset:angular2/lib/src/core/linker/view_utils' + util_1.MODULE_SUFFIX;
	var CD_MODULE_URL = 'asset:angular2/lib/src/core/change_detection/change_detection' + util_1.MODULE_SUFFIX;
	// Reassign the imports to different variables so we can
	// define static variables with the name of the import.
	// (only needed for Dart).
	var impViewUtils = view_utils_1.ViewUtils;
	var impAppView = view_1.AppView;
	var impDebugAppView = view_1.DebugAppView;
	var impDebugContext = debug_context_1.DebugContext;
	var impAppElement = element_1.AppElement;
	var impElementRef = element_ref_1.ElementRef;
	var impViewContainerRef = view_container_ref_1.ViewContainerRef;
	var impChangeDetectorRef = change_detection_1.ChangeDetectorRef;
	var impRenderComponentType = api_1.RenderComponentType;
	var impQueryList = linker_1.QueryList;
	var impTemplateRef = template_ref_1.TemplateRef;
	var impTemplateRef_ = template_ref_1.TemplateRef_;
	var impValueUnwrapper = change_detection_1.ValueUnwrapper;
	var impInjector = injector_1.Injector;
	var impViewEncapsulation = view_2.ViewEncapsulation;
	var impViewType = view_type_1.ViewType;
	var impChangeDetectionStrategy = change_detection_1.ChangeDetectionStrategy;
	var impStaticNodeDebugInfo = debug_context_1.StaticNodeDebugInfo;
	var impRenderer = api_1.Renderer;
	var impSimpleChange = change_detection_1.SimpleChange;
	var impUninitialized = change_detection_1.uninitialized;
	var impChangeDetectorState = change_detection_1.ChangeDetectorState;
	var impFlattenNestedViewRenderNodes = view_utils_1.flattenNestedViewRenderNodes;
	var impDevModeEqual = change_detection_1.devModeEqual;
	var impInterpolate = view_utils_1.interpolate;
	var impCheckBinding = view_utils_1.checkBinding;
	var impCastByValue = view_utils_1.castByValue;
	var impEMPTY_ARRAY = view_utils_1.EMPTY_ARRAY;
	var impEMPTY_MAP = view_utils_1.EMPTY_MAP;
	var Identifiers = (function () {
	    function Identifiers() {
	    }
	    Identifiers.ViewUtils = new compile_metadata_1.CompileIdentifierMetadata({
	        name: 'ViewUtils',
	        moduleUrl: 'asset:angular2/lib/src/core/linker/view_utils' + util_1.MODULE_SUFFIX,
	        runtime: impViewUtils
	    });
	    Identifiers.AppView = new compile_metadata_1.CompileIdentifierMetadata({ name: 'AppView', moduleUrl: APP_VIEW_MODULE_URL, runtime: impAppView });
	    Identifiers.DebugAppView = new compile_metadata_1.CompileIdentifierMetadata({ name: 'DebugAppView', moduleUrl: APP_VIEW_MODULE_URL, runtime: impDebugAppView });
	    Identifiers.AppElement = new compile_metadata_1.CompileIdentifierMetadata({
	        name: 'AppElement',
	        moduleUrl: 'asset:angular2/lib/src/core/linker/element' + util_1.MODULE_SUFFIX,
	        runtime: impAppElement
	    });
	    Identifiers.ElementRef = new compile_metadata_1.CompileIdentifierMetadata({
	        name: 'ElementRef',
	        moduleUrl: 'asset:angular2/lib/src/core/linker/element_ref' + util_1.MODULE_SUFFIX,
	        runtime: impElementRef
	    });
	    Identifiers.ViewContainerRef = new compile_metadata_1.CompileIdentifierMetadata({
	        name: 'ViewContainerRef',
	        moduleUrl: 'asset:angular2/lib/src/core/linker/view_container_ref' + util_1.MODULE_SUFFIX,
	        runtime: impViewContainerRef
	    });
	    Identifiers.ChangeDetectorRef = new compile_metadata_1.CompileIdentifierMetadata({
	        name: 'ChangeDetectorRef',
	        moduleUrl: 'asset:angular2/lib/src/core/change_detection/change_detector_ref' + util_1.MODULE_SUFFIX,
	        runtime: impChangeDetectorRef
	    });
	    Identifiers.RenderComponentType = new compile_metadata_1.CompileIdentifierMetadata({
	        name: 'RenderComponentType',
	        moduleUrl: 'asset:angular2/lib/src/core/render/api' + util_1.MODULE_SUFFIX,
	        runtime: impRenderComponentType
	    });
	    Identifiers.QueryList = new compile_metadata_1.CompileIdentifierMetadata({
	        name: 'QueryList',
	        moduleUrl: 'asset:angular2/lib/src/core/linker/query_list' + util_1.MODULE_SUFFIX,
	        runtime: impQueryList
	    });
	    Identifiers.TemplateRef = new compile_metadata_1.CompileIdentifierMetadata({
	        name: 'TemplateRef',
	        moduleUrl: 'asset:angular2/lib/src/core/linker/template_ref' + util_1.MODULE_SUFFIX,
	        runtime: impTemplateRef
	    });
	    Identifiers.TemplateRef_ = new compile_metadata_1.CompileIdentifierMetadata({
	        name: 'TemplateRef_',
	        moduleUrl: 'asset:angular2/lib/src/core/linker/template_ref' + util_1.MODULE_SUFFIX,
	        runtime: impTemplateRef_
	    });
	    Identifiers.ValueUnwrapper = new compile_metadata_1.CompileIdentifierMetadata({ name: 'ValueUnwrapper', moduleUrl: CD_MODULE_URL, runtime: impValueUnwrapper });
	    Identifiers.Injector = new compile_metadata_1.CompileIdentifierMetadata({
	        name: 'Injector',
	        moduleUrl: "asset:angular2/lib/src/core/di/injector" + util_1.MODULE_SUFFIX,
	        runtime: impInjector
	    });
	    Identifiers.ViewEncapsulation = new compile_metadata_1.CompileIdentifierMetadata({
	        name: 'ViewEncapsulation',
	        moduleUrl: 'asset:angular2/lib/src/core/metadata/view' + util_1.MODULE_SUFFIX,
	        runtime: impViewEncapsulation
	    });
	    Identifiers.ViewType = new compile_metadata_1.CompileIdentifierMetadata({
	        name: 'ViewType',
	        moduleUrl: "asset:angular2/lib/src/core/linker/view_type" + util_1.MODULE_SUFFIX,
	        runtime: impViewType
	    });
	    Identifiers.ChangeDetectionStrategy = new compile_metadata_1.CompileIdentifierMetadata({
	        name: 'ChangeDetectionStrategy',
	        moduleUrl: CD_MODULE_URL,
	        runtime: impChangeDetectionStrategy
	    });
	    Identifiers.StaticNodeDebugInfo = new compile_metadata_1.CompileIdentifierMetadata({
	        name: 'StaticNodeDebugInfo',
	        moduleUrl: "asset:angular2/lib/src/core/linker/debug_context" + util_1.MODULE_SUFFIX,
	        runtime: impStaticNodeDebugInfo
	    });
	    Identifiers.DebugContext = new compile_metadata_1.CompileIdentifierMetadata({
	        name: 'DebugContext',
	        moduleUrl: "asset:angular2/lib/src/core/linker/debug_context" + util_1.MODULE_SUFFIX,
	        runtime: impDebugContext
	    });
	    Identifiers.Renderer = new compile_metadata_1.CompileIdentifierMetadata({
	        name: 'Renderer',
	        moduleUrl: 'asset:angular2/lib/src/core/render/api' + util_1.MODULE_SUFFIX,
	        runtime: impRenderer
	    });
	    Identifiers.SimpleChange = new compile_metadata_1.CompileIdentifierMetadata({ name: 'SimpleChange', moduleUrl: CD_MODULE_URL, runtime: impSimpleChange });
	    Identifiers.uninitialized = new compile_metadata_1.CompileIdentifierMetadata({ name: 'uninitialized', moduleUrl: CD_MODULE_URL, runtime: impUninitialized });
	    Identifiers.ChangeDetectorState = new compile_metadata_1.CompileIdentifierMetadata({ name: 'ChangeDetectorState', moduleUrl: CD_MODULE_URL, runtime: impChangeDetectorState });
	    Identifiers.checkBinding = new compile_metadata_1.CompileIdentifierMetadata({ name: 'checkBinding', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: impCheckBinding });
	    Identifiers.flattenNestedViewRenderNodes = new compile_metadata_1.CompileIdentifierMetadata({
	        name: 'flattenNestedViewRenderNodes',
	        moduleUrl: VIEW_UTILS_MODULE_URL,
	        runtime: impFlattenNestedViewRenderNodes
	    });
	    Identifiers.devModeEqual = new compile_metadata_1.CompileIdentifierMetadata({ name: 'devModeEqual', moduleUrl: CD_MODULE_URL, runtime: impDevModeEqual });
	    Identifiers.interpolate = new compile_metadata_1.CompileIdentifierMetadata({ name: 'interpolate', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: impInterpolate });
	    Identifiers.castByValue = new compile_metadata_1.CompileIdentifierMetadata({ name: 'castByValue', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: impCastByValue });
	    Identifiers.EMPTY_ARRAY = new compile_metadata_1.CompileIdentifierMetadata({ name: 'EMPTY_ARRAY', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: impEMPTY_ARRAY });
	    Identifiers.EMPTY_MAP = new compile_metadata_1.CompileIdentifierMetadata({ name: 'EMPTY_MAP', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: impEMPTY_MAP });
	    Identifiers.pureProxies = [
	        null,
	        new compile_metadata_1.CompileIdentifierMetadata({ name: 'pureProxy1', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils_1.pureProxy1 }),
	        new compile_metadata_1.CompileIdentifierMetadata({ name: 'pureProxy2', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils_1.pureProxy2 }),
	        new compile_metadata_1.CompileIdentifierMetadata({ name: 'pureProxy3', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils_1.pureProxy3 }),
	        new compile_metadata_1.CompileIdentifierMetadata({ name: 'pureProxy4', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils_1.pureProxy4 }),
	        new compile_metadata_1.CompileIdentifierMetadata({ name: 'pureProxy5', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils_1.pureProxy5 }),
	        new compile_metadata_1.CompileIdentifierMetadata({ name: 'pureProxy6', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils_1.pureProxy6 }),
	        new compile_metadata_1.CompileIdentifierMetadata({ name: 'pureProxy7', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils_1.pureProxy7 }),
	        new compile_metadata_1.CompileIdentifierMetadata({ name: 'pureProxy8', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils_1.pureProxy8 }),
	        new compile_metadata_1.CompileIdentifierMetadata({ name: 'pureProxy9', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils_1.pureProxy9 }),
	        new compile_metadata_1.CompileIdentifierMetadata({ name: 'pureProxy10', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils_1.pureProxy10 }),
	    ];
	    return Identifiers;
	}());
	exports.Identifiers = Identifiers;
	function identifierToken(identifier) {
	    return new compile_metadata_1.CompileTokenMetadata({ identifier: identifier });
	}
	exports.identifierToken = identifierToken;


/***/ },
/* 157 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var collection_1 = __webpack_require__(15);
	var change_detection_1 = __webpack_require__(29);
	var view_1 = __webpack_require__(37);
	var selector_1 = __webpack_require__(151);
	var util_1 = __webpack_require__(155);
	var lifecycle_hooks_1 = __webpack_require__(158);
	var url_resolver_1 = __webpack_require__(159);
	// group 1: "property" from "[property]"
	// group 2: "event" from "(event)"
	var HOST_REG_EXP = /^(?:(?:\[([^\]]+)\])|(?:\(([^\)]+)\)))$/g;
	var CompileMetadataWithIdentifier = (function () {
	    function CompileMetadataWithIdentifier() {
	    }
	    Object.defineProperty(CompileMetadataWithIdentifier.prototype, "identifier", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    return CompileMetadataWithIdentifier;
	}());
	exports.CompileMetadataWithIdentifier = CompileMetadataWithIdentifier;
	var CompileMetadataWithType = (function (_super) {
	    __extends(CompileMetadataWithType, _super);
	    function CompileMetadataWithType() {
	        _super.apply(this, arguments);
	    }
	    Object.defineProperty(CompileMetadataWithType.prototype, "type", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(CompileMetadataWithType.prototype, "identifier", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    return CompileMetadataWithType;
	}(CompileMetadataWithIdentifier));
	exports.CompileMetadataWithType = CompileMetadataWithType;
	function metadataFromJson(data) {
	    return _COMPILE_METADATA_FROM_JSON[data['class']](data);
	}
	exports.metadataFromJson = metadataFromJson;
	var CompileIdentifierMetadata = (function () {
	    function CompileIdentifierMetadata(_a) {
	        var _b = _a === void 0 ? {} : _a, runtime = _b.runtime, name = _b.name, moduleUrl = _b.moduleUrl, prefix = _b.prefix, value = _b.value;
	        this.runtime = runtime;
	        this.name = name;
	        this.prefix = prefix;
	        this.moduleUrl = moduleUrl;
	        this.value = value;
	    }
	    CompileIdentifierMetadata.fromJson = function (data) {
	        var value = lang_1.isArray(data['value']) ? _arrayFromJson(data['value'], metadataFromJson) :
	            _objFromJson(data['value'], metadataFromJson);
	        return new CompileIdentifierMetadata({ name: data['name'], prefix: data['prefix'], moduleUrl: data['moduleUrl'], value: value });
	    };
	    CompileIdentifierMetadata.prototype.toJson = function () {
	        var value = lang_1.isArray(this.value) ? _arrayToJson(this.value) : _objToJson(this.value);
	        return {
	            // Note: Runtime type can't be serialized...
	            'class': 'Identifier',
	            'name': this.name,
	            'moduleUrl': this.moduleUrl,
	            'prefix': this.prefix,
	            'value': value
	        };
	    };
	    Object.defineProperty(CompileIdentifierMetadata.prototype, "identifier", {
	        get: function () { return this; },
	        enumerable: true,
	        configurable: true
	    });
	    return CompileIdentifierMetadata;
	}());
	exports.CompileIdentifierMetadata = CompileIdentifierMetadata;
	var CompileDiDependencyMetadata = (function () {
	    function CompileDiDependencyMetadata(_a) {
	        var _b = _a === void 0 ? {} : _a, isAttribute = _b.isAttribute, isSelf = _b.isSelf, isHost = _b.isHost, isSkipSelf = _b.isSkipSelf, isOptional = _b.isOptional, isValue = _b.isValue, query = _b.query, viewQuery = _b.viewQuery, token = _b.token, value = _b.value;
	        this.isAttribute = lang_1.normalizeBool(isAttribute);
	        this.isSelf = lang_1.normalizeBool(isSelf);
	        this.isHost = lang_1.normalizeBool(isHost);
	        this.isSkipSelf = lang_1.normalizeBool(isSkipSelf);
	        this.isOptional = lang_1.normalizeBool(isOptional);
	        this.isValue = lang_1.normalizeBool(isValue);
	        this.query = query;
	        this.viewQuery = viewQuery;
	        this.token = token;
	        this.value = value;
	    }
	    CompileDiDependencyMetadata.fromJson = function (data) {
	        return new CompileDiDependencyMetadata({
	            token: _objFromJson(data['token'], CompileTokenMetadata.fromJson),
	            query: _objFromJson(data['query'], CompileQueryMetadata.fromJson),
	            viewQuery: _objFromJson(data['viewQuery'], CompileQueryMetadata.fromJson),
	            value: data['value'],
	            isAttribute: data['isAttribute'],
	            isSelf: data['isSelf'],
	            isHost: data['isHost'],
	            isSkipSelf: data['isSkipSelf'],
	            isOptional: data['isOptional'],
	            isValue: data['isValue']
	        });
	    };
	    CompileDiDependencyMetadata.prototype.toJson = function () {
	        return {
	            'token': _objToJson(this.token),
	            'query': _objToJson(this.query),
	            'viewQuery': _objToJson(this.viewQuery),
	            'value': this.value,
	            'isAttribute': this.isAttribute,
	            'isSelf': this.isSelf,
	            'isHost': this.isHost,
	            'isSkipSelf': this.isSkipSelf,
	            'isOptional': this.isOptional,
	            'isValue': this.isValue
	        };
	    };
	    return CompileDiDependencyMetadata;
	}());
	exports.CompileDiDependencyMetadata = CompileDiDependencyMetadata;
	var CompileProviderMetadata = (function () {
	    function CompileProviderMetadata(_a) {
	        var token = _a.token, useClass = _a.useClass, useValue = _a.useValue, useExisting = _a.useExisting, useFactory = _a.useFactory, deps = _a.deps, multi = _a.multi;
	        this.token = token;
	        this.useClass = useClass;
	        this.useValue = useValue;
	        this.useExisting = useExisting;
	        this.useFactory = useFactory;
	        this.deps = lang_1.normalizeBlank(deps);
	        this.multi = lang_1.normalizeBool(multi);
	    }
	    CompileProviderMetadata.fromJson = function (data) {
	        return new CompileProviderMetadata({
	            token: _objFromJson(data['token'], CompileTokenMetadata.fromJson),
	            useClass: _objFromJson(data['useClass'], CompileTypeMetadata.fromJson),
	            useExisting: _objFromJson(data['useExisting'], CompileTokenMetadata.fromJson),
	            useValue: _objFromJson(data['useValue'], CompileIdentifierMetadata.fromJson),
	            useFactory: _objFromJson(data['useFactory'], CompileFactoryMetadata.fromJson),
	            multi: data['multi'],
	            deps: _arrayFromJson(data['deps'], CompileDiDependencyMetadata.fromJson)
	        });
	    };
	    CompileProviderMetadata.prototype.toJson = function () {
	        return {
	            // Note: Runtime type can't be serialized...
	            'class': 'Provider',
	            'token': _objToJson(this.token),
	            'useClass': _objToJson(this.useClass),
	            'useExisting': _objToJson(this.useExisting),
	            'useValue': _objToJson(this.useValue),
	            'useFactory': _objToJson(this.useFactory),
	            'multi': this.multi,
	            'deps': _arrayToJson(this.deps)
	        };
	    };
	    return CompileProviderMetadata;
	}());
	exports.CompileProviderMetadata = CompileProviderMetadata;
	var CompileFactoryMetadata = (function () {
	    function CompileFactoryMetadata(_a) {
	        var runtime = _a.runtime, name = _a.name, moduleUrl = _a.moduleUrl, prefix = _a.prefix, diDeps = _a.diDeps, value = _a.value;
	        this.runtime = runtime;
	        this.name = name;
	        this.prefix = prefix;
	        this.moduleUrl = moduleUrl;
	        this.diDeps = _normalizeArray(diDeps);
	        this.value = value;
	    }
	    Object.defineProperty(CompileFactoryMetadata.prototype, "identifier", {
	        get: function () { return this; },
	        enumerable: true,
	        configurable: true
	    });
	    CompileFactoryMetadata.fromJson = function (data) {
	        return new CompileFactoryMetadata({
	            name: data['name'],
	            prefix: data['prefix'],
	            moduleUrl: data['moduleUrl'],
	            value: data['value'],
	            diDeps: _arrayFromJson(data['diDeps'], CompileDiDependencyMetadata.fromJson)
	        });
	    };
	    CompileFactoryMetadata.prototype.toJson = function () {
	        return {
	            'class': 'Factory',
	            'name': this.name,
	            'prefix': this.prefix,
	            'moduleUrl': this.moduleUrl,
	            'value': this.value,
	            'diDeps': _arrayToJson(this.diDeps)
	        };
	    };
	    return CompileFactoryMetadata;
	}());
	exports.CompileFactoryMetadata = CompileFactoryMetadata;
	var CompileTokenMetadata = (function () {
	    function CompileTokenMetadata(_a) {
	        var value = _a.value, identifier = _a.identifier, identifierIsInstance = _a.identifierIsInstance;
	        this.value = value;
	        this.identifier = identifier;
	        this.identifierIsInstance = lang_1.normalizeBool(identifierIsInstance);
	    }
	    CompileTokenMetadata.fromJson = function (data) {
	        return new CompileTokenMetadata({
	            value: data['value'],
	            identifier: _objFromJson(data['identifier'], CompileIdentifierMetadata.fromJson),
	            identifierIsInstance: data['identifierIsInstance']
	        });
	    };
	    CompileTokenMetadata.prototype.toJson = function () {
	        return {
	            'value': this.value,
	            'identifier': _objToJson(this.identifier),
	            'identifierIsInstance': this.identifierIsInstance
	        };
	    };
	    Object.defineProperty(CompileTokenMetadata.prototype, "runtimeCacheKey", {
	        get: function () {
	            if (lang_1.isPresent(this.identifier)) {
	                return this.identifier.runtime;
	            }
	            else {
	                return this.value;
	            }
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(CompileTokenMetadata.prototype, "assetCacheKey", {
	        get: function () {
	            if (lang_1.isPresent(this.identifier)) {
	                return lang_1.isPresent(this.identifier.moduleUrl) &&
	                    lang_1.isPresent(url_resolver_1.getUrlScheme(this.identifier.moduleUrl)) ?
	                    this.identifier.name + "|" + this.identifier.moduleUrl + "|" + this.identifierIsInstance :
	                    null;
	            }
	            else {
	                return this.value;
	            }
	        },
	        enumerable: true,
	        configurable: true
	    });
	    CompileTokenMetadata.prototype.equalsTo = function (token2) {
	        var rk = this.runtimeCacheKey;
	        var ak = this.assetCacheKey;
	        return (lang_1.isPresent(rk) && rk == token2.runtimeCacheKey) ||
	            (lang_1.isPresent(ak) && ak == token2.assetCacheKey);
	    };
	    Object.defineProperty(CompileTokenMetadata.prototype, "name", {
	        get: function () {
	            return lang_1.isPresent(this.value) ? util_1.sanitizeIdentifier(this.value) : this.identifier.name;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    return CompileTokenMetadata;
	}());
	exports.CompileTokenMetadata = CompileTokenMetadata;
	var CompileTokenMap = (function () {
	    function CompileTokenMap() {
	        this._valueMap = new Map();
	        this._values = [];
	    }
	    CompileTokenMap.prototype.add = function (token, value) {
	        var existing = this.get(token);
	        if (lang_1.isPresent(existing)) {
	            throw new exceptions_1.BaseException("Can only add to a TokenMap! Token: " + token.name);
	        }
	        this._values.push(value);
	        var rk = token.runtimeCacheKey;
	        if (lang_1.isPresent(rk)) {
	            this._valueMap.set(rk, value);
	        }
	        var ak = token.assetCacheKey;
	        if (lang_1.isPresent(ak)) {
	            this._valueMap.set(ak, value);
	        }
	    };
	    CompileTokenMap.prototype.get = function (token) {
	        var rk = token.runtimeCacheKey;
	        var ak = token.assetCacheKey;
	        var result;
	        if (lang_1.isPresent(rk)) {
	            result = this._valueMap.get(rk);
	        }
	        if (lang_1.isBlank(result) && lang_1.isPresent(ak)) {
	            result = this._valueMap.get(ak);
	        }
	        return result;
	    };
	    CompileTokenMap.prototype.values = function () { return this._values; };
	    Object.defineProperty(CompileTokenMap.prototype, "size", {
	        get: function () { return this._values.length; },
	        enumerable: true,
	        configurable: true
	    });
	    return CompileTokenMap;
	}());
	exports.CompileTokenMap = CompileTokenMap;
	/**
	 * Metadata regarding compilation of a type.
	 */
	var CompileTypeMetadata = (function () {
	    function CompileTypeMetadata(_a) {
	        var _b = _a === void 0 ? {} : _a, runtime = _b.runtime, name = _b.name, moduleUrl = _b.moduleUrl, prefix = _b.prefix, isHost = _b.isHost, value = _b.value, diDeps = _b.diDeps;
	        this.runtime = runtime;
	        this.name = name;
	        this.moduleUrl = moduleUrl;
	        this.prefix = prefix;
	        this.isHost = lang_1.normalizeBool(isHost);
	        this.value = value;
	        this.diDeps = _normalizeArray(diDeps);
	    }
	    CompileTypeMetadata.fromJson = function (data) {
	        return new CompileTypeMetadata({
	            name: data['name'],
	            moduleUrl: data['moduleUrl'],
	            prefix: data['prefix'],
	            isHost: data['isHost'],
	            value: data['value'],
	            diDeps: _arrayFromJson(data['diDeps'], CompileDiDependencyMetadata.fromJson)
	        });
	    };
	    Object.defineProperty(CompileTypeMetadata.prototype, "identifier", {
	        get: function () { return this; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(CompileTypeMetadata.prototype, "type", {
	        get: function () { return this; },
	        enumerable: true,
	        configurable: true
	    });
	    CompileTypeMetadata.prototype.toJson = function () {
	        return {
	            // Note: Runtime type can't be serialized...
	            'class': 'Type',
	            'name': this.name,
	            'moduleUrl': this.moduleUrl,
	            'prefix': this.prefix,
	            'isHost': this.isHost,
	            'value': this.value,
	            'diDeps': _arrayToJson(this.diDeps)
	        };
	    };
	    return CompileTypeMetadata;
	}());
	exports.CompileTypeMetadata = CompileTypeMetadata;
	var CompileQueryMetadata = (function () {
	    function CompileQueryMetadata(_a) {
	        var _b = _a === void 0 ? {} : _a, selectors = _b.selectors, descendants = _b.descendants, first = _b.first, propertyName = _b.propertyName, read = _b.read;
	        this.selectors = selectors;
	        this.descendants = lang_1.normalizeBool(descendants);
	        this.first = lang_1.normalizeBool(first);
	        this.propertyName = propertyName;
	        this.read = read;
	    }
	    CompileQueryMetadata.fromJson = function (data) {
	        return new CompileQueryMetadata({
	            selectors: _arrayFromJson(data['selectors'], CompileTokenMetadata.fromJson),
	            descendants: data['descendants'],
	            first: data['first'],
	            propertyName: data['propertyName'],
	            read: _objFromJson(data['read'], CompileTokenMetadata.fromJson)
	        });
	    };
	    CompileQueryMetadata.prototype.toJson = function () {
	        return {
	            'selectors': _arrayToJson(this.selectors),
	            'descendants': this.descendants,
	            'first': this.first,
	            'propertyName': this.propertyName,
	            'read': _objToJson(this.read)
	        };
	    };
	    return CompileQueryMetadata;
	}());
	exports.CompileQueryMetadata = CompileQueryMetadata;
	/**
	 * Metadata regarding compilation of a template.
	 */
	var CompileTemplateMetadata = (function () {
	    function CompileTemplateMetadata(_a) {
	        var _b = _a === void 0 ? {} : _a, encapsulation = _b.encapsulation, template = _b.template, templateUrl = _b.templateUrl, styles = _b.styles, styleUrls = _b.styleUrls, ngContentSelectors = _b.ngContentSelectors, baseUrl = _b.baseUrl;
	        this.encapsulation = lang_1.isPresent(encapsulation) ? encapsulation : view_1.ViewEncapsulation.Emulated;
	        this.template = template;
	        this.templateUrl = templateUrl;
	        this.styles = lang_1.isPresent(styles) ? styles : [];
	        this.styleUrls = lang_1.isPresent(styleUrls) ? styleUrls : [];
	        this.ngContentSelectors = lang_1.isPresent(ngContentSelectors) ? ngContentSelectors : [];
	        this.baseUrl = baseUrl;
	    }
	    CompileTemplateMetadata.fromJson = function (data) {
	        return new CompileTemplateMetadata({
	            encapsulation: lang_1.isPresent(data['encapsulation']) ?
	                view_1.VIEW_ENCAPSULATION_VALUES[data['encapsulation']] :
	                data['encapsulation'],
	            template: data['template'],
	            templateUrl: data['templateUrl'],
	            styles: data['styles'],
	            styleUrls: data['styleUrls'],
	            ngContentSelectors: data['ngContentSelectors'],
	            baseUrl: data['baseUrl']
	        });
	    };
	    CompileTemplateMetadata.prototype.toJson = function () {
	        return {
	            'encapsulation': lang_1.isPresent(this.encapsulation) ? lang_1.serializeEnum(this.encapsulation) : this.encapsulation,
	            'template': this.template,
	            'templateUrl': this.templateUrl,
	            'styles': this.styles,
	            'styleUrls': this.styleUrls,
	            'ngContentSelectors': this.ngContentSelectors,
	            'baseUrl': this.baseUrl
	        };
	    };
	    return CompileTemplateMetadata;
	}());
	exports.CompileTemplateMetadata = CompileTemplateMetadata;
	/**
	 * Metadata regarding compilation of a directive.
	 */
	var CompileDirectiveMetadata = (function () {
	    function CompileDirectiveMetadata(_a) {
	        var _b = _a === void 0 ? {} : _a, type = _b.type, isComponent = _b.isComponent, selector = _b.selector, exportAs = _b.exportAs, changeDetection = _b.changeDetection, inputs = _b.inputs, outputs = _b.outputs, hostListeners = _b.hostListeners, hostProperties = _b.hostProperties, hostAttributes = _b.hostAttributes, lifecycleHooks = _b.lifecycleHooks, providers = _b.providers, viewProviders = _b.viewProviders, queries = _b.queries, viewQueries = _b.viewQueries, template = _b.template;
	        this.type = type;
	        this.isComponent = isComponent;
	        this.selector = selector;
	        this.exportAs = exportAs;
	        this.changeDetection = changeDetection;
	        this.inputs = inputs;
	        this.outputs = outputs;
	        this.hostListeners = hostListeners;
	        this.hostProperties = hostProperties;
	        this.hostAttributes = hostAttributes;
	        this.lifecycleHooks = _normalizeArray(lifecycleHooks);
	        this.providers = _normalizeArray(providers);
	        this.viewProviders = _normalizeArray(viewProviders);
	        this.queries = _normalizeArray(queries);
	        this.viewQueries = _normalizeArray(viewQueries);
	        this.template = template;
	    }
	    CompileDirectiveMetadata.create = function (_a) {
	        var _b = _a === void 0 ? {} : _a, type = _b.type, isComponent = _b.isComponent, selector = _b.selector, exportAs = _b.exportAs, changeDetection = _b.changeDetection, inputs = _b.inputs, outputs = _b.outputs, host = _b.host, lifecycleHooks = _b.lifecycleHooks, providers = _b.providers, viewProviders = _b.viewProviders, queries = _b.queries, viewQueries = _b.viewQueries, template = _b.template;
	        var hostListeners = {};
	        var hostProperties = {};
	        var hostAttributes = {};
	        if (lang_1.isPresent(host)) {
	            collection_1.StringMapWrapper.forEach(host, function (value, key) {
	                var matches = lang_1.RegExpWrapper.firstMatch(HOST_REG_EXP, key);
	                if (lang_1.isBlank(matches)) {
	                    hostAttributes[key] = value;
	                }
	                else if (lang_1.isPresent(matches[1])) {
	                    hostProperties[matches[1]] = value;
	                }
	                else if (lang_1.isPresent(matches[2])) {
	                    hostListeners[matches[2]] = value;
	                }
	            });
	        }
	        var inputsMap = {};
	        if (lang_1.isPresent(inputs)) {
	            inputs.forEach(function (bindConfig) {
	                // canonical syntax: `dirProp: elProp`
	                // if there is no `:`, use dirProp = elProp
	                var parts = util_1.splitAtColon(bindConfig, [bindConfig, bindConfig]);
	                inputsMap[parts[0]] = parts[1];
	            });
	        }
	        var outputsMap = {};
	        if (lang_1.isPresent(outputs)) {
	            outputs.forEach(function (bindConfig) {
	                // canonical syntax: `dirProp: elProp`
	                // if there is no `:`, use dirProp = elProp
	                var parts = util_1.splitAtColon(bindConfig, [bindConfig, bindConfig]);
	                outputsMap[parts[0]] = parts[1];
	            });
	        }
	        return new CompileDirectiveMetadata({
	            type: type,
	            isComponent: lang_1.normalizeBool(isComponent),
	            selector: selector,
	            exportAs: exportAs,
	            changeDetection: changeDetection,
	            inputs: inputsMap,
	            outputs: outputsMap,
	            hostListeners: hostListeners,
	            hostProperties: hostProperties,
	            hostAttributes: hostAttributes,
	            lifecycleHooks: lang_1.isPresent(lifecycleHooks) ? lifecycleHooks : [],
	            providers: providers,
	            viewProviders: viewProviders,
	            queries: queries,
	            viewQueries: viewQueries,
	            template: template
	        });
	    };
	    Object.defineProperty(CompileDirectiveMetadata.prototype, "identifier", {
	        get: function () { return this.type; },
	        enumerable: true,
	        configurable: true
	    });
	    CompileDirectiveMetadata.fromJson = function (data) {
	        return new CompileDirectiveMetadata({
	            isComponent: data['isComponent'],
	            selector: data['selector'],
	            exportAs: data['exportAs'],
	            type: lang_1.isPresent(data['type']) ? CompileTypeMetadata.fromJson(data['type']) : data['type'],
	            changeDetection: lang_1.isPresent(data['changeDetection']) ?
	                change_detection_1.CHANGE_DETECTION_STRATEGY_VALUES[data['changeDetection']] :
	                data['changeDetection'],
	            inputs: data['inputs'],
	            outputs: data['outputs'],
	            hostListeners: data['hostListeners'],
	            hostProperties: data['hostProperties'],
	            hostAttributes: data['hostAttributes'],
	            lifecycleHooks: data['lifecycleHooks'].map(function (hookValue) { return lifecycle_hooks_1.LIFECYCLE_HOOKS_VALUES[hookValue]; }),
	            template: lang_1.isPresent(data['template']) ? CompileTemplateMetadata.fromJson(data['template']) :
	                data['template'],
	            providers: _arrayFromJson(data['providers'], metadataFromJson),
	            viewProviders: _arrayFromJson(data['viewProviders'], metadataFromJson),
	            queries: _arrayFromJson(data['queries'], CompileQueryMetadata.fromJson),
	            viewQueries: _arrayFromJson(data['viewQueries'], CompileQueryMetadata.fromJson)
	        });
	    };
	    CompileDirectiveMetadata.prototype.toJson = function () {
	        return {
	            'class': 'Directive',
	            'isComponent': this.isComponent,
	            'selector': this.selector,
	            'exportAs': this.exportAs,
	            'type': lang_1.isPresent(this.type) ? this.type.toJson() : this.type,
	            'changeDetection': lang_1.isPresent(this.changeDetection) ? lang_1.serializeEnum(this.changeDetection) :
	                this.changeDetection,
	            'inputs': this.inputs,
	            'outputs': this.outputs,
	            'hostListeners': this.hostListeners,
	            'hostProperties': this.hostProperties,
	            'hostAttributes': this.hostAttributes,
	            'lifecycleHooks': this.lifecycleHooks.map(function (hook) { return lang_1.serializeEnum(hook); }),
	            'template': lang_1.isPresent(this.template) ? this.template.toJson() : this.template,
	            'providers': _arrayToJson(this.providers),
	            'viewProviders': _arrayToJson(this.viewProviders),
	            'queries': _arrayToJson(this.queries),
	            'viewQueries': _arrayToJson(this.viewQueries)
	        };
	    };
	    return CompileDirectiveMetadata;
	}());
	exports.CompileDirectiveMetadata = CompileDirectiveMetadata;
	/**
	 * Construct {@link CompileDirectiveMetadata} from {@link ComponentTypeMetadata} and a selector.
	 */
	function createHostComponentMeta(componentType, componentSelector) {
	    var template = selector_1.CssSelector.parse(componentSelector)[0].getMatchingElementTemplate();
	    return CompileDirectiveMetadata.create({
	        type: new CompileTypeMetadata({
	            runtime: Object,
	            name: componentType.name + "_Host",
	            moduleUrl: componentType.moduleUrl,
	            isHost: true
	        }),
	        template: new CompileTemplateMetadata({ template: template, templateUrl: '', styles: [], styleUrls: [], ngContentSelectors: [] }),
	        changeDetection: change_detection_1.ChangeDetectionStrategy.Default,
	        inputs: [],
	        outputs: [],
	        host: {},
	        lifecycleHooks: [],
	        isComponent: true,
	        selector: '*',
	        providers: [],
	        viewProviders: [],
	        queries: [],
	        viewQueries: []
	    });
	}
	exports.createHostComponentMeta = createHostComponentMeta;
	var CompilePipeMetadata = (function () {
	    function CompilePipeMetadata(_a) {
	        var _b = _a === void 0 ? {} : _a, type = _b.type, name = _b.name, pure = _b.pure, lifecycleHooks = _b.lifecycleHooks;
	        this.type = type;
	        this.name = name;
	        this.pure = lang_1.normalizeBool(pure);
	        this.lifecycleHooks = _normalizeArray(lifecycleHooks);
	    }
	    Object.defineProperty(CompilePipeMetadata.prototype, "identifier", {
	        get: function () { return this.type; },
	        enumerable: true,
	        configurable: true
	    });
	    CompilePipeMetadata.fromJson = function (data) {
	        return new CompilePipeMetadata({
	            type: lang_1.isPresent(data['type']) ? CompileTypeMetadata.fromJson(data['type']) : data['type'],
	            name: data['name'],
	            pure: data['pure']
	        });
	    };
	    CompilePipeMetadata.prototype.toJson = function () {
	        return {
	            'class': 'Pipe',
	            'type': lang_1.isPresent(this.type) ? this.type.toJson() : null,
	            'name': this.name,
	            'pure': this.pure
	        };
	    };
	    return CompilePipeMetadata;
	}());
	exports.CompilePipeMetadata = CompilePipeMetadata;
	var _COMPILE_METADATA_FROM_JSON = {
	    'Directive': CompileDirectiveMetadata.fromJson,
	    'Pipe': CompilePipeMetadata.fromJson,
	    'Type': CompileTypeMetadata.fromJson,
	    'Provider': CompileProviderMetadata.fromJson,
	    'Identifier': CompileIdentifierMetadata.fromJson,
	    'Factory': CompileFactoryMetadata.fromJson
	};
	function _arrayFromJson(obj, fn) {
	    return lang_1.isBlank(obj) ? null : obj.map(function (o) { return _objFromJson(o, fn); });
	}
	function _arrayToJson(obj) {
	    return lang_1.isBlank(obj) ? null : obj.map(_objToJson);
	}
	function _objFromJson(obj, fn) {
	    if (lang_1.isArray(obj))
	        return _arrayFromJson(obj, fn);
	    if (lang_1.isString(obj) || lang_1.isBlank(obj) || lang_1.isBoolean(obj) || lang_1.isNumber(obj))
	        return obj;
	    return fn(obj);
	}
	function _objToJson(obj) {
	    if (lang_1.isArray(obj))
	        return _arrayToJson(obj);
	    if (lang_1.isString(obj) || lang_1.isBlank(obj) || lang_1.isBoolean(obj) || lang_1.isNumber(obj))
	        return obj;
	    return obj.toJson();
	}
	function _normalizeArray(obj) {
	    return lang_1.isPresent(obj) ? obj : [];
	}


/***/ },
/* 158 */
/***/ function(module, exports) {

	"use strict";
	(function (LifecycleHooks) {
	    LifecycleHooks[LifecycleHooks["OnInit"] = 0] = "OnInit";
	    LifecycleHooks[LifecycleHooks["OnDestroy"] = 1] = "OnDestroy";
	    LifecycleHooks[LifecycleHooks["DoCheck"] = 2] = "DoCheck";
	    LifecycleHooks[LifecycleHooks["OnChanges"] = 3] = "OnChanges";
	    LifecycleHooks[LifecycleHooks["AfterContentInit"] = 4] = "AfterContentInit";
	    LifecycleHooks[LifecycleHooks["AfterContentChecked"] = 5] = "AfterContentChecked";
	    LifecycleHooks[LifecycleHooks["AfterViewInit"] = 6] = "AfterViewInit";
	    LifecycleHooks[LifecycleHooks["AfterViewChecked"] = 7] = "AfterViewChecked";
	})(exports.LifecycleHooks || (exports.LifecycleHooks = {}));
	var LifecycleHooks = exports.LifecycleHooks;
	/**
	 * @internal
	 */
	exports.LIFECYCLE_HOOKS_VALUES = [
	    LifecycleHooks.OnInit,
	    LifecycleHooks.OnDestroy,
	    LifecycleHooks.DoCheck,
	    LifecycleHooks.OnChanges,
	    LifecycleHooks.AfterContentInit,
	    LifecycleHooks.AfterContentChecked,
	    LifecycleHooks.AfterViewInit,
	    LifecycleHooks.AfterViewChecked
	];


/***/ },
/* 159 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var di_1 = __webpack_require__(6);
	var lang_1 = __webpack_require__(5);
	var application_tokens_1 = __webpack_require__(64);
	var _ASSET_SCHEME = 'asset:';
	/**
	 * Create a {@link UrlResolver} with no package prefix.
	 */
	function createUrlResolverWithoutPackagePrefix() {
	    return new UrlResolver();
	}
	exports.createUrlResolverWithoutPackagePrefix = createUrlResolverWithoutPackagePrefix;
	function createOfflineCompileUrlResolver() {
	    return new UrlResolver(_ASSET_SCHEME);
	}
	exports.createOfflineCompileUrlResolver = createOfflineCompileUrlResolver;
	/**
	 * A default provider for {@link PACKAGE_ROOT_URL} that maps to '/'.
	 */
	exports.DEFAULT_PACKAGE_URL_PROVIDER = {
	    provide: application_tokens_1.PACKAGE_ROOT_URL,
	    useValue: "/"
	};
	/**
	 * Used by the {@link Compiler} when resolving HTML and CSS template URLs.
	 *
	 * This class can be overridden by the application developer to create custom behavior.
	 *
	 * See {@link Compiler}
	 *
	 * ## Example
	 *
	 * {@example compiler/ts/url_resolver/url_resolver.ts region='url_resolver'}
	 */
	var UrlResolver = (function () {
	    function UrlResolver(_packagePrefix) {
	        if (_packagePrefix === void 0) { _packagePrefix = null; }
	        this._packagePrefix = _packagePrefix;
	    }
	    /**
	     * Resolves the `url` given the `baseUrl`:
	     * - when the `url` is null, the `baseUrl` is returned,
	     * - if `url` is relative ('path/to/here', './path/to/here'), the resolved url is a combination of
	     * `baseUrl` and `url`,
	     * - if `url` is absolute (it has a scheme: 'http://', 'https://' or start with '/'), the `url` is
	     * returned as is (ignoring the `baseUrl`)
	     *
	     * @param {string} baseUrl
	     * @param {string} url
	     * @returns {string} the resolved URL
	     */
	    UrlResolver.prototype.resolve = function (baseUrl, url) {
	        var resolvedUrl = url;
	        if (lang_1.isPresent(baseUrl) && baseUrl.length > 0) {
	            resolvedUrl = _resolveUrl(baseUrl, resolvedUrl);
	        }
	        var resolvedParts = _split(resolvedUrl);
	        var prefix = this._packagePrefix;
	        if (lang_1.isPresent(prefix) && lang_1.isPresent(resolvedParts) &&
	            resolvedParts[_ComponentIndex.Scheme] == "package") {
	            var path = resolvedParts[_ComponentIndex.Path];
	            if (this._packagePrefix === _ASSET_SCHEME) {
	                var pathSegements = path.split(/\//);
	                resolvedUrl = "asset:" + pathSegements[0] + "/lib/" + pathSegements.slice(1).join('/');
	            }
	            else {
	                prefix = lang_1.StringWrapper.stripRight(prefix, '/');
	                path = lang_1.StringWrapper.stripLeft(path, '/');
	                return prefix + "/" + path;
	            }
	        }
	        return resolvedUrl;
	    };
	    UrlResolver = __decorate([
	        di_1.Injectable(),
	        __param(0, di_1.Inject(application_tokens_1.PACKAGE_ROOT_URL)), 
	        __metadata('design:paramtypes', [String])
	    ], UrlResolver);
	    return UrlResolver;
	}());
	exports.UrlResolver = UrlResolver;
	/**
	 * Extract the scheme of a URL.
	 */
	function getUrlScheme(url) {
	    var match = _split(url);
	    return (match && match[_ComponentIndex.Scheme]) || "";
	}
	exports.getUrlScheme = getUrlScheme;
	// The code below is adapted from Traceur:
	// https://github.com/google/traceur-compiler/blob/9511c1dafa972bf0de1202a8a863bad02f0f95a8/src/runtime/url.js
	/**
	 * Builds a URI string from already-encoded parts.
	 *
	 * No encoding is performed.  Any component may be omitted as either null or
	 * undefined.
	 *
	 * @param {?string=} opt_scheme The scheme such as 'http'.
	 * @param {?string=} opt_userInfo The user name before the '@'.
	 * @param {?string=} opt_domain The domain such as 'www.google.com', already
	 *     URI-encoded.
	 * @param {(string|null)=} opt_port The port number.
	 * @param {?string=} opt_path The path, already URI-encoded.  If it is not
	 *     empty, it must begin with a slash.
	 * @param {?string=} opt_queryData The URI-encoded query data.
	 * @param {?string=} opt_fragment The URI-encoded fragment identifier.
	 * @return {string} The fully combined URI.
	 */
	function _buildFromEncodedParts(opt_scheme, opt_userInfo, opt_domain, opt_port, opt_path, opt_queryData, opt_fragment) {
	    var out = [];
	    if (lang_1.isPresent(opt_scheme)) {
	        out.push(opt_scheme + ':');
	    }
	    if (lang_1.isPresent(opt_domain)) {
	        out.push('//');
	        if (lang_1.isPresent(opt_userInfo)) {
	            out.push(opt_userInfo + '@');
	        }
	        out.push(opt_domain);
	        if (lang_1.isPresent(opt_port)) {
	            out.push(':' + opt_port);
	        }
	    }
	    if (lang_1.isPresent(opt_path)) {
	        out.push(opt_path);
	    }
	    if (lang_1.isPresent(opt_queryData)) {
	        out.push('?' + opt_queryData);
	    }
	    if (lang_1.isPresent(opt_fragment)) {
	        out.push('#' + opt_fragment);
	    }
	    return out.join('');
	}
	/**
	 * A regular expression for breaking a URI into its component parts.
	 *
	 * {@link http://www.gbiv.com/protocols/uri/rfc/rfc3986.html#RFC2234} says
	 * As the "first-match-wins" algorithm is identical to the "greedy"
	 * disambiguation method used by POSIX regular expressions, it is natural and
	 * commonplace to use a regular expression for parsing the potential five
	 * components of a URI reference.
	 *
	 * The following line is the regular expression for breaking-down a
	 * well-formed URI reference into its components.
	 *
	 * <pre>
	 * ^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
	 *  12            3  4          5       6  7        8 9
	 * </pre>
	 *
	 * The numbers in the second line above are only to assist readability; they
	 * indicate the reference points for each subexpression (i.e., each paired
	 * parenthesis). We refer to the value matched for subexpression <n> as $<n>.
	 * For example, matching the above expression to
	 * <pre>
	 *     http://www.ics.uci.edu/pub/ietf/uri/#Related
	 * </pre>
	 * results in the following subexpression matches:
	 * <pre>
	 *    $1 = http:
	 *    $2 = http
	 *    $3 = //www.ics.uci.edu
	 *    $4 = www.ics.uci.edu
	 *    $5 = /pub/ietf/uri/
	 *    $6 = <undefined>
	 *    $7 = <undefined>
	 *    $8 = #Related
	 *    $9 = Related
	 * </pre>
	 * where <undefined> indicates that the component is not present, as is the
	 * case for the query component in the above example. Therefore, we can
	 * determine the value of the five components as
	 * <pre>
	 *    scheme    = $2
	 *    authority = $4
	 *    path      = $5
	 *    query     = $7
	 *    fragment  = $9
	 * </pre>
	 *
	 * The regular expression has been modified slightly to expose the
	 * userInfo, domain, and port separately from the authority.
	 * The modified version yields
	 * <pre>
	 *    $1 = http              scheme
	 *    $2 = <undefined>       userInfo -\
	 *    $3 = www.ics.uci.edu   domain     | authority
	 *    $4 = <undefined>       port     -/
	 *    $5 = /pub/ietf/uri/    path
	 *    $6 = <undefined>       query without ?
	 *    $7 = Related           fragment without #
	 * </pre>
	 * @type {!RegExp}
	 * @internal
	 */
	var _splitRe = lang_1.RegExpWrapper.create('^' +
	    '(?:' +
	    '([^:/?#.]+)' +
	    // used by other URL parts such as :,
	    // ?, /, #, and .
	    ':)?' +
	    '(?://' +
	    '(?:([^/?#]*)@)?' +
	    '([\\w\\d\\-\\u0100-\\uffff.%]*)' +
	    // digits, dashes, dots, percent
	    // escapes, and unicode characters.
	    '(?::([0-9]+))?' +
	    ')?' +
	    '([^?#]+)?' +
	    '(?:\\?([^#]*))?' +
	    '(?:#(.*))?' +
	    '$');
	/**
	 * The index of each URI component in the return value of goog.uri.utils.split.
	 * @enum {number}
	 */
	var _ComponentIndex;
	(function (_ComponentIndex) {
	    _ComponentIndex[_ComponentIndex["Scheme"] = 1] = "Scheme";
	    _ComponentIndex[_ComponentIndex["UserInfo"] = 2] = "UserInfo";
	    _ComponentIndex[_ComponentIndex["Domain"] = 3] = "Domain";
	    _ComponentIndex[_ComponentIndex["Port"] = 4] = "Port";
	    _ComponentIndex[_ComponentIndex["Path"] = 5] = "Path";
	    _ComponentIndex[_ComponentIndex["QueryData"] = 6] = "QueryData";
	    _ComponentIndex[_ComponentIndex["Fragment"] = 7] = "Fragment";
	})(_ComponentIndex || (_ComponentIndex = {}));
	/**
	 * Splits a URI into its component parts.
	 *
	 * Each component can be accessed via the component indices; for example:
	 * <pre>
	 * goog.uri.utils.split(someStr)[goog.uri.utils.CompontentIndex.QUERY_DATA];
	 * </pre>
	 *
	 * @param {string} uri The URI string to examine.
	 * @return {!Array.<string|undefined>} Each component still URI-encoded.
	 *     Each component that is present will contain the encoded value, whereas
	 *     components that are not present will be undefined or empty, depending
	 *     on the browser's regular expression implementation.  Never null, since
	 *     arbitrary strings may still look like path names.
	 */
	function _split(uri) {
	    return lang_1.RegExpWrapper.firstMatch(_splitRe, uri);
	}
	/**
	  * Removes dot segments in given path component, as described in
	  * RFC 3986, section 5.2.4.
	  *
	  * @param {string} path A non-empty path component.
	  * @return {string} Path component with removed dot segments.
	  */
	function _removeDotSegments(path) {
	    if (path == '/')
	        return '/';
	    var leadingSlash = path[0] == '/' ? '/' : '';
	    var trailingSlash = path[path.length - 1] === '/' ? '/' : '';
	    var segments = path.split('/');
	    var out = [];
	    var up = 0;
	    for (var pos = 0; pos < segments.length; pos++) {
	        var segment = segments[pos];
	        switch (segment) {
	            case '':
	            case '.':
	                break;
	            case '..':
	                if (out.length > 0) {
	                    out.pop();
	                }
	                else {
	                    up++;
	                }
	                break;
	            default:
	                out.push(segment);
	        }
	    }
	    if (leadingSlash == '') {
	        while (up-- > 0) {
	            out.unshift('..');
	        }
	        if (out.length === 0)
	            out.push('.');
	    }
	    return leadingSlash + out.join('/') + trailingSlash;
	}
	/**
	 * Takes an array of the parts from split and canonicalizes the path part
	 * and then joins all the parts.
	 * @param {Array.<string?>} parts
	 * @return {string}
	 */
	function _joinAndCanonicalizePath(parts) {
	    var path = parts[_ComponentIndex.Path];
	    path = lang_1.isBlank(path) ? '' : _removeDotSegments(path);
	    parts[_ComponentIndex.Path] = path;
	    return _buildFromEncodedParts(parts[_ComponentIndex.Scheme], parts[_ComponentIndex.UserInfo], parts[_ComponentIndex.Domain], parts[_ComponentIndex.Port], path, parts[_ComponentIndex.QueryData], parts[_ComponentIndex.Fragment]);
	}
	/**
	 * Resolves a URL.
	 * @param {string} base The URL acting as the base URL.
	 * @param {string} to The URL to resolve.
	 * @return {string}
	 */
	function _resolveUrl(base, url) {
	    var parts = _split(encodeURI(url));
	    var baseParts = _split(base);
	    if (lang_1.isPresent(parts[_ComponentIndex.Scheme])) {
	        return _joinAndCanonicalizePath(parts);
	    }
	    else {
	        parts[_ComponentIndex.Scheme] = baseParts[_ComponentIndex.Scheme];
	    }
	    for (var i = _ComponentIndex.Scheme; i <= _ComponentIndex.Port; i++) {
	        if (lang_1.isBlank(parts[i])) {
	            parts[i] = baseParts[i];
	        }
	    }
	    if (parts[_ComponentIndex.Path][0] == '/') {
	        return _joinAndCanonicalizePath(parts);
	    }
	    var path = baseParts[_ComponentIndex.Path];
	    if (lang_1.isBlank(path))
	        path = '/';
	    var index = path.lastIndexOf('/');
	    path = path.substring(0, index + 1) + parts[_ComponentIndex.Path];
	    parts[_ComponentIndex.Path] = path;
	    return _joinAndCanonicalizePath(parts);
	}


/***/ },
/* 160 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var collection_1 = __webpack_require__(15);
	var element_1 = __webpack_require__(69);
	var lang_1 = __webpack_require__(5);
	var async_1 = __webpack_require__(41);
	var view_ref_1 = __webpack_require__(84);
	var view_type_1 = __webpack_require__(70);
	var view_utils_1 = __webpack_require__(68);
	var change_detection_1 = __webpack_require__(29);
	var profile_1 = __webpack_require__(73);
	var exceptions_1 = __webpack_require__(75);
	var debug_context_1 = __webpack_require__(161);
	var element_injector_1 = __webpack_require__(162);
	var _scope_check = profile_1.wtfCreateScope("AppView#check(ascii id)");
	/**
	 * Cost of making objects: http://jsperf.com/instantiate-size-of-object
	 *
	 */
	var AppView = (function () {
	    function AppView(clazz, componentType, type, viewUtils, parentInjector, declarationAppElement, cdMode) {
	        this.clazz = clazz;
	        this.componentType = componentType;
	        this.type = type;
	        this.viewUtils = viewUtils;
	        this.parentInjector = parentInjector;
	        this.declarationAppElement = declarationAppElement;
	        this.cdMode = cdMode;
	        this.contentChildren = [];
	        this.viewChildren = [];
	        this.viewContainerElement = null;
	        // The names of the below fields must be kept in sync with codegen_name_util.ts or
	        // change detection will fail.
	        this.cdState = change_detection_1.ChangeDetectorState.NeverChecked;
	        this.destroyed = false;
	        this.ref = new view_ref_1.ViewRef_(this);
	        if (type === view_type_1.ViewType.COMPONENT || type === view_type_1.ViewType.HOST) {
	            this.renderer = viewUtils.renderComponent(componentType);
	        }
	        else {
	            this.renderer = declarationAppElement.parentView.renderer;
	        }
	    }
	    AppView.prototype.create = function (context, givenProjectableNodes, rootSelectorOrNode) {
	        this.context = context;
	        var projectableNodes;
	        switch (this.type) {
	            case view_type_1.ViewType.COMPONENT:
	                projectableNodes = view_utils_1.ensureSlotCount(givenProjectableNodes, this.componentType.slotCount);
	                break;
	            case view_type_1.ViewType.EMBEDDED:
	                projectableNodes = this.declarationAppElement.parentView.projectableNodes;
	                break;
	            case view_type_1.ViewType.HOST:
	                // Note: Don't ensure the slot count for the projectableNodes as we store
	                // them only for the contained component view (which will later check the slot count...)
	                projectableNodes = givenProjectableNodes;
	                break;
	        }
	        this._hasExternalHostElement = lang_1.isPresent(rootSelectorOrNode);
	        this.projectableNodes = projectableNodes;
	        return this.createInternal(rootSelectorOrNode);
	    };
	    /**
	     * Overwritten by implementations.
	     * Returns the AppElement for the host element for ViewType.HOST.
	     */
	    AppView.prototype.createInternal = function (rootSelectorOrNode) { return null; };
	    AppView.prototype.init = function (rootNodesOrAppElements, allNodes, disposables, subscriptions) {
	        this.rootNodesOrAppElements = rootNodesOrAppElements;
	        this.allNodes = allNodes;
	        this.disposables = disposables;
	        this.subscriptions = subscriptions;
	        if (this.type === view_type_1.ViewType.COMPONENT) {
	            // Note: the render nodes have been attached to their host element
	            // in the ViewFactory already.
	            this.declarationAppElement.parentView.viewChildren.push(this);
	            this.dirtyParentQueriesInternal();
	        }
	    };
	    AppView.prototype.selectOrCreateHostElement = function (elementName, rootSelectorOrNode, debugInfo) {
	        var hostElement;
	        if (lang_1.isPresent(rootSelectorOrNode)) {
	            hostElement = this.renderer.selectRootElement(rootSelectorOrNode, debugInfo);
	        }
	        else {
	            hostElement = this.renderer.createElement(null, elementName, debugInfo);
	        }
	        return hostElement;
	    };
	    AppView.prototype.injectorGet = function (token, nodeIndex, notFoundResult) {
	        return this.injectorGetInternal(token, nodeIndex, notFoundResult);
	    };
	    /**
	     * Overwritten by implementations
	     */
	    AppView.prototype.injectorGetInternal = function (token, nodeIndex, notFoundResult) {
	        return notFoundResult;
	    };
	    AppView.prototype.injector = function (nodeIndex) {
	        if (lang_1.isPresent(nodeIndex)) {
	            return new element_injector_1.ElementInjector(this, nodeIndex);
	        }
	        else {
	            return this.parentInjector;
	        }
	    };
	    AppView.prototype.destroy = function () {
	        if (this._hasExternalHostElement) {
	            this.renderer.detachView(this.flatRootNodes);
	        }
	        else if (lang_1.isPresent(this.viewContainerElement)) {
	            this.viewContainerElement.detachView(this.viewContainerElement.nestedViews.indexOf(this));
	        }
	        this._destroyRecurse();
	    };
	    AppView.prototype._destroyRecurse = function () {
	        if (this.destroyed) {
	            return;
	        }
	        var children = this.contentChildren;
	        for (var i = 0; i < children.length; i++) {
	            children[i]._destroyRecurse();
	        }
	        children = this.viewChildren;
	        for (var i = 0; i < children.length; i++) {
	            children[i]._destroyRecurse();
	        }
	        this.destroyLocal();
	        this.destroyed = true;
	    };
	    AppView.prototype.destroyLocal = function () {
	        var hostElement = this.type === view_type_1.ViewType.COMPONENT ? this.declarationAppElement.nativeElement : null;
	        for (var i = 0; i < this.disposables.length; i++) {
	            this.disposables[i]();
	        }
	        for (var i = 0; i < this.subscriptions.length; i++) {
	            async_1.ObservableWrapper.dispose(this.subscriptions[i]);
	        }
	        this.destroyInternal();
	        if (this._hasExternalHostElement) {
	            this.renderer.detachView(this.flatRootNodes);
	        }
	        else if (lang_1.isPresent(this.viewContainerElement)) {
	            this.viewContainerElement.detachView(this.viewContainerElement.nestedViews.indexOf(this));
	        }
	        else {
	            this.dirtyParentQueriesInternal();
	        }
	        this.renderer.destroyView(hostElement, this.allNodes);
	    };
	    /**
	     * Overwritten by implementations
	     */
	    AppView.prototype.destroyInternal = function () { };
	    Object.defineProperty(AppView.prototype, "changeDetectorRef", {
	        get: function () { return this.ref; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AppView.prototype, "parent", {
	        get: function () {
	            return lang_1.isPresent(this.declarationAppElement) ? this.declarationAppElement.parentView : null;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AppView.prototype, "flatRootNodes", {
	        get: function () { return view_utils_1.flattenNestedViewRenderNodes(this.rootNodesOrAppElements); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(AppView.prototype, "lastRootNode", {
	        get: function () {
	            var lastNode = this.rootNodesOrAppElements.length > 0 ?
	                this.rootNodesOrAppElements[this.rootNodesOrAppElements.length - 1] :
	                null;
	            return _findLastRenderNode(lastNode);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    /**
	     * Overwritten by implementations
	     */
	    AppView.prototype.dirtyParentQueriesInternal = function () { };
	    AppView.prototype.detectChanges = function (throwOnChange) {
	        var s = _scope_check(this.clazz);
	        if (this.cdMode === change_detection_1.ChangeDetectionStrategy.Detached ||
	            this.cdMode === change_detection_1.ChangeDetectionStrategy.Checked ||
	            this.cdState === change_detection_1.ChangeDetectorState.Errored)
	            return;
	        if (this.destroyed) {
	            this.throwDestroyedError('detectChanges');
	        }
	        this.detectChangesInternal(throwOnChange);
	        if (this.cdMode === change_detection_1.ChangeDetectionStrategy.CheckOnce)
	            this.cdMode = change_detection_1.ChangeDetectionStrategy.Checked;
	        this.cdState = change_detection_1.ChangeDetectorState.CheckedBefore;
	        profile_1.wtfLeave(s);
	    };
	    /**
	     * Overwritten by implementations
	     */
	    AppView.prototype.detectChangesInternal = function (throwOnChange) {
	        this.detectContentChildrenChanges(throwOnChange);
	        this.detectViewChildrenChanges(throwOnChange);
	    };
	    AppView.prototype.detectContentChildrenChanges = function (throwOnChange) {
	        for (var i = 0; i < this.contentChildren.length; ++i) {
	            this.contentChildren[i].detectChanges(throwOnChange);
	        }
	    };
	    AppView.prototype.detectViewChildrenChanges = function (throwOnChange) {
	        for (var i = 0; i < this.viewChildren.length; ++i) {
	            this.viewChildren[i].detectChanges(throwOnChange);
	        }
	    };
	    AppView.prototype.addToContentChildren = function (renderAppElement) {
	        renderAppElement.parentView.contentChildren.push(this);
	        this.viewContainerElement = renderAppElement;
	        this.dirtyParentQueriesInternal();
	    };
	    AppView.prototype.removeFromContentChildren = function (renderAppElement) {
	        collection_1.ListWrapper.remove(renderAppElement.parentView.contentChildren, this);
	        this.dirtyParentQueriesInternal();
	        this.viewContainerElement = null;
	    };
	    AppView.prototype.markAsCheckOnce = function () { this.cdMode = change_detection_1.ChangeDetectionStrategy.CheckOnce; };
	    AppView.prototype.markPathToRootAsCheckOnce = function () {
	        var c = this;
	        while (lang_1.isPresent(c) && c.cdMode !== change_detection_1.ChangeDetectionStrategy.Detached) {
	            if (c.cdMode === change_detection_1.ChangeDetectionStrategy.Checked) {
	                c.cdMode = change_detection_1.ChangeDetectionStrategy.CheckOnce;
	            }
	            var parentEl = c.type === view_type_1.ViewType.COMPONENT ? c.declarationAppElement : c.viewContainerElement;
	            c = lang_1.isPresent(parentEl) ? parentEl.parentView : null;
	        }
	    };
	    AppView.prototype.eventHandler = function (cb) { return cb; };
	    AppView.prototype.throwDestroyedError = function (details) { throw new exceptions_1.ViewDestroyedException(details); };
	    return AppView;
	}());
	exports.AppView = AppView;
	var DebugAppView = (function (_super) {
	    __extends(DebugAppView, _super);
	    function DebugAppView(clazz, componentType, type, viewUtils, parentInjector, declarationAppElement, cdMode, staticNodeDebugInfos) {
	        _super.call(this, clazz, componentType, type, viewUtils, parentInjector, declarationAppElement, cdMode);
	        this.staticNodeDebugInfos = staticNodeDebugInfos;
	        this._currentDebugContext = null;
	    }
	    DebugAppView.prototype.create = function (context, givenProjectableNodes, rootSelectorOrNode) {
	        this._resetDebug();
	        try {
	            return _super.prototype.create.call(this, context, givenProjectableNodes, rootSelectorOrNode);
	        }
	        catch (e) {
	            this._rethrowWithContext(e, e.stack);
	            throw e;
	        }
	    };
	    DebugAppView.prototype.injectorGet = function (token, nodeIndex, notFoundResult) {
	        this._resetDebug();
	        try {
	            return _super.prototype.injectorGet.call(this, token, nodeIndex, notFoundResult);
	        }
	        catch (e) {
	            this._rethrowWithContext(e, e.stack);
	            throw e;
	        }
	    };
	    DebugAppView.prototype.destroyLocal = function () {
	        this._resetDebug();
	        try {
	            _super.prototype.destroyLocal.call(this);
	        }
	        catch (e) {
	            this._rethrowWithContext(e, e.stack);
	            throw e;
	        }
	    };
	    DebugAppView.prototype.detectChanges = function (throwOnChange) {
	        this._resetDebug();
	        try {
	            _super.prototype.detectChanges.call(this, throwOnChange);
	        }
	        catch (e) {
	            this._rethrowWithContext(e, e.stack);
	            throw e;
	        }
	    };
	    DebugAppView.prototype._resetDebug = function () { this._currentDebugContext = null; };
	    DebugAppView.prototype.debug = function (nodeIndex, rowNum, colNum) {
	        return this._currentDebugContext = new debug_context_1.DebugContext(this, nodeIndex, rowNum, colNum);
	    };
	    DebugAppView.prototype._rethrowWithContext = function (e, stack) {
	        if (!(e instanceof exceptions_1.ViewWrappedException)) {
	            if (!(e instanceof exceptions_1.ExpressionChangedAfterItHasBeenCheckedException)) {
	                this.cdState = change_detection_1.ChangeDetectorState.Errored;
	            }
	            if (lang_1.isPresent(this._currentDebugContext)) {
	                throw new exceptions_1.ViewWrappedException(e, stack, this._currentDebugContext);
	            }
	        }
	    };
	    DebugAppView.prototype.eventHandler = function (cb) {
	        var _this = this;
	        var superHandler = _super.prototype.eventHandler.call(this, cb);
	        return function (event) {
	            _this._resetDebug();
	            try {
	                return superHandler(event);
	            }
	            catch (e) {
	                _this._rethrowWithContext(e, e.stack);
	                throw e;
	            }
	        };
	    };
	    return DebugAppView;
	}(AppView));
	exports.DebugAppView = DebugAppView;
	function _findLastRenderNode(node) {
	    var lastNode;
	    if (node instanceof element_1.AppElement) {
	        var appEl = node;
	        lastNode = appEl.nativeElement;
	        if (lang_1.isPresent(appEl.nestedViews)) {
	            // Note: Views might have no root nodes at all!
	            for (var i = appEl.nestedViews.length - 1; i >= 0; i--) {
	                var nestedView = appEl.nestedViews[i];
	                if (nestedView.rootNodesOrAppElements.length > 0) {
	                    lastNode = _findLastRenderNode(nestedView.rootNodesOrAppElements[nestedView.rootNodesOrAppElements.length - 1]);
	                }
	            }
	        }
	    }
	    else {
	        lastNode = node;
	    }
	    return lastNode;
	}


/***/ },
/* 161 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var view_type_1 = __webpack_require__(70);
	/* @ts2dart_const */
	var StaticNodeDebugInfo = (function () {
	    function StaticNodeDebugInfo(providerTokens, componentToken, refTokens) {
	        this.providerTokens = providerTokens;
	        this.componentToken = componentToken;
	        this.refTokens = refTokens;
	    }
	    return StaticNodeDebugInfo;
	}());
	exports.StaticNodeDebugInfo = StaticNodeDebugInfo;
	var DebugContext = (function () {
	    function DebugContext(_view, _nodeIndex, _tplRow, _tplCol) {
	        this._view = _view;
	        this._nodeIndex = _nodeIndex;
	        this._tplRow = _tplRow;
	        this._tplCol = _tplCol;
	    }
	    Object.defineProperty(DebugContext.prototype, "_staticNodeInfo", {
	        get: function () {
	            return lang_1.isPresent(this._nodeIndex) ? this._view.staticNodeDebugInfos[this._nodeIndex] : null;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DebugContext.prototype, "context", {
	        get: function () { return this._view.context; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DebugContext.prototype, "component", {
	        get: function () {
	            var staticNodeInfo = this._staticNodeInfo;
	            if (lang_1.isPresent(staticNodeInfo) && lang_1.isPresent(staticNodeInfo.componentToken)) {
	                return this.injector.get(staticNodeInfo.componentToken);
	            }
	            return null;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DebugContext.prototype, "componentRenderElement", {
	        get: function () {
	            var componentView = this._view;
	            while (lang_1.isPresent(componentView.declarationAppElement) &&
	                componentView.type !== view_type_1.ViewType.COMPONENT) {
	                componentView = componentView.declarationAppElement.parentView;
	            }
	            return lang_1.isPresent(componentView.declarationAppElement) ?
	                componentView.declarationAppElement.nativeElement :
	                null;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DebugContext.prototype, "injector", {
	        get: function () { return this._view.injector(this._nodeIndex); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DebugContext.prototype, "renderNode", {
	        get: function () {
	            if (lang_1.isPresent(this._nodeIndex) && lang_1.isPresent(this._view.allNodes)) {
	                return this._view.allNodes[this._nodeIndex];
	            }
	            else {
	                return null;
	            }
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DebugContext.prototype, "providerTokens", {
	        get: function () {
	            var staticNodeInfo = this._staticNodeInfo;
	            return lang_1.isPresent(staticNodeInfo) ? staticNodeInfo.providerTokens : null;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DebugContext.prototype, "source", {
	        get: function () {
	            return this._view.componentType.templateUrl + ":" + this._tplRow + ":" + this._tplCol;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DebugContext.prototype, "references", {
	        get: function () {
	            var _this = this;
	            var varValues = {};
	            var staticNodeInfo = this._staticNodeInfo;
	            if (lang_1.isPresent(staticNodeInfo)) {
	                var refs = staticNodeInfo.refTokens;
	                collection_1.StringMapWrapper.forEach(refs, function (refToken, refName) {
	                    var varValue;
	                    if (lang_1.isBlank(refToken)) {
	                        varValue = lang_1.isPresent(_this._view.allNodes) ? _this._view.allNodes[_this._nodeIndex] : null;
	                    }
	                    else {
	                        varValue = _this._view.injectorGet(refToken, _this._nodeIndex, null);
	                    }
	                    varValues[refName] = varValue;
	                });
	            }
	            return varValues;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    return DebugContext;
	}());
	exports.DebugContext = DebugContext;


/***/ },
/* 162 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var injector_1 = __webpack_require__(11);
	var _UNDEFINED = new Object();
	var ElementInjector = (function (_super) {
	    __extends(ElementInjector, _super);
	    function ElementInjector(_view, _nodeIndex) {
	        _super.call(this);
	        this._view = _view;
	        this._nodeIndex = _nodeIndex;
	    }
	    ElementInjector.prototype.get = function (token, notFoundValue) {
	        if (notFoundValue === void 0) { notFoundValue = injector_1.THROW_IF_NOT_FOUND; }
	        var result = _UNDEFINED;
	        if (result === _UNDEFINED) {
	            result = this._view.injectorGet(token, this._nodeIndex, _UNDEFINED);
	        }
	        if (result === _UNDEFINED) {
	            result = this._view.parentInjector.get(token, notFoundValue);
	        }
	        return result;
	    };
	    return ElementInjector;
	}(injector_1.Injector));
	exports.ElementInjector = ElementInjector;


/***/ },
/* 163 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var template_ast_1 = __webpack_require__(141);
	var compile_metadata_1 = __webpack_require__(157);
	var identifiers_1 = __webpack_require__(156);
	var parse_util_1 = __webpack_require__(149);
	var ProviderError = (function (_super) {
	    __extends(ProviderError, _super);
	    function ProviderError(message, span) {
	        _super.call(this, span, message);
	    }
	    return ProviderError;
	}(parse_util_1.ParseError));
	exports.ProviderError = ProviderError;
	var ProviderViewContext = (function () {
	    function ProviderViewContext(component, sourceSpan) {
	        var _this = this;
	        this.component = component;
	        this.sourceSpan = sourceSpan;
	        this.errors = [];
	        this.viewQueries = _getViewQueries(component);
	        this.viewProviders = new compile_metadata_1.CompileTokenMap();
	        _normalizeProviders(component.viewProviders, sourceSpan, this.errors)
	            .forEach(function (provider) {
	            if (lang_1.isBlank(_this.viewProviders.get(provider.token))) {
	                _this.viewProviders.add(provider.token, true);
	            }
	        });
	    }
	    return ProviderViewContext;
	}());
	exports.ProviderViewContext = ProviderViewContext;
	var ProviderElementContext = (function () {
	    function ProviderElementContext(_viewContext, _parent, _isViewRoot, _directiveAsts, attrs, refs, _sourceSpan) {
	        var _this = this;
	        this._viewContext = _viewContext;
	        this._parent = _parent;
	        this._isViewRoot = _isViewRoot;
	        this._directiveAsts = _directiveAsts;
	        this._sourceSpan = _sourceSpan;
	        this._transformedProviders = new compile_metadata_1.CompileTokenMap();
	        this._seenProviders = new compile_metadata_1.CompileTokenMap();
	        this._hasViewContainer = false;
	        this._attrs = {};
	        attrs.forEach(function (attrAst) { return _this._attrs[attrAst.name] = attrAst.value; });
	        var directivesMeta = _directiveAsts.map(function (directiveAst) { return directiveAst.directive; });
	        this._allProviders =
	            _resolveProvidersFromDirectives(directivesMeta, _sourceSpan, _viewContext.errors);
	        this._contentQueries = _getContentQueries(directivesMeta);
	        var queriedTokens = new compile_metadata_1.CompileTokenMap();
	        this._allProviders.values().forEach(function (provider) { _this._addQueryReadsTo(provider.token, queriedTokens); });
	        refs.forEach(function (refAst) {
	            _this._addQueryReadsTo(new compile_metadata_1.CompileTokenMetadata({ value: refAst.name }), queriedTokens);
	        });
	        if (lang_1.isPresent(queriedTokens.get(identifiers_1.identifierToken(identifiers_1.Identifiers.ViewContainerRef)))) {
	            this._hasViewContainer = true;
	        }
	        // create the providers that we know are eager first
	        this._allProviders.values().forEach(function (provider) {
	            var eager = provider.eager || lang_1.isPresent(queriedTokens.get(provider.token));
	            if (eager) {
	                _this._getOrCreateLocalProvider(provider.providerType, provider.token, true);
	            }
	        });
	    }
	    ProviderElementContext.prototype.afterElement = function () {
	        var _this = this;
	        // collect lazy providers
	        this._allProviders.values().forEach(function (provider) {
	            _this._getOrCreateLocalProvider(provider.providerType, provider.token, false);
	        });
	    };
	    Object.defineProperty(ProviderElementContext.prototype, "transformProviders", {
	        get: function () { return this._transformedProviders.values(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ProviderElementContext.prototype, "transformedDirectiveAsts", {
	        get: function () {
	            var sortedProviderTypes = this._transformedProviders.values().map(function (provider) { return provider.token.identifier; });
	            var sortedDirectives = collection_1.ListWrapper.clone(this._directiveAsts);
	            collection_1.ListWrapper.sort(sortedDirectives, function (dir1, dir2) { return sortedProviderTypes.indexOf(dir1.directive.type) -
	                sortedProviderTypes.indexOf(dir2.directive.type); });
	            return sortedDirectives;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(ProviderElementContext.prototype, "transformedHasViewContainer", {
	        get: function () { return this._hasViewContainer; },
	        enumerable: true,
	        configurable: true
	    });
	    ProviderElementContext.prototype._addQueryReadsTo = function (token, queryReadTokens) {
	        this._getQueriesFor(token).forEach(function (query) {
	            var queryReadToken = lang_1.isPresent(query.read) ? query.read : token;
	            if (lang_1.isBlank(queryReadTokens.get(queryReadToken))) {
	                queryReadTokens.add(queryReadToken, true);
	            }
	        });
	    };
	    ProviderElementContext.prototype._getQueriesFor = function (token) {
	        var result = [];
	        var currentEl = this;
	        var distance = 0;
	        var queries;
	        while (currentEl !== null) {
	            queries = currentEl._contentQueries.get(token);
	            if (lang_1.isPresent(queries)) {
	                collection_1.ListWrapper.addAll(result, queries.filter(function (query) { return query.descendants || distance <= 1; }));
	            }
	            if (currentEl._directiveAsts.length > 0) {
	                distance++;
	            }
	            currentEl = currentEl._parent;
	        }
	        queries = this._viewContext.viewQueries.get(token);
	        if (lang_1.isPresent(queries)) {
	            collection_1.ListWrapper.addAll(result, queries);
	        }
	        return result;
	    };
	    ProviderElementContext.prototype._getOrCreateLocalProvider = function (requestingProviderType, token, eager) {
	        var _this = this;
	        var resolvedProvider = this._allProviders.get(token);
	        if (lang_1.isBlank(resolvedProvider) ||
	            ((requestingProviderType === template_ast_1.ProviderAstType.Directive ||
	                requestingProviderType === template_ast_1.ProviderAstType.PublicService) &&
	                resolvedProvider.providerType === template_ast_1.ProviderAstType.PrivateService) ||
	            ((requestingProviderType === template_ast_1.ProviderAstType.PrivateService ||
	                requestingProviderType === template_ast_1.ProviderAstType.PublicService) &&
	                resolvedProvider.providerType === template_ast_1.ProviderAstType.Builtin)) {
	            return null;
	        }
	        var transformedProviderAst = this._transformedProviders.get(token);
	        if (lang_1.isPresent(transformedProviderAst)) {
	            return transformedProviderAst;
	        }
	        if (lang_1.isPresent(this._seenProviders.get(token))) {
	            this._viewContext.errors.push(new ProviderError("Cannot instantiate cyclic dependency! " + token.name, this._sourceSpan));
	            return null;
	        }
	        this._seenProviders.add(token, true);
	        var transformedProviders = resolvedProvider.providers.map(function (provider) {
	            var transformedUseValue = provider.useValue;
	            var transformedUseExisting = provider.useExisting;
	            var transformedDeps;
	            if (lang_1.isPresent(provider.useExisting)) {
	                var existingDiDep = _this._getDependency(resolvedProvider.providerType, new compile_metadata_1.CompileDiDependencyMetadata({ token: provider.useExisting }), eager);
	                if (lang_1.isPresent(existingDiDep.token)) {
	                    transformedUseExisting = existingDiDep.token;
	                }
	                else {
	                    transformedUseExisting = null;
	                    transformedUseValue = existingDiDep.value;
	                }
	            }
	            else if (lang_1.isPresent(provider.useFactory)) {
	                var deps = lang_1.isPresent(provider.deps) ? provider.deps : provider.useFactory.diDeps;
	                transformedDeps =
	                    deps.map(function (dep) { return _this._getDependency(resolvedProvider.providerType, dep, eager); });
	            }
	            else if (lang_1.isPresent(provider.useClass)) {
	                var deps = lang_1.isPresent(provider.deps) ? provider.deps : provider.useClass.diDeps;
	                transformedDeps =
	                    deps.map(function (dep) { return _this._getDependency(resolvedProvider.providerType, dep, eager); });
	            }
	            return _transformProvider(provider, {
	                useExisting: transformedUseExisting,
	                useValue: transformedUseValue,
	                deps: transformedDeps
	            });
	        });
	        transformedProviderAst =
	            _transformProviderAst(resolvedProvider, { eager: eager, providers: transformedProviders });
	        this._transformedProviders.add(token, transformedProviderAst);
	        return transformedProviderAst;
	    };
	    ProviderElementContext.prototype._getLocalDependency = function (requestingProviderType, dep, eager) {
	        if (eager === void 0) { eager = null; }
	        if (dep.isAttribute) {
	            var attrValue = this._attrs[dep.token.value];
	            return new compile_metadata_1.CompileDiDependencyMetadata({ isValue: true, value: lang_1.normalizeBlank(attrValue) });
	        }
	        if (lang_1.isPresent(dep.query) || lang_1.isPresent(dep.viewQuery)) {
	            return dep;
	        }
	        if (lang_1.isPresent(dep.token)) {
	            // access builtints
	            if ((requestingProviderType === template_ast_1.ProviderAstType.Directive ||
	                requestingProviderType === template_ast_1.ProviderAstType.Component)) {
	                if (dep.token.equalsTo(identifiers_1.identifierToken(identifiers_1.Identifiers.Renderer)) ||
	                    dep.token.equalsTo(identifiers_1.identifierToken(identifiers_1.Identifiers.ElementRef)) ||
	                    dep.token.equalsTo(identifiers_1.identifierToken(identifiers_1.Identifiers.ChangeDetectorRef)) ||
	                    dep.token.equalsTo(identifiers_1.identifierToken(identifiers_1.Identifiers.TemplateRef))) {
	                    return dep;
	                }
	                if (dep.token.equalsTo(identifiers_1.identifierToken(identifiers_1.Identifiers.ViewContainerRef))) {
	                    this._hasViewContainer = true;
	                }
	            }
	            // access the injector
	            if (dep.token.equalsTo(identifiers_1.identifierToken(identifiers_1.Identifiers.Injector))) {
	                return dep;
	            }
	            // access providers
	            if (lang_1.isPresent(this._getOrCreateLocalProvider(requestingProviderType, dep.token, eager))) {
	                return dep;
	            }
	        }
	        return null;
	    };
	    ProviderElementContext.prototype._getDependency = function (requestingProviderType, dep, eager) {
	        if (eager === void 0) { eager = null; }
	        var currElement = this;
	        var currEager = eager;
	        var result = null;
	        if (!dep.isSkipSelf) {
	            result = this._getLocalDependency(requestingProviderType, dep, eager);
	        }
	        if (dep.isSelf) {
	            if (lang_1.isBlank(result) && dep.isOptional) {
	                result = new compile_metadata_1.CompileDiDependencyMetadata({ isValue: true, value: null });
	            }
	        }
	        else {
	            // check parent elements
	            while (lang_1.isBlank(result) && lang_1.isPresent(currElement._parent)) {
	                var prevElement = currElement;
	                currElement = currElement._parent;
	                if (prevElement._isViewRoot) {
	                    currEager = false;
	                }
	                result = currElement._getLocalDependency(template_ast_1.ProviderAstType.PublicService, dep, currEager);
	            }
	            // check @Host restriction
	            if (lang_1.isBlank(result)) {
	                if (!dep.isHost || this._viewContext.component.type.isHost ||
	                    identifiers_1.identifierToken(this._viewContext.component.type).equalsTo(dep.token) ||
	                    lang_1.isPresent(this._viewContext.viewProviders.get(dep.token))) {
	                    result = dep;
	                }
	                else {
	                    result = dep.isOptional ?
	                        result = new compile_metadata_1.CompileDiDependencyMetadata({ isValue: true, value: null }) :
	                        null;
	                }
	            }
	        }
	        if (lang_1.isBlank(result)) {
	            this._viewContext.errors.push(new ProviderError("No provider for " + dep.token.name, this._sourceSpan));
	        }
	        return result;
	    };
	    return ProviderElementContext;
	}());
	exports.ProviderElementContext = ProviderElementContext;
	function _transformProvider(provider, _a) {
	    var useExisting = _a.useExisting, useValue = _a.useValue, deps = _a.deps;
	    return new compile_metadata_1.CompileProviderMetadata({
	        token: provider.token,
	        useClass: provider.useClass,
	        useExisting: useExisting,
	        useFactory: provider.useFactory,
	        useValue: useValue,
	        deps: deps,
	        multi: provider.multi
	    });
	}
	function _transformProviderAst(provider, _a) {
	    var eager = _a.eager, providers = _a.providers;
	    return new template_ast_1.ProviderAst(provider.token, provider.multiProvider, provider.eager || eager, providers, provider.providerType, provider.sourceSpan);
	}
	function _normalizeProviders(providers, sourceSpan, targetErrors, targetProviders) {
	    if (targetProviders === void 0) { targetProviders = null; }
	    if (lang_1.isBlank(targetProviders)) {
	        targetProviders = [];
	    }
	    if (lang_1.isPresent(providers)) {
	        providers.forEach(function (provider) {
	            if (lang_1.isArray(provider)) {
	                _normalizeProviders(provider, sourceSpan, targetErrors, targetProviders);
	            }
	            else {
	                var normalizeProvider;
	                if (provider instanceof compile_metadata_1.CompileProviderMetadata) {
	                    normalizeProvider = provider;
	                }
	                else if (provider instanceof compile_metadata_1.CompileTypeMetadata) {
	                    normalizeProvider = new compile_metadata_1.CompileProviderMetadata({ token: new compile_metadata_1.CompileTokenMetadata({ identifier: provider }), useClass: provider });
	                }
	                else {
	                    targetErrors.push(new ProviderError("Unknown provider type " + provider, sourceSpan));
	                }
	                if (lang_1.isPresent(normalizeProvider)) {
	                    targetProviders.push(normalizeProvider);
	                }
	            }
	        });
	    }
	    return targetProviders;
	}
	function _resolveProvidersFromDirectives(directives, sourceSpan, targetErrors) {
	    var providersByToken = new compile_metadata_1.CompileTokenMap();
	    directives.forEach(function (directive) {
	        var dirProvider = new compile_metadata_1.CompileProviderMetadata({ token: new compile_metadata_1.CompileTokenMetadata({ identifier: directive.type }), useClass: directive.type });
	        _resolveProviders([dirProvider], directive.isComponent ? template_ast_1.ProviderAstType.Component : template_ast_1.ProviderAstType.Directive, true, sourceSpan, targetErrors, providersByToken);
	    });
	    // Note: directives need to be able to overwrite providers of a component!
	    var directivesWithComponentFirst = directives.filter(function (dir) { return dir.isComponent; }).concat(directives.filter(function (dir) { return !dir.isComponent; }));
	    directivesWithComponentFirst.forEach(function (directive) {
	        _resolveProviders(_normalizeProviders(directive.providers, sourceSpan, targetErrors), template_ast_1.ProviderAstType.PublicService, false, sourceSpan, targetErrors, providersByToken);
	        _resolveProviders(_normalizeProviders(directive.viewProviders, sourceSpan, targetErrors), template_ast_1.ProviderAstType.PrivateService, false, sourceSpan, targetErrors, providersByToken);
	    });
	    return providersByToken;
	}
	function _resolveProviders(providers, providerType, eager, sourceSpan, targetErrors, targetProvidersByToken) {
	    providers.forEach(function (provider) {
	        var resolvedProvider = targetProvidersByToken.get(provider.token);
	        if (lang_1.isPresent(resolvedProvider) && resolvedProvider.multiProvider !== provider.multi) {
	            targetErrors.push(new ProviderError("Mixing multi and non multi provider is not possible for token " + resolvedProvider.token.name, sourceSpan));
	        }
	        if (lang_1.isBlank(resolvedProvider)) {
	            resolvedProvider = new template_ast_1.ProviderAst(provider.token, provider.multi, eager, [provider], providerType, sourceSpan);
	            targetProvidersByToken.add(provider.token, resolvedProvider);
	        }
	        else {
	            if (!provider.multi) {
	                collection_1.ListWrapper.clear(resolvedProvider.providers);
	            }
	            resolvedProvider.providers.push(provider);
	        }
	    });
	}
	function _getViewQueries(component) {
	    var viewQueries = new compile_metadata_1.CompileTokenMap();
	    if (lang_1.isPresent(component.viewQueries)) {
	        component.viewQueries.forEach(function (query) { return _addQueryToTokenMap(viewQueries, query); });
	    }
	    component.type.diDeps.forEach(function (dep) {
	        if (lang_1.isPresent(dep.viewQuery)) {
	            _addQueryToTokenMap(viewQueries, dep.viewQuery);
	        }
	    });
	    return viewQueries;
	}
	function _getContentQueries(directives) {
	    var contentQueries = new compile_metadata_1.CompileTokenMap();
	    directives.forEach(function (directive) {
	        if (lang_1.isPresent(directive.queries)) {
	            directive.queries.forEach(function (query) { return _addQueryToTokenMap(contentQueries, query); });
	        }
	        directive.type.diDeps.forEach(function (dep) {
	            if (lang_1.isPresent(dep.query)) {
	                _addQueryToTokenMap(contentQueries, dep.query);
	            }
	        });
	    });
	    return contentQueries;
	}
	function _addQueryToTokenMap(map, query) {
	    query.selectors.forEach(function (token) {
	        var entry = map.get(token);
	        if (lang_1.isBlank(entry)) {
	            entry = [];
	            map.add(token, entry);
	        }
	        entry.push(query);
	    });
	}


/***/ },
/* 164 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var identifiers_1 = __webpack_require__(156);
	var CompilerConfig = (function () {
	    function CompilerConfig(genDebugInfo, logBindingUpdate, useJit, renderTypes) {
	        if (renderTypes === void 0) { renderTypes = null; }
	        this.genDebugInfo = genDebugInfo;
	        this.logBindingUpdate = logBindingUpdate;
	        this.useJit = useJit;
	        if (lang_1.isBlank(renderTypes)) {
	            renderTypes = new DefaultRenderTypes();
	        }
	        this.renderTypes = renderTypes;
	    }
	    return CompilerConfig;
	}());
	exports.CompilerConfig = CompilerConfig;
	/**
	 * Types used for the renderer.
	 * Can be replaced to specialize the generated output to a specific renderer
	 * to help tree shaking.
	 */
	var RenderTypes = (function () {
	    function RenderTypes() {
	    }
	    Object.defineProperty(RenderTypes.prototype, "renderer", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(RenderTypes.prototype, "renderText", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(RenderTypes.prototype, "renderElement", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(RenderTypes.prototype, "renderComment", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(RenderTypes.prototype, "renderNode", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(RenderTypes.prototype, "renderEvent", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    return RenderTypes;
	}());
	exports.RenderTypes = RenderTypes;
	var DefaultRenderTypes = (function () {
	    function DefaultRenderTypes() {
	        this.renderer = identifiers_1.Identifiers.Renderer;
	        this.renderText = null;
	        this.renderElement = null;
	        this.renderComment = null;
	        this.renderNode = null;
	        this.renderEvent = null;
	    }
	    return DefaultRenderTypes;
	}());
	exports.DefaultRenderTypes = DefaultRenderTypes;


/***/ },
/* 165 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var compile_metadata_1 = __webpack_require__(157);
	var exceptions_1 = __webpack_require__(12);
	var collection_1 = __webpack_require__(15);
	var o = __webpack_require__(166);
	var component_factory_1 = __webpack_require__(67);
	var util_1 = __webpack_require__(155);
	var _COMPONENT_FACTORY_IDENTIFIER = new compile_metadata_1.CompileIdentifierMetadata({
	    name: 'ComponentFactory',
	    runtime: component_factory_1.ComponentFactory,
	    moduleUrl: "asset:angular2/lib/src/core/linker/component_factory" + util_1.MODULE_SUFFIX
	});
	var SourceModule = (function () {
	    function SourceModule(moduleUrl, source) {
	        this.moduleUrl = moduleUrl;
	        this.source = source;
	    }
	    return SourceModule;
	}());
	exports.SourceModule = SourceModule;
	var NormalizedComponentWithViewDirectives = (function () {
	    function NormalizedComponentWithViewDirectives(component, directives, pipes) {
	        this.component = component;
	        this.directives = directives;
	        this.pipes = pipes;
	    }
	    return NormalizedComponentWithViewDirectives;
	}());
	exports.NormalizedComponentWithViewDirectives = NormalizedComponentWithViewDirectives;
	var OfflineCompiler = (function () {
	    function OfflineCompiler(_directiveNormalizer, _templateParser, _styleCompiler, _viewCompiler, _outputEmitter) {
	        this._directiveNormalizer = _directiveNormalizer;
	        this._templateParser = _templateParser;
	        this._styleCompiler = _styleCompiler;
	        this._viewCompiler = _viewCompiler;
	        this._outputEmitter = _outputEmitter;
	    }
	    OfflineCompiler.prototype.normalizeDirectiveMetadata = function (directive) {
	        return this._directiveNormalizer.normalizeDirective(directive);
	    };
	    OfflineCompiler.prototype.compileTemplates = function (components) {
	        var _this = this;
	        if (components.length === 0) {
	            throw new exceptions_1.BaseException('No components given');
	        }
	        var statements = [];
	        var exportedVars = [];
	        var moduleUrl = _templateModuleUrl(components[0].component);
	        components.forEach(function (componentWithDirs) {
	            var compMeta = componentWithDirs.component;
	            _assertComponent(compMeta);
	            var compViewFactoryVar = _this._compileComponent(compMeta, componentWithDirs.directives, componentWithDirs.pipes, statements);
	            exportedVars.push(compViewFactoryVar);
	            var hostMeta = compile_metadata_1.createHostComponentMeta(compMeta.type, compMeta.selector);
	            var hostViewFactoryVar = _this._compileComponent(hostMeta, [compMeta], [], statements);
	            var compFactoryVar = compMeta.type.name + "NgFactory";
	            statements.push(o.variable(compFactoryVar)
	                .set(o.importExpr(_COMPONENT_FACTORY_IDENTIFIER, [o.importType(compMeta.type)])
	                .instantiate([
	                o.literal(compMeta.selector),
	                o.variable(hostViewFactoryVar),
	                o.importExpr(compMeta.type)
	            ], o.importType(_COMPONENT_FACTORY_IDENTIFIER, [o.importType(compMeta.type)], [o.TypeModifier.Const])))
	                .toDeclStmt(null, [o.StmtModifier.Final]));
	            exportedVars.push(compFactoryVar);
	        });
	        return this._codegenSourceModule(moduleUrl, statements, exportedVars);
	    };
	    OfflineCompiler.prototype.compileStylesheet = function (stylesheetUrl, cssText) {
	        var plainStyles = this._styleCompiler.compileStylesheet(stylesheetUrl, cssText, false);
	        var shimStyles = this._styleCompiler.compileStylesheet(stylesheetUrl, cssText, true);
	        return [
	            this._codegenSourceModule(_stylesModuleUrl(stylesheetUrl, false), _resolveStyleStatements(plainStyles), [plainStyles.stylesVar]),
	            this._codegenSourceModule(_stylesModuleUrl(stylesheetUrl, true), _resolveStyleStatements(shimStyles), [shimStyles.stylesVar])
	        ];
	    };
	    OfflineCompiler.prototype._compileComponent = function (compMeta, directives, pipes, targetStatements) {
	        var styleResult = this._styleCompiler.compileComponent(compMeta);
	        var parsedTemplate = this._templateParser.parse(compMeta, compMeta.template.template, directives, pipes, compMeta.type.name);
	        var viewResult = this._viewCompiler.compileComponent(compMeta, parsedTemplate, o.variable(styleResult.stylesVar), pipes);
	        collection_1.ListWrapper.addAll(targetStatements, _resolveStyleStatements(styleResult));
	        collection_1.ListWrapper.addAll(targetStatements, _resolveViewStatements(viewResult));
	        return viewResult.viewFactoryVar;
	    };
	    OfflineCompiler.prototype._codegenSourceModule = function (moduleUrl, statements, exportedVars) {
	        return new SourceModule(moduleUrl, this._outputEmitter.emitStatements(moduleUrl, statements, exportedVars));
	    };
	    return OfflineCompiler;
	}());
	exports.OfflineCompiler = OfflineCompiler;
	function _resolveViewStatements(compileResult) {
	    compileResult.dependencies.forEach(function (dep) { dep.factoryPlaceholder.moduleUrl = _templateModuleUrl(dep.comp); });
	    return compileResult.statements;
	}
	function _resolveStyleStatements(compileResult) {
	    compileResult.dependencies.forEach(function (dep) {
	        dep.valuePlaceholder.moduleUrl = _stylesModuleUrl(dep.sourceUrl, dep.isShimmed);
	    });
	    return compileResult.statements;
	}
	function _templateModuleUrl(comp) {
	    var moduleUrl = comp.type.moduleUrl;
	    var urlWithoutSuffix = moduleUrl.substring(0, moduleUrl.length - util_1.MODULE_SUFFIX.length);
	    return urlWithoutSuffix + ".ngfactory" + util_1.MODULE_SUFFIX;
	}
	function _stylesModuleUrl(stylesheetUrl, shim) {
	    return shim ? stylesheetUrl + ".shim" + util_1.MODULE_SUFFIX : "" + stylesheetUrl + util_1.MODULE_SUFFIX;
	}
	function _assertComponent(meta) {
	    if (!meta.isComponent) {
	        throw new exceptions_1.BaseException("Could not compile '" + meta.type.name + "' because it is not a component.");
	    }
	}


/***/ },
/* 166 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	//// Types
	(function (TypeModifier) {
	    TypeModifier[TypeModifier["Const"] = 0] = "Const";
	})(exports.TypeModifier || (exports.TypeModifier = {}));
	var TypeModifier = exports.TypeModifier;
	var Type = (function () {
	    function Type(modifiers) {
	        if (modifiers === void 0) { modifiers = null; }
	        this.modifiers = modifiers;
	        if (lang_1.isBlank(modifiers)) {
	            this.modifiers = [];
	        }
	    }
	    Type.prototype.hasModifier = function (modifier) { return this.modifiers.indexOf(modifier) !== -1; };
	    return Type;
	}());
	exports.Type = Type;
	(function (BuiltinTypeName) {
	    BuiltinTypeName[BuiltinTypeName["Dynamic"] = 0] = "Dynamic";
	    BuiltinTypeName[BuiltinTypeName["Bool"] = 1] = "Bool";
	    BuiltinTypeName[BuiltinTypeName["String"] = 2] = "String";
	    BuiltinTypeName[BuiltinTypeName["Int"] = 3] = "Int";
	    BuiltinTypeName[BuiltinTypeName["Number"] = 4] = "Number";
	    BuiltinTypeName[BuiltinTypeName["Function"] = 5] = "Function";
	})(exports.BuiltinTypeName || (exports.BuiltinTypeName = {}));
	var BuiltinTypeName = exports.BuiltinTypeName;
	var BuiltinType = (function (_super) {
	    __extends(BuiltinType, _super);
	    function BuiltinType(name, modifiers) {
	        if (modifiers === void 0) { modifiers = null; }
	        _super.call(this, modifiers);
	        this.name = name;
	    }
	    BuiltinType.prototype.visitType = function (visitor, context) {
	        return visitor.visitBuiltintType(this, context);
	    };
	    return BuiltinType;
	}(Type));
	exports.BuiltinType = BuiltinType;
	var ExternalType = (function (_super) {
	    __extends(ExternalType, _super);
	    function ExternalType(value, typeParams, modifiers) {
	        if (typeParams === void 0) { typeParams = null; }
	        if (modifiers === void 0) { modifiers = null; }
	        _super.call(this, modifiers);
	        this.value = value;
	        this.typeParams = typeParams;
	    }
	    ExternalType.prototype.visitType = function (visitor, context) {
	        return visitor.visitExternalType(this, context);
	    };
	    return ExternalType;
	}(Type));
	exports.ExternalType = ExternalType;
	var ArrayType = (function (_super) {
	    __extends(ArrayType, _super);
	    function ArrayType(of, modifiers) {
	        if (modifiers === void 0) { modifiers = null; }
	        _super.call(this, modifiers);
	        this.of = of;
	    }
	    ArrayType.prototype.visitType = function (visitor, context) {
	        return visitor.visitArrayType(this, context);
	    };
	    return ArrayType;
	}(Type));
	exports.ArrayType = ArrayType;
	var MapType = (function (_super) {
	    __extends(MapType, _super);
	    function MapType(valueType, modifiers) {
	        if (modifiers === void 0) { modifiers = null; }
	        _super.call(this, modifiers);
	        this.valueType = valueType;
	    }
	    MapType.prototype.visitType = function (visitor, context) { return visitor.visitMapType(this, context); };
	    return MapType;
	}(Type));
	exports.MapType = MapType;
	exports.DYNAMIC_TYPE = new BuiltinType(BuiltinTypeName.Dynamic);
	exports.BOOL_TYPE = new BuiltinType(BuiltinTypeName.Bool);
	exports.INT_TYPE = new BuiltinType(BuiltinTypeName.Int);
	exports.NUMBER_TYPE = new BuiltinType(BuiltinTypeName.Number);
	exports.STRING_TYPE = new BuiltinType(BuiltinTypeName.String);
	exports.FUNCTION_TYPE = new BuiltinType(BuiltinTypeName.Function);
	///// Expressions
	(function (BinaryOperator) {
	    BinaryOperator[BinaryOperator["Equals"] = 0] = "Equals";
	    BinaryOperator[BinaryOperator["NotEquals"] = 1] = "NotEquals";
	    BinaryOperator[BinaryOperator["Identical"] = 2] = "Identical";
	    BinaryOperator[BinaryOperator["NotIdentical"] = 3] = "NotIdentical";
	    BinaryOperator[BinaryOperator["Minus"] = 4] = "Minus";
	    BinaryOperator[BinaryOperator["Plus"] = 5] = "Plus";
	    BinaryOperator[BinaryOperator["Divide"] = 6] = "Divide";
	    BinaryOperator[BinaryOperator["Multiply"] = 7] = "Multiply";
	    BinaryOperator[BinaryOperator["Modulo"] = 8] = "Modulo";
	    BinaryOperator[BinaryOperator["And"] = 9] = "And";
	    BinaryOperator[BinaryOperator["Or"] = 10] = "Or";
	    BinaryOperator[BinaryOperator["Lower"] = 11] = "Lower";
	    BinaryOperator[BinaryOperator["LowerEquals"] = 12] = "LowerEquals";
	    BinaryOperator[BinaryOperator["Bigger"] = 13] = "Bigger";
	    BinaryOperator[BinaryOperator["BiggerEquals"] = 14] = "BiggerEquals";
	})(exports.BinaryOperator || (exports.BinaryOperator = {}));
	var BinaryOperator = exports.BinaryOperator;
	var Expression = (function () {
	    function Expression(type) {
	        this.type = type;
	    }
	    Expression.prototype.prop = function (name) { return new ReadPropExpr(this, name); };
	    Expression.prototype.key = function (index, type) {
	        if (type === void 0) { type = null; }
	        return new ReadKeyExpr(this, index, type);
	    };
	    Expression.prototype.callMethod = function (name, params) {
	        return new InvokeMethodExpr(this, name, params);
	    };
	    Expression.prototype.callFn = function (params) { return new InvokeFunctionExpr(this, params); };
	    Expression.prototype.instantiate = function (params, type) {
	        if (type === void 0) { type = null; }
	        return new InstantiateExpr(this, params, type);
	    };
	    Expression.prototype.conditional = function (trueCase, falseCase) {
	        if (falseCase === void 0) { falseCase = null; }
	        return new ConditionalExpr(this, trueCase, falseCase);
	    };
	    Expression.prototype.equals = function (rhs) {
	        return new BinaryOperatorExpr(BinaryOperator.Equals, this, rhs);
	    };
	    Expression.prototype.notEquals = function (rhs) {
	        return new BinaryOperatorExpr(BinaryOperator.NotEquals, this, rhs);
	    };
	    Expression.prototype.identical = function (rhs) {
	        return new BinaryOperatorExpr(BinaryOperator.Identical, this, rhs);
	    };
	    Expression.prototype.notIdentical = function (rhs) {
	        return new BinaryOperatorExpr(BinaryOperator.NotIdentical, this, rhs);
	    };
	    Expression.prototype.minus = function (rhs) {
	        return new BinaryOperatorExpr(BinaryOperator.Minus, this, rhs);
	    };
	    Expression.prototype.plus = function (rhs) {
	        return new BinaryOperatorExpr(BinaryOperator.Plus, this, rhs);
	    };
	    Expression.prototype.divide = function (rhs) {
	        return new BinaryOperatorExpr(BinaryOperator.Divide, this, rhs);
	    };
	    Expression.prototype.multiply = function (rhs) {
	        return new BinaryOperatorExpr(BinaryOperator.Multiply, this, rhs);
	    };
	    Expression.prototype.modulo = function (rhs) {
	        return new BinaryOperatorExpr(BinaryOperator.Modulo, this, rhs);
	    };
	    Expression.prototype.and = function (rhs) {
	        return new BinaryOperatorExpr(BinaryOperator.And, this, rhs);
	    };
	    Expression.prototype.or = function (rhs) {
	        return new BinaryOperatorExpr(BinaryOperator.Or, this, rhs);
	    };
	    Expression.prototype.lower = function (rhs) {
	        return new BinaryOperatorExpr(BinaryOperator.Lower, this, rhs);
	    };
	    Expression.prototype.lowerEquals = function (rhs) {
	        return new BinaryOperatorExpr(BinaryOperator.LowerEquals, this, rhs);
	    };
	    Expression.prototype.bigger = function (rhs) {
	        return new BinaryOperatorExpr(BinaryOperator.Bigger, this, rhs);
	    };
	    Expression.prototype.biggerEquals = function (rhs) {
	        return new BinaryOperatorExpr(BinaryOperator.BiggerEquals, this, rhs);
	    };
	    Expression.prototype.isBlank = function () {
	        // Note: We use equals by purpose here to compare to null and undefined in JS.
	        return this.equals(exports.NULL_EXPR);
	    };
	    Expression.prototype.cast = function (type) { return new CastExpr(this, type); };
	    Expression.prototype.toStmt = function () { return new ExpressionStatement(this); };
	    return Expression;
	}());
	exports.Expression = Expression;
	(function (BuiltinVar) {
	    BuiltinVar[BuiltinVar["This"] = 0] = "This";
	    BuiltinVar[BuiltinVar["Super"] = 1] = "Super";
	    BuiltinVar[BuiltinVar["CatchError"] = 2] = "CatchError";
	    BuiltinVar[BuiltinVar["CatchStack"] = 3] = "CatchStack";
	})(exports.BuiltinVar || (exports.BuiltinVar = {}));
	var BuiltinVar = exports.BuiltinVar;
	var ReadVarExpr = (function (_super) {
	    __extends(ReadVarExpr, _super);
	    function ReadVarExpr(name, type) {
	        if (type === void 0) { type = null; }
	        _super.call(this, type);
	        if (lang_1.isString(name)) {
	            this.name = name;
	            this.builtin = null;
	        }
	        else {
	            this.name = null;
	            this.builtin = name;
	        }
	    }
	    ReadVarExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitReadVarExpr(this, context);
	    };
	    ReadVarExpr.prototype.set = function (value) { return new WriteVarExpr(this.name, value); };
	    return ReadVarExpr;
	}(Expression));
	exports.ReadVarExpr = ReadVarExpr;
	var WriteVarExpr = (function (_super) {
	    __extends(WriteVarExpr, _super);
	    function WriteVarExpr(name, value, type) {
	        if (type === void 0) { type = null; }
	        _super.call(this, lang_1.isPresent(type) ? type : value.type);
	        this.name = name;
	        this.value = value;
	    }
	    WriteVarExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitWriteVarExpr(this, context);
	    };
	    WriteVarExpr.prototype.toDeclStmt = function (type, modifiers) {
	        if (type === void 0) { type = null; }
	        if (modifiers === void 0) { modifiers = null; }
	        return new DeclareVarStmt(this.name, this.value, type, modifiers);
	    };
	    return WriteVarExpr;
	}(Expression));
	exports.WriteVarExpr = WriteVarExpr;
	var WriteKeyExpr = (function (_super) {
	    __extends(WriteKeyExpr, _super);
	    function WriteKeyExpr(receiver, index, value, type) {
	        if (type === void 0) { type = null; }
	        _super.call(this, lang_1.isPresent(type) ? type : value.type);
	        this.receiver = receiver;
	        this.index = index;
	        this.value = value;
	    }
	    WriteKeyExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitWriteKeyExpr(this, context);
	    };
	    return WriteKeyExpr;
	}(Expression));
	exports.WriteKeyExpr = WriteKeyExpr;
	var WritePropExpr = (function (_super) {
	    __extends(WritePropExpr, _super);
	    function WritePropExpr(receiver, name, value, type) {
	        if (type === void 0) { type = null; }
	        _super.call(this, lang_1.isPresent(type) ? type : value.type);
	        this.receiver = receiver;
	        this.name = name;
	        this.value = value;
	    }
	    WritePropExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitWritePropExpr(this, context);
	    };
	    return WritePropExpr;
	}(Expression));
	exports.WritePropExpr = WritePropExpr;
	(function (BuiltinMethod) {
	    BuiltinMethod[BuiltinMethod["ConcatArray"] = 0] = "ConcatArray";
	    BuiltinMethod[BuiltinMethod["SubscribeObservable"] = 1] = "SubscribeObservable";
	    BuiltinMethod[BuiltinMethod["bind"] = 2] = "bind";
	})(exports.BuiltinMethod || (exports.BuiltinMethod = {}));
	var BuiltinMethod = exports.BuiltinMethod;
	var InvokeMethodExpr = (function (_super) {
	    __extends(InvokeMethodExpr, _super);
	    function InvokeMethodExpr(receiver, method, args, type) {
	        if (type === void 0) { type = null; }
	        _super.call(this, type);
	        this.receiver = receiver;
	        this.args = args;
	        if (lang_1.isString(method)) {
	            this.name = method;
	            this.builtin = null;
	        }
	        else {
	            this.name = null;
	            this.builtin = method;
	        }
	    }
	    InvokeMethodExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitInvokeMethodExpr(this, context);
	    };
	    return InvokeMethodExpr;
	}(Expression));
	exports.InvokeMethodExpr = InvokeMethodExpr;
	var InvokeFunctionExpr = (function (_super) {
	    __extends(InvokeFunctionExpr, _super);
	    function InvokeFunctionExpr(fn, args, type) {
	        if (type === void 0) { type = null; }
	        _super.call(this, type);
	        this.fn = fn;
	        this.args = args;
	    }
	    InvokeFunctionExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitInvokeFunctionExpr(this, context);
	    };
	    return InvokeFunctionExpr;
	}(Expression));
	exports.InvokeFunctionExpr = InvokeFunctionExpr;
	var InstantiateExpr = (function (_super) {
	    __extends(InstantiateExpr, _super);
	    function InstantiateExpr(classExpr, args, type) {
	        _super.call(this, type);
	        this.classExpr = classExpr;
	        this.args = args;
	    }
	    InstantiateExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitInstantiateExpr(this, context);
	    };
	    return InstantiateExpr;
	}(Expression));
	exports.InstantiateExpr = InstantiateExpr;
	var LiteralExpr = (function (_super) {
	    __extends(LiteralExpr, _super);
	    function LiteralExpr(value, type) {
	        if (type === void 0) { type = null; }
	        _super.call(this, type);
	        this.value = value;
	    }
	    LiteralExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitLiteralExpr(this, context);
	    };
	    return LiteralExpr;
	}(Expression));
	exports.LiteralExpr = LiteralExpr;
	var ExternalExpr = (function (_super) {
	    __extends(ExternalExpr, _super);
	    function ExternalExpr(value, type, typeParams) {
	        if (type === void 0) { type = null; }
	        if (typeParams === void 0) { typeParams = null; }
	        _super.call(this, type);
	        this.value = value;
	        this.typeParams = typeParams;
	    }
	    ExternalExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitExternalExpr(this, context);
	    };
	    return ExternalExpr;
	}(Expression));
	exports.ExternalExpr = ExternalExpr;
	var ConditionalExpr = (function (_super) {
	    __extends(ConditionalExpr, _super);
	    function ConditionalExpr(condition, trueCase, falseCase, type) {
	        if (falseCase === void 0) { falseCase = null; }
	        if (type === void 0) { type = null; }
	        _super.call(this, lang_1.isPresent(type) ? type : trueCase.type);
	        this.condition = condition;
	        this.falseCase = falseCase;
	        this.trueCase = trueCase;
	    }
	    ConditionalExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitConditionalExpr(this, context);
	    };
	    return ConditionalExpr;
	}(Expression));
	exports.ConditionalExpr = ConditionalExpr;
	var NotExpr = (function (_super) {
	    __extends(NotExpr, _super);
	    function NotExpr(condition) {
	        _super.call(this, exports.BOOL_TYPE);
	        this.condition = condition;
	    }
	    NotExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitNotExpr(this, context);
	    };
	    return NotExpr;
	}(Expression));
	exports.NotExpr = NotExpr;
	var CastExpr = (function (_super) {
	    __extends(CastExpr, _super);
	    function CastExpr(value, type) {
	        _super.call(this, type);
	        this.value = value;
	    }
	    CastExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitCastExpr(this, context);
	    };
	    return CastExpr;
	}(Expression));
	exports.CastExpr = CastExpr;
	var FnParam = (function () {
	    function FnParam(name, type) {
	        if (type === void 0) { type = null; }
	        this.name = name;
	        this.type = type;
	    }
	    return FnParam;
	}());
	exports.FnParam = FnParam;
	var FunctionExpr = (function (_super) {
	    __extends(FunctionExpr, _super);
	    function FunctionExpr(params, statements, type) {
	        if (type === void 0) { type = null; }
	        _super.call(this, type);
	        this.params = params;
	        this.statements = statements;
	    }
	    FunctionExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitFunctionExpr(this, context);
	    };
	    FunctionExpr.prototype.toDeclStmt = function (name, modifiers) {
	        if (modifiers === void 0) { modifiers = null; }
	        return new DeclareFunctionStmt(name, this.params, this.statements, this.type, modifiers);
	    };
	    return FunctionExpr;
	}(Expression));
	exports.FunctionExpr = FunctionExpr;
	var BinaryOperatorExpr = (function (_super) {
	    __extends(BinaryOperatorExpr, _super);
	    function BinaryOperatorExpr(operator, lhs, rhs, type) {
	        if (type === void 0) { type = null; }
	        _super.call(this, lang_1.isPresent(type) ? type : lhs.type);
	        this.operator = operator;
	        this.rhs = rhs;
	        this.lhs = lhs;
	    }
	    BinaryOperatorExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitBinaryOperatorExpr(this, context);
	    };
	    return BinaryOperatorExpr;
	}(Expression));
	exports.BinaryOperatorExpr = BinaryOperatorExpr;
	var ReadPropExpr = (function (_super) {
	    __extends(ReadPropExpr, _super);
	    function ReadPropExpr(receiver, name, type) {
	        if (type === void 0) { type = null; }
	        _super.call(this, type);
	        this.receiver = receiver;
	        this.name = name;
	    }
	    ReadPropExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitReadPropExpr(this, context);
	    };
	    ReadPropExpr.prototype.set = function (value) {
	        return new WritePropExpr(this.receiver, this.name, value);
	    };
	    return ReadPropExpr;
	}(Expression));
	exports.ReadPropExpr = ReadPropExpr;
	var ReadKeyExpr = (function (_super) {
	    __extends(ReadKeyExpr, _super);
	    function ReadKeyExpr(receiver, index, type) {
	        if (type === void 0) { type = null; }
	        _super.call(this, type);
	        this.receiver = receiver;
	        this.index = index;
	    }
	    ReadKeyExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitReadKeyExpr(this, context);
	    };
	    ReadKeyExpr.prototype.set = function (value) {
	        return new WriteKeyExpr(this.receiver, this.index, value);
	    };
	    return ReadKeyExpr;
	}(Expression));
	exports.ReadKeyExpr = ReadKeyExpr;
	var LiteralArrayExpr = (function (_super) {
	    __extends(LiteralArrayExpr, _super);
	    function LiteralArrayExpr(entries, type) {
	        if (type === void 0) { type = null; }
	        _super.call(this, type);
	        this.entries = entries;
	    }
	    LiteralArrayExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitLiteralArrayExpr(this, context);
	    };
	    return LiteralArrayExpr;
	}(Expression));
	exports.LiteralArrayExpr = LiteralArrayExpr;
	var LiteralMapExpr = (function (_super) {
	    __extends(LiteralMapExpr, _super);
	    function LiteralMapExpr(entries, type) {
	        if (type === void 0) { type = null; }
	        _super.call(this, type);
	        this.entries = entries;
	        this.valueType = null;
	        if (lang_1.isPresent(type)) {
	            this.valueType = type.valueType;
	        }
	    }
	    ;
	    LiteralMapExpr.prototype.visitExpression = function (visitor, context) {
	        return visitor.visitLiteralMapExpr(this, context);
	    };
	    return LiteralMapExpr;
	}(Expression));
	exports.LiteralMapExpr = LiteralMapExpr;
	exports.THIS_EXPR = new ReadVarExpr(BuiltinVar.This);
	exports.SUPER_EXPR = new ReadVarExpr(BuiltinVar.Super);
	exports.CATCH_ERROR_VAR = new ReadVarExpr(BuiltinVar.CatchError);
	exports.CATCH_STACK_VAR = new ReadVarExpr(BuiltinVar.CatchStack);
	exports.NULL_EXPR = new LiteralExpr(null, null);
	//// Statements
	(function (StmtModifier) {
	    StmtModifier[StmtModifier["Final"] = 0] = "Final";
	    StmtModifier[StmtModifier["Private"] = 1] = "Private";
	})(exports.StmtModifier || (exports.StmtModifier = {}));
	var StmtModifier = exports.StmtModifier;
	var Statement = (function () {
	    function Statement(modifiers) {
	        if (modifiers === void 0) { modifiers = null; }
	        this.modifiers = modifiers;
	        if (lang_1.isBlank(modifiers)) {
	            this.modifiers = [];
	        }
	    }
	    Statement.prototype.hasModifier = function (modifier) { return this.modifiers.indexOf(modifier) !== -1; };
	    return Statement;
	}());
	exports.Statement = Statement;
	var DeclareVarStmt = (function (_super) {
	    __extends(DeclareVarStmt, _super);
	    function DeclareVarStmt(name, value, type, modifiers) {
	        if (type === void 0) { type = null; }
	        if (modifiers === void 0) { modifiers = null; }
	        _super.call(this, modifiers);
	        this.name = name;
	        this.value = value;
	        this.type = lang_1.isPresent(type) ? type : value.type;
	    }
	    DeclareVarStmt.prototype.visitStatement = function (visitor, context) {
	        return visitor.visitDeclareVarStmt(this, context);
	    };
	    return DeclareVarStmt;
	}(Statement));
	exports.DeclareVarStmt = DeclareVarStmt;
	var DeclareFunctionStmt = (function (_super) {
	    __extends(DeclareFunctionStmt, _super);
	    function DeclareFunctionStmt(name, params, statements, type, modifiers) {
	        if (type === void 0) { type = null; }
	        if (modifiers === void 0) { modifiers = null; }
	        _super.call(this, modifiers);
	        this.name = name;
	        this.params = params;
	        this.statements = statements;
	        this.type = type;
	    }
	    DeclareFunctionStmt.prototype.visitStatement = function (visitor, context) {
	        return visitor.visitDeclareFunctionStmt(this, context);
	    };
	    return DeclareFunctionStmt;
	}(Statement));
	exports.DeclareFunctionStmt = DeclareFunctionStmt;
	var ExpressionStatement = (function (_super) {
	    __extends(ExpressionStatement, _super);
	    function ExpressionStatement(expr) {
	        _super.call(this);
	        this.expr = expr;
	    }
	    ExpressionStatement.prototype.visitStatement = function (visitor, context) {
	        return visitor.visitExpressionStmt(this, context);
	    };
	    return ExpressionStatement;
	}(Statement));
	exports.ExpressionStatement = ExpressionStatement;
	var ReturnStatement = (function (_super) {
	    __extends(ReturnStatement, _super);
	    function ReturnStatement(value) {
	        _super.call(this);
	        this.value = value;
	    }
	    ReturnStatement.prototype.visitStatement = function (visitor, context) {
	        return visitor.visitReturnStmt(this, context);
	    };
	    return ReturnStatement;
	}(Statement));
	exports.ReturnStatement = ReturnStatement;
	var AbstractClassPart = (function () {
	    function AbstractClassPart(type, modifiers) {
	        if (type === void 0) { type = null; }
	        this.type = type;
	        this.modifiers = modifiers;
	        if (lang_1.isBlank(modifiers)) {
	            this.modifiers = [];
	        }
	    }
	    AbstractClassPart.prototype.hasModifier = function (modifier) { return this.modifiers.indexOf(modifier) !== -1; };
	    return AbstractClassPart;
	}());
	exports.AbstractClassPart = AbstractClassPart;
	var ClassField = (function (_super) {
	    __extends(ClassField, _super);
	    function ClassField(name, type, modifiers) {
	        if (type === void 0) { type = null; }
	        if (modifiers === void 0) { modifiers = null; }
	        _super.call(this, type, modifiers);
	        this.name = name;
	    }
	    return ClassField;
	}(AbstractClassPart));
	exports.ClassField = ClassField;
	var ClassMethod = (function (_super) {
	    __extends(ClassMethod, _super);
	    function ClassMethod(name, params, body, type, modifiers) {
	        if (type === void 0) { type = null; }
	        if (modifiers === void 0) { modifiers = null; }
	        _super.call(this, type, modifiers);
	        this.name = name;
	        this.params = params;
	        this.body = body;
	    }
	    return ClassMethod;
	}(AbstractClassPart));
	exports.ClassMethod = ClassMethod;
	var ClassGetter = (function (_super) {
	    __extends(ClassGetter, _super);
	    function ClassGetter(name, body, type, modifiers) {
	        if (type === void 0) { type = null; }
	        if (modifiers === void 0) { modifiers = null; }
	        _super.call(this, type, modifiers);
	        this.name = name;
	        this.body = body;
	    }
	    return ClassGetter;
	}(AbstractClassPart));
	exports.ClassGetter = ClassGetter;
	var ClassStmt = (function (_super) {
	    __extends(ClassStmt, _super);
	    function ClassStmt(name, parent, fields, getters, constructorMethod, methods, modifiers) {
	        if (modifiers === void 0) { modifiers = null; }
	        _super.call(this, modifiers);
	        this.name = name;
	        this.parent = parent;
	        this.fields = fields;
	        this.getters = getters;
	        this.constructorMethod = constructorMethod;
	        this.methods = methods;
	    }
	    ClassStmt.prototype.visitStatement = function (visitor, context) {
	        return visitor.visitDeclareClassStmt(this, context);
	    };
	    return ClassStmt;
	}(Statement));
	exports.ClassStmt = ClassStmt;
	var IfStmt = (function (_super) {
	    __extends(IfStmt, _super);
	    function IfStmt(condition, trueCase, falseCase) {
	        if (falseCase === void 0) { falseCase = []; }
	        _super.call(this);
	        this.condition = condition;
	        this.trueCase = trueCase;
	        this.falseCase = falseCase;
	    }
	    IfStmt.prototype.visitStatement = function (visitor, context) {
	        return visitor.visitIfStmt(this, context);
	    };
	    return IfStmt;
	}(Statement));
	exports.IfStmt = IfStmt;
	var CommentStmt = (function (_super) {
	    __extends(CommentStmt, _super);
	    function CommentStmt(comment) {
	        _super.call(this);
	        this.comment = comment;
	    }
	    CommentStmt.prototype.visitStatement = function (visitor, context) {
	        return visitor.visitCommentStmt(this, context);
	    };
	    return CommentStmt;
	}(Statement));
	exports.CommentStmt = CommentStmt;
	var TryCatchStmt = (function (_super) {
	    __extends(TryCatchStmt, _super);
	    function TryCatchStmt(bodyStmts, catchStmts) {
	        _super.call(this);
	        this.bodyStmts = bodyStmts;
	        this.catchStmts = catchStmts;
	    }
	    TryCatchStmt.prototype.visitStatement = function (visitor, context) {
	        return visitor.visitTryCatchStmt(this, context);
	    };
	    return TryCatchStmt;
	}(Statement));
	exports.TryCatchStmt = TryCatchStmt;
	var ThrowStmt = (function (_super) {
	    __extends(ThrowStmt, _super);
	    function ThrowStmt(error) {
	        _super.call(this);
	        this.error = error;
	    }
	    ThrowStmt.prototype.visitStatement = function (visitor, context) {
	        return visitor.visitThrowStmt(this, context);
	    };
	    return ThrowStmt;
	}(Statement));
	exports.ThrowStmt = ThrowStmt;
	var ExpressionTransformer = (function () {
	    function ExpressionTransformer() {
	    }
	    ExpressionTransformer.prototype.visitReadVarExpr = function (ast, context) { return ast; };
	    ExpressionTransformer.prototype.visitWriteVarExpr = function (expr, context) {
	        return new WriteVarExpr(expr.name, expr.value.visitExpression(this, context));
	    };
	    ExpressionTransformer.prototype.visitWriteKeyExpr = function (expr, context) {
	        return new WriteKeyExpr(expr.receiver.visitExpression(this, context), expr.index.visitExpression(this, context), expr.value.visitExpression(this, context));
	    };
	    ExpressionTransformer.prototype.visitWritePropExpr = function (expr, context) {
	        return new WritePropExpr(expr.receiver.visitExpression(this, context), expr.name, expr.value.visitExpression(this, context));
	    };
	    ExpressionTransformer.prototype.visitInvokeMethodExpr = function (ast, context) {
	        var method = lang_1.isPresent(ast.builtin) ? ast.builtin : ast.name;
	        return new InvokeMethodExpr(ast.receiver.visitExpression(this, context), method, this.visitAllExpressions(ast.args, context), ast.type);
	    };
	    ExpressionTransformer.prototype.visitInvokeFunctionExpr = function (ast, context) {
	        return new InvokeFunctionExpr(ast.fn.visitExpression(this, context), this.visitAllExpressions(ast.args, context), ast.type);
	    };
	    ExpressionTransformer.prototype.visitInstantiateExpr = function (ast, context) {
	        return new InstantiateExpr(ast.classExpr.visitExpression(this, context), this.visitAllExpressions(ast.args, context), ast.type);
	    };
	    ExpressionTransformer.prototype.visitLiteralExpr = function (ast, context) { return ast; };
	    ExpressionTransformer.prototype.visitExternalExpr = function (ast, context) { return ast; };
	    ExpressionTransformer.prototype.visitConditionalExpr = function (ast, context) {
	        return new ConditionalExpr(ast.condition.visitExpression(this, context), ast.trueCase.visitExpression(this, context), ast.falseCase.visitExpression(this, context));
	    };
	    ExpressionTransformer.prototype.visitNotExpr = function (ast, context) {
	        return new NotExpr(ast.condition.visitExpression(this, context));
	    };
	    ExpressionTransformer.prototype.visitCastExpr = function (ast, context) {
	        return new CastExpr(ast.value.visitExpression(this, context), context);
	    };
	    ExpressionTransformer.prototype.visitFunctionExpr = function (ast, context) {
	        // Don't descend into nested functions
	        return ast;
	    };
	    ExpressionTransformer.prototype.visitBinaryOperatorExpr = function (ast, context) {
	        return new BinaryOperatorExpr(ast.operator, ast.lhs.visitExpression(this, context), ast.rhs.visitExpression(this, context), ast.type);
	    };
	    ExpressionTransformer.prototype.visitReadPropExpr = function (ast, context) {
	        return new ReadPropExpr(ast.receiver.visitExpression(this, context), ast.name, ast.type);
	    };
	    ExpressionTransformer.prototype.visitReadKeyExpr = function (ast, context) {
	        return new ReadKeyExpr(ast.receiver.visitExpression(this, context), ast.index.visitExpression(this, context), ast.type);
	    };
	    ExpressionTransformer.prototype.visitLiteralArrayExpr = function (ast, context) {
	        return new LiteralArrayExpr(this.visitAllExpressions(ast.entries, context));
	    };
	    ExpressionTransformer.prototype.visitLiteralMapExpr = function (ast, context) {
	        var _this = this;
	        return new LiteralMapExpr(ast.entries.map(function (entry) { return [entry[0], entry[1].visitExpression(_this, context)]; }));
	    };
	    ExpressionTransformer.prototype.visitAllExpressions = function (exprs, context) {
	        var _this = this;
	        return exprs.map(function (expr) { return expr.visitExpression(_this, context); });
	    };
	    ExpressionTransformer.prototype.visitDeclareVarStmt = function (stmt, context) {
	        return new DeclareVarStmt(stmt.name, stmt.value.visitExpression(this, context), stmt.type, stmt.modifiers);
	    };
	    ExpressionTransformer.prototype.visitDeclareFunctionStmt = function (stmt, context) {
	        // Don't descend into nested functions
	        return stmt;
	    };
	    ExpressionTransformer.prototype.visitExpressionStmt = function (stmt, context) {
	        return new ExpressionStatement(stmt.expr.visitExpression(this, context));
	    };
	    ExpressionTransformer.prototype.visitReturnStmt = function (stmt, context) {
	        return new ReturnStatement(stmt.value.visitExpression(this, context));
	    };
	    ExpressionTransformer.prototype.visitDeclareClassStmt = function (stmt, context) {
	        // Don't descend into nested functions
	        return stmt;
	    };
	    ExpressionTransformer.prototype.visitIfStmt = function (stmt, context) {
	        return new IfStmt(stmt.condition.visitExpression(this, context), this.visitAllStatements(stmt.trueCase, context), this.visitAllStatements(stmt.falseCase, context));
	    };
	    ExpressionTransformer.prototype.visitTryCatchStmt = function (stmt, context) {
	        return new TryCatchStmt(this.visitAllStatements(stmt.bodyStmts, context), this.visitAllStatements(stmt.catchStmts, context));
	    };
	    ExpressionTransformer.prototype.visitThrowStmt = function (stmt, context) {
	        return new ThrowStmt(stmt.error.visitExpression(this, context));
	    };
	    ExpressionTransformer.prototype.visitCommentStmt = function (stmt, context) { return stmt; };
	    ExpressionTransformer.prototype.visitAllStatements = function (stmts, context) {
	        var _this = this;
	        return stmts.map(function (stmt) { return stmt.visitStatement(_this, context); });
	    };
	    return ExpressionTransformer;
	}());
	exports.ExpressionTransformer = ExpressionTransformer;
	var RecursiveExpressionVisitor = (function () {
	    function RecursiveExpressionVisitor() {
	    }
	    RecursiveExpressionVisitor.prototype.visitReadVarExpr = function (ast, context) { return ast; };
	    RecursiveExpressionVisitor.prototype.visitWriteVarExpr = function (expr, context) {
	        expr.value.visitExpression(this, context);
	        return expr;
	    };
	    RecursiveExpressionVisitor.prototype.visitWriteKeyExpr = function (expr, context) {
	        expr.receiver.visitExpression(this, context);
	        expr.index.visitExpression(this, context);
	        expr.value.visitExpression(this, context);
	        return expr;
	    };
	    RecursiveExpressionVisitor.prototype.visitWritePropExpr = function (expr, context) {
	        expr.receiver.visitExpression(this, context);
	        expr.value.visitExpression(this, context);
	        return expr;
	    };
	    RecursiveExpressionVisitor.prototype.visitInvokeMethodExpr = function (ast, context) {
	        ast.receiver.visitExpression(this, context);
	        this.visitAllExpressions(ast.args, context);
	        return ast;
	    };
	    RecursiveExpressionVisitor.prototype.visitInvokeFunctionExpr = function (ast, context) {
	        ast.fn.visitExpression(this, context);
	        this.visitAllExpressions(ast.args, context);
	        return ast;
	    };
	    RecursiveExpressionVisitor.prototype.visitInstantiateExpr = function (ast, context) {
	        ast.classExpr.visitExpression(this, context);
	        this.visitAllExpressions(ast.args, context);
	        return ast;
	    };
	    RecursiveExpressionVisitor.prototype.visitLiteralExpr = function (ast, context) { return ast; };
	    RecursiveExpressionVisitor.prototype.visitExternalExpr = function (ast, context) { return ast; };
	    RecursiveExpressionVisitor.prototype.visitConditionalExpr = function (ast, context) {
	        ast.condition.visitExpression(this, context);
	        ast.trueCase.visitExpression(this, context);
	        ast.falseCase.visitExpression(this, context);
	        return ast;
	    };
	    RecursiveExpressionVisitor.prototype.visitNotExpr = function (ast, context) {
	        ast.condition.visitExpression(this, context);
	        return ast;
	    };
	    RecursiveExpressionVisitor.prototype.visitCastExpr = function (ast, context) {
	        ast.value.visitExpression(this, context);
	        return ast;
	    };
	    RecursiveExpressionVisitor.prototype.visitFunctionExpr = function (ast, context) { return ast; };
	    RecursiveExpressionVisitor.prototype.visitBinaryOperatorExpr = function (ast, context) {
	        ast.lhs.visitExpression(this, context);
	        ast.rhs.visitExpression(this, context);
	        return ast;
	    };
	    RecursiveExpressionVisitor.prototype.visitReadPropExpr = function (ast, context) {
	        ast.receiver.visitExpression(this, context);
	        return ast;
	    };
	    RecursiveExpressionVisitor.prototype.visitReadKeyExpr = function (ast, context) {
	        ast.receiver.visitExpression(this, context);
	        ast.index.visitExpression(this, context);
	        return ast;
	    };
	    RecursiveExpressionVisitor.prototype.visitLiteralArrayExpr = function (ast, context) {
	        this.visitAllExpressions(ast.entries, context);
	        return ast;
	    };
	    RecursiveExpressionVisitor.prototype.visitLiteralMapExpr = function (ast, context) {
	        var _this = this;
	        ast.entries.forEach(function (entry) { return entry[1].visitExpression(_this, context); });
	        return ast;
	    };
	    RecursiveExpressionVisitor.prototype.visitAllExpressions = function (exprs, context) {
	        var _this = this;
	        exprs.forEach(function (expr) { return expr.visitExpression(_this, context); });
	    };
	    RecursiveExpressionVisitor.prototype.visitDeclareVarStmt = function (stmt, context) {
	        stmt.value.visitExpression(this, context);
	        return stmt;
	    };
	    RecursiveExpressionVisitor.prototype.visitDeclareFunctionStmt = function (stmt, context) {
	        // Don't descend into nested functions
	        return stmt;
	    };
	    RecursiveExpressionVisitor.prototype.visitExpressionStmt = function (stmt, context) {
	        stmt.expr.visitExpression(this, context);
	        return stmt;
	    };
	    RecursiveExpressionVisitor.prototype.visitReturnStmt = function (stmt, context) {
	        stmt.value.visitExpression(this, context);
	        return stmt;
	    };
	    RecursiveExpressionVisitor.prototype.visitDeclareClassStmt = function (stmt, context) {
	        // Don't descend into nested functions
	        return stmt;
	    };
	    RecursiveExpressionVisitor.prototype.visitIfStmt = function (stmt, context) {
	        stmt.condition.visitExpression(this, context);
	        this.visitAllStatements(stmt.trueCase, context);
	        this.visitAllStatements(stmt.falseCase, context);
	        return stmt;
	    };
	    RecursiveExpressionVisitor.prototype.visitTryCatchStmt = function (stmt, context) {
	        this.visitAllStatements(stmt.bodyStmts, context);
	        this.visitAllStatements(stmt.catchStmts, context);
	        return stmt;
	    };
	    RecursiveExpressionVisitor.prototype.visitThrowStmt = function (stmt, context) {
	        stmt.error.visitExpression(this, context);
	        return stmt;
	    };
	    RecursiveExpressionVisitor.prototype.visitCommentStmt = function (stmt, context) { return stmt; };
	    RecursiveExpressionVisitor.prototype.visitAllStatements = function (stmts, context) {
	        var _this = this;
	        stmts.forEach(function (stmt) { return stmt.visitStatement(_this, context); });
	    };
	    return RecursiveExpressionVisitor;
	}());
	exports.RecursiveExpressionVisitor = RecursiveExpressionVisitor;
	function replaceVarInExpression(varName, newValue, expression) {
	    var transformer = new _ReplaceVariableTransformer(varName, newValue);
	    return expression.visitExpression(transformer, null);
	}
	exports.replaceVarInExpression = replaceVarInExpression;
	var _ReplaceVariableTransformer = (function (_super) {
	    __extends(_ReplaceVariableTransformer, _super);
	    function _ReplaceVariableTransformer(_varName, _newValue) {
	        _super.call(this);
	        this._varName = _varName;
	        this._newValue = _newValue;
	    }
	    _ReplaceVariableTransformer.prototype.visitReadVarExpr = function (ast, context) {
	        return ast.name == this._varName ? this._newValue : ast;
	    };
	    return _ReplaceVariableTransformer;
	}(ExpressionTransformer));
	function findReadVarNames(stmts) {
	    var finder = new _VariableFinder();
	    finder.visitAllStatements(stmts, null);
	    return finder.varNames;
	}
	exports.findReadVarNames = findReadVarNames;
	var _VariableFinder = (function (_super) {
	    __extends(_VariableFinder, _super);
	    function _VariableFinder() {
	        _super.apply(this, arguments);
	        this.varNames = new Set();
	    }
	    _VariableFinder.prototype.visitReadVarExpr = function (ast, context) {
	        this.varNames.add(ast.name);
	        return null;
	    };
	    return _VariableFinder;
	}(RecursiveExpressionVisitor));
	function variable(name, type) {
	    if (type === void 0) { type = null; }
	    return new ReadVarExpr(name, type);
	}
	exports.variable = variable;
	function importExpr(id, typeParams) {
	    if (typeParams === void 0) { typeParams = null; }
	    return new ExternalExpr(id, null, typeParams);
	}
	exports.importExpr = importExpr;
	function importType(id, typeParams, typeModifiers) {
	    if (typeParams === void 0) { typeParams = null; }
	    if (typeModifiers === void 0) { typeModifiers = null; }
	    return lang_1.isPresent(id) ? new ExternalType(id, typeParams, typeModifiers) : null;
	}
	exports.importType = importType;
	function literal(value, type) {
	    if (type === void 0) { type = null; }
	    return new LiteralExpr(value, type);
	}
	exports.literal = literal;
	function literalArr(values, type) {
	    if (type === void 0) { type = null; }
	    return new LiteralArrayExpr(values, type);
	}
	exports.literalArr = literalArr;
	function literalMap(values, type) {
	    if (type === void 0) { type = null; }
	    return new LiteralMapExpr(values, type);
	}
	exports.literalMap = literalMap;
	function not(expr) {
	    return new NotExpr(expr);
	}
	exports.not = not;
	function fn(params, body, type) {
	    if (type === void 0) { type = null; }
	    return new FunctionExpr(params, body, type);
	}
	exports.fn = fn;


/***/ },
/* 167 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var collection_1 = __webpack_require__(15);
	var async_1 = __webpack_require__(41);
	var compile_metadata_1 = __webpack_require__(157);
	var di_1 = __webpack_require__(6);
	var style_compiler_1 = __webpack_require__(168);
	var view_compiler_1 = __webpack_require__(170);
	var template_parser_1 = __webpack_require__(142);
	var directive_normalizer_1 = __webpack_require__(185);
	var metadata_resolver_1 = __webpack_require__(187);
	var component_factory_1 = __webpack_require__(67);
	var config_1 = __webpack_require__(164);
	var ir = __webpack_require__(166);
	var output_jit_1 = __webpack_require__(193);
	var output_interpreter_1 = __webpack_require__(196);
	var interpretive_view_1 = __webpack_require__(200);
	var xhr_1 = __webpack_require__(186);
	/**
	 * An internal module of the Angular compiler that begins with component types,
	 * extracts templates, and eventually produces a compiled version of the component
	 * ready for linking into an application.
	 */
	var RuntimeCompiler = (function () {
	    function RuntimeCompiler(_metadataResolver, _templateNormalizer, _templateParser, _styleCompiler, _viewCompiler, _xhr, _genConfig) {
	        this._metadataResolver = _metadataResolver;
	        this._templateNormalizer = _templateNormalizer;
	        this._templateParser = _templateParser;
	        this._styleCompiler = _styleCompiler;
	        this._viewCompiler = _viewCompiler;
	        this._xhr = _xhr;
	        this._genConfig = _genConfig;
	        this._styleCache = new Map();
	        this._hostCacheKeys = new Map();
	        this._compiledTemplateCache = new Map();
	        this._compiledTemplateDone = new Map();
	    }
	    RuntimeCompiler.prototype.resolveComponent = function (componentType) {
	        var compMeta = this._metadataResolver.getDirectiveMetadata(componentType);
	        var hostCacheKey = this._hostCacheKeys.get(componentType);
	        if (lang_1.isBlank(hostCacheKey)) {
	            hostCacheKey = new Object();
	            this._hostCacheKeys.set(componentType, hostCacheKey);
	            assertComponent(compMeta);
	            var hostMeta = compile_metadata_1.createHostComponentMeta(compMeta.type, compMeta.selector);
	            this._loadAndCompileComponent(hostCacheKey, hostMeta, [compMeta], [], []);
	        }
	        return this._compiledTemplateDone.get(hostCacheKey)
	            .then(function (compiledTemplate) { return new component_factory_1.ComponentFactory(compMeta.selector, compiledTemplate.viewFactory, componentType); });
	    };
	    RuntimeCompiler.prototype.clearCache = function () {
	        this._styleCache.clear();
	        this._compiledTemplateCache.clear();
	        this._compiledTemplateDone.clear();
	        this._hostCacheKeys.clear();
	    };
	    RuntimeCompiler.prototype._loadAndCompileComponent = function (cacheKey, compMeta, viewDirectives, pipes, compilingComponentsPath) {
	        var _this = this;
	        var compiledTemplate = this._compiledTemplateCache.get(cacheKey);
	        var done = this._compiledTemplateDone.get(cacheKey);
	        if (lang_1.isBlank(compiledTemplate)) {
	            compiledTemplate = new CompiledTemplate();
	            this._compiledTemplateCache.set(cacheKey, compiledTemplate);
	            done =
	                async_1.PromiseWrapper.all([this._compileComponentStyles(compMeta)].concat(viewDirectives.map(function (dirMeta) { return _this._templateNormalizer.normalizeDirective(dirMeta); })))
	                    .then(function (stylesAndNormalizedViewDirMetas) {
	                    var normalizedViewDirMetas = stylesAndNormalizedViewDirMetas.slice(1);
	                    var styles = stylesAndNormalizedViewDirMetas[0];
	                    var parsedTemplate = _this._templateParser.parse(compMeta, compMeta.template.template, normalizedViewDirMetas, pipes, compMeta.type.name);
	                    var childPromises = [];
	                    compiledTemplate.init(_this._compileComponent(compMeta, parsedTemplate, styles, pipes, compilingComponentsPath, childPromises));
	                    return async_1.PromiseWrapper.all(childPromises).then(function (_) { return compiledTemplate; });
	                });
	            this._compiledTemplateDone.set(cacheKey, done);
	        }
	        return compiledTemplate;
	    };
	    RuntimeCompiler.prototype._compileComponent = function (compMeta, parsedTemplate, styles, pipes, compilingComponentsPath, childPromises) {
	        var _this = this;
	        var compileResult = this._viewCompiler.compileComponent(compMeta, parsedTemplate, new ir.ExternalExpr(new compile_metadata_1.CompileIdentifierMetadata({ runtime: styles })), pipes);
	        compileResult.dependencies.forEach(function (dep) {
	            var childCompilingComponentsPath = collection_1.ListWrapper.clone(compilingComponentsPath);
	            var childCacheKey = dep.comp.type.runtime;
	            var childViewDirectives = _this._metadataResolver.getViewDirectivesMetadata(dep.comp.type.runtime);
	            var childViewPipes = _this._metadataResolver.getViewPipesMetadata(dep.comp.type.runtime);
	            var childIsRecursive = collection_1.ListWrapper.contains(childCompilingComponentsPath, childCacheKey);
	            childCompilingComponentsPath.push(childCacheKey);
	            var childComp = _this._loadAndCompileComponent(dep.comp.type.runtime, dep.comp, childViewDirectives, childViewPipes, childCompilingComponentsPath);
	            dep.factoryPlaceholder.runtime = childComp.proxyViewFactory;
	            dep.factoryPlaceholder.name = "viewFactory_" + dep.comp.type.name;
	            if (!childIsRecursive) {
	                // Only wait for a child if it is not a cycle
	                childPromises.push(_this._compiledTemplateDone.get(childCacheKey));
	            }
	        });
	        var factory;
	        if (lang_1.IS_DART || !this._genConfig.useJit) {
	            factory = output_interpreter_1.interpretStatements(compileResult.statements, compileResult.viewFactoryVar, new interpretive_view_1.InterpretiveAppViewInstanceFactory());
	        }
	        else {
	            factory = output_jit_1.jitStatements(compMeta.type.name + ".template.js", compileResult.statements, compileResult.viewFactoryVar);
	        }
	        return factory;
	    };
	    RuntimeCompiler.prototype._compileComponentStyles = function (compMeta) {
	        var compileResult = this._styleCompiler.compileComponent(compMeta);
	        return this._resolveStylesCompileResult(compMeta.type.name, compileResult);
	    };
	    RuntimeCompiler.prototype._resolveStylesCompileResult = function (sourceUrl, result) {
	        var _this = this;
	        var promises = result.dependencies.map(function (dep) { return _this._loadStylesheetDep(dep); });
	        return async_1.PromiseWrapper.all(promises)
	            .then(function (cssTexts) {
	            var nestedCompileResultPromises = [];
	            for (var i = 0; i < result.dependencies.length; i++) {
	                var dep = result.dependencies[i];
	                var cssText = cssTexts[i];
	                var nestedCompileResult = _this._styleCompiler.compileStylesheet(dep.sourceUrl, cssText, dep.isShimmed);
	                nestedCompileResultPromises.push(_this._resolveStylesCompileResult(dep.sourceUrl, nestedCompileResult));
	            }
	            return async_1.PromiseWrapper.all(nestedCompileResultPromises);
	        })
	            .then(function (nestedStylesArr) {
	            for (var i = 0; i < result.dependencies.length; i++) {
	                var dep = result.dependencies[i];
	                dep.valuePlaceholder.runtime = nestedStylesArr[i];
	                dep.valuePlaceholder.name = "importedStyles" + i;
	            }
	            if (lang_1.IS_DART || !_this._genConfig.useJit) {
	                return output_interpreter_1.interpretStatements(result.statements, result.stylesVar, new interpretive_view_1.InterpretiveAppViewInstanceFactory());
	            }
	            else {
	                return output_jit_1.jitStatements(sourceUrl + ".css.js", result.statements, result.stylesVar);
	            }
	        });
	    };
	    RuntimeCompiler.prototype._loadStylesheetDep = function (dep) {
	        var cacheKey = "" + dep.sourceUrl + (dep.isShimmed ? '.shim' : '');
	        var cssTextPromise = this._styleCache.get(cacheKey);
	        if (lang_1.isBlank(cssTextPromise)) {
	            cssTextPromise = this._xhr.get(dep.sourceUrl);
	            this._styleCache.set(cacheKey, cssTextPromise);
	        }
	        return cssTextPromise;
	    };
	    RuntimeCompiler = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [metadata_resolver_1.CompileMetadataResolver, directive_normalizer_1.DirectiveNormalizer, template_parser_1.TemplateParser, style_compiler_1.StyleCompiler, view_compiler_1.ViewCompiler, xhr_1.XHR, config_1.CompilerConfig])
	    ], RuntimeCompiler);
	    return RuntimeCompiler;
	}());
	exports.RuntimeCompiler = RuntimeCompiler;
	var CompiledTemplate = (function () {
	    function CompiledTemplate() {
	        var _this = this;
	        this.viewFactory = null;
	        this.proxyViewFactory = function (viewUtils, childInjector, contextEl) {
	            return _this.viewFactory(viewUtils, childInjector, contextEl);
	        };
	    }
	    CompiledTemplate.prototype.init = function (viewFactory) { this.viewFactory = viewFactory; };
	    return CompiledTemplate;
	}());
	function assertComponent(meta) {
	    if (!meta.isComponent) {
	        throw new exceptions_1.BaseException("Could not compile '" + meta.type.name + "' because it is not a component.");
	    }
	}


/***/ },
/* 168 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var compile_metadata_1 = __webpack_require__(157);
	var o = __webpack_require__(166);
	var view_1 = __webpack_require__(37);
	var shadow_css_1 = __webpack_require__(169);
	var url_resolver_1 = __webpack_require__(159);
	var style_url_resolver_1 = __webpack_require__(154);
	var di_1 = __webpack_require__(6);
	var lang_1 = __webpack_require__(5);
	var COMPONENT_VARIABLE = '%COMP%';
	var HOST_ATTR = "_nghost-" + COMPONENT_VARIABLE;
	var CONTENT_ATTR = "_ngcontent-" + COMPONENT_VARIABLE;
	var StylesCompileDependency = (function () {
	    function StylesCompileDependency(sourceUrl, isShimmed, valuePlaceholder) {
	        this.sourceUrl = sourceUrl;
	        this.isShimmed = isShimmed;
	        this.valuePlaceholder = valuePlaceholder;
	    }
	    return StylesCompileDependency;
	}());
	exports.StylesCompileDependency = StylesCompileDependency;
	var StylesCompileResult = (function () {
	    function StylesCompileResult(statements, stylesVar, dependencies) {
	        this.statements = statements;
	        this.stylesVar = stylesVar;
	        this.dependencies = dependencies;
	    }
	    return StylesCompileResult;
	}());
	exports.StylesCompileResult = StylesCompileResult;
	var StyleCompiler = (function () {
	    function StyleCompiler(_urlResolver) {
	        this._urlResolver = _urlResolver;
	        this._shadowCss = new shadow_css_1.ShadowCss();
	    }
	    StyleCompiler.prototype.compileComponent = function (comp) {
	        var shim = comp.template.encapsulation === view_1.ViewEncapsulation.Emulated;
	        return this._compileStyles(getStylesVarName(comp), comp.template.styles, comp.template.styleUrls, shim);
	    };
	    StyleCompiler.prototype.compileStylesheet = function (stylesheetUrl, cssText, isShimmed) {
	        var styleWithImports = style_url_resolver_1.extractStyleUrls(this._urlResolver, stylesheetUrl, cssText);
	        return this._compileStyles(getStylesVarName(null), [styleWithImports.style], styleWithImports.styleUrls, isShimmed);
	    };
	    StyleCompiler.prototype._compileStyles = function (stylesVar, plainStyles, absUrls, shim) {
	        var _this = this;
	        var styleExpressions = plainStyles.map(function (plainStyle) { return o.literal(_this._shimIfNeeded(plainStyle, shim)); });
	        var dependencies = [];
	        for (var i = 0; i < absUrls.length; i++) {
	            var identifier = new compile_metadata_1.CompileIdentifierMetadata({ name: getStylesVarName(null) });
	            dependencies.push(new StylesCompileDependency(absUrls[i], shim, identifier));
	            styleExpressions.push(new o.ExternalExpr(identifier));
	        }
	        // styles variable contains plain strings and arrays of other styles arrays (recursive),
	        // so we set its type to dynamic.
	        var stmt = o.variable(stylesVar)
	            .set(o.literalArr(styleExpressions, new o.ArrayType(o.DYNAMIC_TYPE, [o.TypeModifier.Const])))
	            .toDeclStmt(null, [o.StmtModifier.Final]);
	        return new StylesCompileResult([stmt], stylesVar, dependencies);
	    };
	    StyleCompiler.prototype._shimIfNeeded = function (style, shim) {
	        return shim ? this._shadowCss.shimCssText(style, CONTENT_ATTR, HOST_ATTR) : style;
	    };
	    StyleCompiler = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [url_resolver_1.UrlResolver])
	    ], StyleCompiler);
	    return StyleCompiler;
	}());
	exports.StyleCompiler = StyleCompiler;
	function getStylesVarName(component) {
	    var result = "styles";
	    if (lang_1.isPresent(component)) {
	        result += "_" + component.type.name;
	    }
	    return result;
	}


/***/ },
/* 169 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	/**
	 * This file is a port of shadowCSS from webcomponents.js to TypeScript.
	 *
	 * Please make sure to keep to edits in sync with the source file.
	 *
	 * Source:
	 * https://github.com/webcomponents/webcomponentsjs/blob/4efecd7e0e/src/ShadowCSS/ShadowCSS.js
	 *
	 * The original file level comment is reproduced below
	 */
	/*
	  This is a limited shim for ShadowDOM css styling.
	  https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#styles

	  The intention here is to support only the styling features which can be
	  relatively simply implemented. The goal is to allow users to avoid the
	  most obvious pitfalls and do so without compromising performance significantly.
	  For ShadowDOM styling that's not covered here, a set of best practices
	  can be provided that should allow users to accomplish more complex styling.

	  The following is a list of specific ShadowDOM styling features and a brief
	  discussion of the approach used to shim.

	  Shimmed features:

	  * :host, :host-context: ShadowDOM allows styling of the shadowRoot's host
	  element using the :host rule. To shim this feature, the :host styles are
	  reformatted and prefixed with a given scope name and promoted to a
	  document level stylesheet.
	  For example, given a scope name of .foo, a rule like this:

	    :host {
	        background: red;
	      }
	    }

	  becomes:

	    .foo {
	      background: red;
	    }

	  * encapsultion: Styles defined within ShadowDOM, apply only to
	  dom inside the ShadowDOM. Polymer uses one of two techniques to implement
	  this feature.

	  By default, rules are prefixed with the host element tag name
	  as a descendant selector. This ensures styling does not leak out of the 'top'
	  of the element's ShadowDOM. For example,

	  div {
	      font-weight: bold;
	    }

	  becomes:

	  x-foo div {
	      font-weight: bold;
	    }

	  becomes:


	  Alternatively, if WebComponents.ShadowCSS.strictStyling is set to true then
	  selectors are scoped by adding an attribute selector suffix to each
	  simple selector that contains the host element tag name. Each element
	  in the element's ShadowDOM template is also given the scope attribute.
	  Thus, these rules match only elements that have the scope attribute.
	  For example, given a scope name of x-foo, a rule like this:

	    div {
	      font-weight: bold;
	    }

	  becomes:

	    div[x-foo] {
	      font-weight: bold;
	    }

	  Note that elements that are dynamically added to a scope must have the scope
	  selector added to them manually.

	  * upper/lower bound encapsulation: Styles which are defined outside a
	  shadowRoot should not cross the ShadowDOM boundary and should not apply
	  inside a shadowRoot.

	  This styling behavior is not emulated. Some possible ways to do this that
	  were rejected due to complexity and/or performance concerns include: (1) reset
	  every possible property for every possible selector for a given scope name;
	  (2) re-implement css in javascript.

	  As an alternative, users should make sure to use selectors
	  specific to the scope in which they are working.

	  * ::distributed: This behavior is not emulated. It's often not necessary
	  to style the contents of a specific insertion point and instead, descendants
	  of the host element can be styled selectively. Users can also create an
	  extra node around an insertion point and style that node's contents
	  via descendent selectors. For example, with a shadowRoot like this:

	    <style>
	      ::content(div) {
	        background: red;
	      }
	    </style>
	    <content></content>

	  could become:

	    <style>
	      / *@polyfill .content-container div * /
	      ::content(div) {
	        background: red;
	      }
	    </style>
	    <div class="content-container">
	      <content></content>
	    </div>

	  Note the use of @polyfill in the comment above a ShadowDOM specific style
	  declaration. This is a directive to the styling shim to use the selector
	  in comments in lieu of the next selector when running under polyfill.
	*/
	var ShadowCss = (function () {
	    function ShadowCss() {
	        this.strictStyling = true;
	    }
	    /*
	    * Shim some cssText with the given selector. Returns cssText that can
	    * be included in the document via WebComponents.ShadowCSS.addCssToDocument(css).
	    *
	    * When strictStyling is true:
	    * - selector is the attribute added to all elements inside the host,
	    * - hostSelector is the attribute added to the host itself.
	    */
	    ShadowCss.prototype.shimCssText = function (cssText, selector, hostSelector) {
	        if (hostSelector === void 0) { hostSelector = ''; }
	        cssText = stripComments(cssText);
	        cssText = this._insertDirectives(cssText);
	        return this._scopeCssText(cssText, selector, hostSelector);
	    };
	    ShadowCss.prototype._insertDirectives = function (cssText) {
	        cssText = this._insertPolyfillDirectivesInCssText(cssText);
	        return this._insertPolyfillRulesInCssText(cssText);
	    };
	    /*
	     * Process styles to convert native ShadowDOM rules that will trip
	     * up the css parser; we rely on decorating the stylesheet with inert rules.
	     *
	     * For example, we convert this rule:
	     *
	     * polyfill-next-selector { content: ':host menu-item'; }
	     * ::content menu-item {
	     *
	     * to this:
	     *
	     * scopeName menu-item {
	     *
	    **/
	    ShadowCss.prototype._insertPolyfillDirectivesInCssText = function (cssText) {
	        // Difference with webcomponents.js: does not handle comments
	        return lang_1.StringWrapper.replaceAllMapped(cssText, _cssContentNextSelectorRe, function (m) { return m[1] + '{'; });
	    };
	    /*
	     * Process styles to add rules which will only apply under the polyfill
	     *
	     * For example, we convert this rule:
	     *
	     * polyfill-rule {
	     *   content: ':host menu-item';
	     * ...
	     * }
	     *
	     * to this:
	     *
	     * scopeName menu-item {...}
	     *
	    **/
	    ShadowCss.prototype._insertPolyfillRulesInCssText = function (cssText) {
	        // Difference with webcomponents.js: does not handle comments
	        return lang_1.StringWrapper.replaceAllMapped(cssText, _cssContentRuleRe, function (m) {
	            var rule = m[0];
	            rule = lang_1.StringWrapper.replace(rule, m[1], '');
	            rule = lang_1.StringWrapper.replace(rule, m[2], '');
	            return m[3] + rule;
	        });
	    };
	    /* Ensure styles are scoped. Pseudo-scoping takes a rule like:
	     *
	     *  .foo {... }
	     *
	     *  and converts this to
	     *
	     *  scopeName .foo { ... }
	    */
	    ShadowCss.prototype._scopeCssText = function (cssText, scopeSelector, hostSelector) {
	        var unscoped = this._extractUnscopedRulesFromCssText(cssText);
	        cssText = this._insertPolyfillHostInCssText(cssText);
	        cssText = this._convertColonHost(cssText);
	        cssText = this._convertColonHostContext(cssText);
	        cssText = this._convertShadowDOMSelectors(cssText);
	        if (lang_1.isPresent(scopeSelector)) {
	            cssText = this._scopeSelectors(cssText, scopeSelector, hostSelector);
	        }
	        cssText = cssText + '\n' + unscoped;
	        return cssText.trim();
	    };
	    /*
	     * Process styles to add rules which will only apply under the polyfill
	     * and do not process via CSSOM. (CSSOM is destructive to rules on rare
	     * occasions, e.g. -webkit-calc on Safari.)
	     * For example, we convert this rule:
	     *
	     * @polyfill-unscoped-rule {
	     *   content: 'menu-item';
	     * ... }
	     *
	     * to this:
	     *
	     * menu-item {...}
	     *
	    **/
	    ShadowCss.prototype._extractUnscopedRulesFromCssText = function (cssText) {
	        // Difference with webcomponents.js: does not handle comments
	        var r = '', m;
	        var matcher = lang_1.RegExpWrapper.matcher(_cssContentUnscopedRuleRe, cssText);
	        while (lang_1.isPresent(m = lang_1.RegExpMatcherWrapper.next(matcher))) {
	            var rule = m[0];
	            rule = lang_1.StringWrapper.replace(rule, m[2], '');
	            rule = lang_1.StringWrapper.replace(rule, m[1], m[3]);
	            r += rule + '\n\n';
	        }
	        return r;
	    };
	    /*
	     * convert a rule like :host(.foo) > .bar { }
	     *
	     * to
	     *
	     * scopeName.foo > .bar
	    */
	    ShadowCss.prototype._convertColonHost = function (cssText) {
	        return this._convertColonRule(cssText, _cssColonHostRe, this._colonHostPartReplacer);
	    };
	    /*
	     * convert a rule like :host-context(.foo) > .bar { }
	     *
	     * to
	     *
	     * scopeName.foo > .bar, .foo scopeName > .bar { }
	     *
	     * and
	     *
	     * :host-context(.foo:host) .bar { ... }
	     *
	     * to
	     *
	     * scopeName.foo .bar { ... }
	    */
	    ShadowCss.prototype._convertColonHostContext = function (cssText) {
	        return this._convertColonRule(cssText, _cssColonHostContextRe, this._colonHostContextPartReplacer);
	    };
	    ShadowCss.prototype._convertColonRule = function (cssText, regExp, partReplacer) {
	        // p1 = :host, p2 = contents of (), p3 rest of rule
	        return lang_1.StringWrapper.replaceAllMapped(cssText, regExp, function (m) {
	            if (lang_1.isPresent(m[2])) {
	                var parts = m[2].split(','), r = [];
	                for (var i = 0; i < parts.length; i++) {
	                    var p = parts[i];
	                    if (lang_1.isBlank(p))
	                        break;
	                    p = p.trim();
	                    r.push(partReplacer(_polyfillHostNoCombinator, p, m[3]));
	                }
	                return r.join(',');
	            }
	            else {
	                return _polyfillHostNoCombinator + m[3];
	            }
	        });
	    };
	    ShadowCss.prototype._colonHostContextPartReplacer = function (host, part, suffix) {
	        if (lang_1.StringWrapper.contains(part, _polyfillHost)) {
	            return this._colonHostPartReplacer(host, part, suffix);
	        }
	        else {
	            return host + part + suffix + ', ' + part + ' ' + host + suffix;
	        }
	    };
	    ShadowCss.prototype._colonHostPartReplacer = function (host, part, suffix) {
	        return host + lang_1.StringWrapper.replace(part, _polyfillHost, '') + suffix;
	    };
	    /*
	     * Convert combinators like ::shadow and pseudo-elements like ::content
	     * by replacing with space.
	    */
	    ShadowCss.prototype._convertShadowDOMSelectors = function (cssText) {
	        for (var i = 0; i < _shadowDOMSelectorsRe.length; i++) {
	            cssText = lang_1.StringWrapper.replaceAll(cssText, _shadowDOMSelectorsRe[i], ' ');
	        }
	        return cssText;
	    };
	    // change a selector like 'div' to 'name div'
	    ShadowCss.prototype._scopeSelectors = function (cssText, scopeSelector, hostSelector) {
	        var _this = this;
	        return processRules(cssText, function (rule) {
	            var selector = rule.selector;
	            var content = rule.content;
	            if (rule.selector[0] != '@' || rule.selector.startsWith('@page')) {
	                selector =
	                    _this._scopeSelector(rule.selector, scopeSelector, hostSelector, _this.strictStyling);
	            }
	            else if (rule.selector.startsWith('@media')) {
	                content = _this._scopeSelectors(rule.content, scopeSelector, hostSelector);
	            }
	            return new CssRule(selector, content);
	        });
	    };
	    ShadowCss.prototype._scopeSelector = function (selector, scopeSelector, hostSelector, strict) {
	        var r = [], parts = selector.split(',');
	        for (var i = 0; i < parts.length; i++) {
	            var p = parts[i].trim();
	            var deepParts = lang_1.StringWrapper.split(p, _shadowDeepSelectors);
	            var shallowPart = deepParts[0];
	            if (this._selectorNeedsScoping(shallowPart, scopeSelector)) {
	                deepParts[0] = strict && !lang_1.StringWrapper.contains(shallowPart, _polyfillHostNoCombinator) ?
	                    this._applyStrictSelectorScope(shallowPart, scopeSelector) :
	                    this._applySelectorScope(shallowPart, scopeSelector, hostSelector);
	            }
	            // replace /deep/ with a space for child selectors
	            r.push(deepParts.join(' '));
	        }
	        return r.join(', ');
	    };
	    ShadowCss.prototype._selectorNeedsScoping = function (selector, scopeSelector) {
	        var re = this._makeScopeMatcher(scopeSelector);
	        return !lang_1.isPresent(lang_1.RegExpWrapper.firstMatch(re, selector));
	    };
	    ShadowCss.prototype._makeScopeMatcher = function (scopeSelector) {
	        var lre = /\[/g;
	        var rre = /\]/g;
	        scopeSelector = lang_1.StringWrapper.replaceAll(scopeSelector, lre, '\\[');
	        scopeSelector = lang_1.StringWrapper.replaceAll(scopeSelector, rre, '\\]');
	        return lang_1.RegExpWrapper.create('^(' + scopeSelector + ')' + _selectorReSuffix, 'm');
	    };
	    ShadowCss.prototype._applySelectorScope = function (selector, scopeSelector, hostSelector) {
	        // Difference from webcomponentsjs: scopeSelector could not be an array
	        return this._applySimpleSelectorScope(selector, scopeSelector, hostSelector);
	    };
	    // scope via name and [is=name]
	    ShadowCss.prototype._applySimpleSelectorScope = function (selector, scopeSelector, hostSelector) {
	        if (lang_1.isPresent(lang_1.RegExpWrapper.firstMatch(_polyfillHostRe, selector))) {
	            var replaceBy = this.strictStyling ? "[" + hostSelector + "]" : scopeSelector;
	            selector = lang_1.StringWrapper.replace(selector, _polyfillHostNoCombinator, replaceBy);
	            return lang_1.StringWrapper.replaceAll(selector, _polyfillHostRe, replaceBy + ' ');
	        }
	        else {
	            return scopeSelector + ' ' + selector;
	        }
	    };
	    // return a selector with [name] suffix on each simple selector
	    // e.g. .foo.bar > .zot becomes .foo[name].bar[name] > .zot[name]  /** @internal */
	    ShadowCss.prototype._applyStrictSelectorScope = function (selector, scopeSelector) {
	        var isRe = /\[is=([^\]]*)\]/g;
	        scopeSelector = lang_1.StringWrapper.replaceAllMapped(scopeSelector, isRe, function (m) { return m[1]; });
	        var splits = [' ', '>', '+', '~'], scoped = selector, attrName = '[' + scopeSelector + ']';
	        for (var i = 0; i < splits.length; i++) {
	            var sep = splits[i];
	            var parts = scoped.split(sep);
	            scoped = parts.map(function (p) {
	                // remove :host since it should be unnecessary
	                var t = lang_1.StringWrapper.replaceAll(p.trim(), _polyfillHostRe, '');
	                if (t.length > 0 && !collection_1.ListWrapper.contains(splits, t) &&
	                    !lang_1.StringWrapper.contains(t, attrName)) {
	                    var re = /([^:]*)(:*)(.*)/g;
	                    var m = lang_1.RegExpWrapper.firstMatch(re, t);
	                    if (lang_1.isPresent(m)) {
	                        p = m[1] + attrName + m[2] + m[3];
	                    }
	                }
	                return p;
	            })
	                .join(sep);
	        }
	        return scoped;
	    };
	    ShadowCss.prototype._insertPolyfillHostInCssText = function (selector) {
	        selector = lang_1.StringWrapper.replaceAll(selector, _colonHostContextRe, _polyfillHostContext);
	        selector = lang_1.StringWrapper.replaceAll(selector, _colonHostRe, _polyfillHost);
	        return selector;
	    };
	    return ShadowCss;
	}());
	exports.ShadowCss = ShadowCss;
	var _cssContentNextSelectorRe = /polyfill-next-selector[^}]*content:[\s]*?['"](.*?)['"][;\s]*}([^{]*?){/gim;
	var _cssContentRuleRe = /(polyfill-rule)[^}]*(content:[\s]*['"](.*?)['"])[;\s]*[^}]*}/gim;
	var _cssContentUnscopedRuleRe = /(polyfill-unscoped-rule)[^}]*(content:[\s]*['"](.*?)['"])[;\s]*[^}]*}/gim;
	var _polyfillHost = '-shadowcsshost';
	// note: :host-context pre-processed to -shadowcsshostcontext.
	var _polyfillHostContext = '-shadowcsscontext';
	var _parenSuffix = ')(?:\\((' +
	    '(?:\\([^)(]*\\)|[^)(]*)+?' +
	    ')\\))?([^,{]*)';
	var _cssColonHostRe = lang_1.RegExpWrapper.create('(' + _polyfillHost + _parenSuffix, 'im');
	var _cssColonHostContextRe = lang_1.RegExpWrapper.create('(' + _polyfillHostContext + _parenSuffix, 'im');
	var _polyfillHostNoCombinator = _polyfillHost + '-no-combinator';
	var _shadowDOMSelectorsRe = [
	    /::shadow/g,
	    /::content/g,
	    // Deprecated selectors
	    // TODO(vicb): see https://github.com/angular/clang-format/issues/16
	    // clang-format off
	    /\/shadow-deep\//g,
	    /\/shadow\//g,
	];
	var _shadowDeepSelectors = /(?:>>>)|(?:\/deep\/)/g;
	var _selectorReSuffix = '([>\\s~+\[.,{:][\\s\\S]*)?$';
	var _polyfillHostRe = lang_1.RegExpWrapper.create(_polyfillHost, 'im');
	var _colonHostRe = /:host/gim;
	var _colonHostContextRe = /:host-context/gim;
	var _commentRe = /\/\*[\s\S]*?\*\//g;
	function stripComments(input) {
	    return lang_1.StringWrapper.replaceAllMapped(input, _commentRe, function (_) { return ''; });
	}
	var _ruleRe = /(\s*)([^;\{\}]+?)(\s*)((?:{%BLOCK%}?\s*;?)|(?:\s*;))/g;
	var _curlyRe = /([{}])/g;
	var OPEN_CURLY = '{';
	var CLOSE_CURLY = '}';
	var BLOCK_PLACEHOLDER = '%BLOCK%';
	var CssRule = (function () {
	    function CssRule(selector, content) {
	        this.selector = selector;
	        this.content = content;
	    }
	    return CssRule;
	}());
	exports.CssRule = CssRule;
	function processRules(input, ruleCallback) {
	    var inputWithEscapedBlocks = escapeBlocks(input);
	    var nextBlockIndex = 0;
	    return lang_1.StringWrapper.replaceAllMapped(inputWithEscapedBlocks.escapedString, _ruleRe, function (m) {
	        var selector = m[2];
	        var content = '';
	        var suffix = m[4];
	        var contentPrefix = '';
	        if (lang_1.isPresent(m[4]) && m[4].startsWith('{' + BLOCK_PLACEHOLDER)) {
	            content = inputWithEscapedBlocks.blocks[nextBlockIndex++];
	            suffix = m[4].substring(BLOCK_PLACEHOLDER.length + 1);
	            contentPrefix = '{';
	        }
	        var rule = ruleCallback(new CssRule(selector, content));
	        return "" + m[1] + rule.selector + m[3] + contentPrefix + rule.content + suffix;
	    });
	}
	exports.processRules = processRules;
	var StringWithEscapedBlocks = (function () {
	    function StringWithEscapedBlocks(escapedString, blocks) {
	        this.escapedString = escapedString;
	        this.blocks = blocks;
	    }
	    return StringWithEscapedBlocks;
	}());
	function escapeBlocks(input) {
	    var inputParts = lang_1.StringWrapper.split(input, _curlyRe);
	    var resultParts = [];
	    var escapedBlocks = [];
	    var bracketCount = 0;
	    var currentBlockParts = [];
	    for (var partIndex = 0; partIndex < inputParts.length; partIndex++) {
	        var part = inputParts[partIndex];
	        if (part == CLOSE_CURLY) {
	            bracketCount--;
	        }
	        if (bracketCount > 0) {
	            currentBlockParts.push(part);
	        }
	        else {
	            if (currentBlockParts.length > 0) {
	                escapedBlocks.push(currentBlockParts.join(''));
	                resultParts.push(BLOCK_PLACEHOLDER);
	                currentBlockParts = [];
	            }
	            resultParts.push(part);
	        }
	        if (part == OPEN_CURLY) {
	            bracketCount++;
	        }
	    }
	    if (currentBlockParts.length > 0) {
	        escapedBlocks.push(currentBlockParts.join(''));
	        resultParts.push(BLOCK_PLACEHOLDER);
	    }
	    return new StringWithEscapedBlocks(resultParts.join(''), escapedBlocks);
	}


/***/ },
/* 170 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var di_1 = __webpack_require__(6);
	var compile_element_1 = __webpack_require__(171);
	var compile_view_1 = __webpack_require__(176);
	var view_builder_1 = __webpack_require__(178);
	var view_binder_1 = __webpack_require__(179);
	var config_1 = __webpack_require__(164);
	var ViewCompileResult = (function () {
	    function ViewCompileResult(statements, viewFactoryVar, dependencies) {
	        this.statements = statements;
	        this.viewFactoryVar = viewFactoryVar;
	        this.dependencies = dependencies;
	    }
	    return ViewCompileResult;
	}());
	exports.ViewCompileResult = ViewCompileResult;
	var ViewCompiler = (function () {
	    function ViewCompiler(_genConfig) {
	        this._genConfig = _genConfig;
	    }
	    ViewCompiler.prototype.compileComponent = function (component, template, styles, pipes) {
	        var statements = [];
	        var dependencies = [];
	        var view = new compile_view_1.CompileView(component, this._genConfig, pipes, styles, 0, compile_element_1.CompileElement.createNull(), []);
	        view_builder_1.buildView(view, template, dependencies);
	        // Need to separate binding from creation to be able to refer to
	        // variables that have been declared after usage.
	        view_binder_1.bindView(view, template);
	        view_builder_1.finishView(view, statements);
	        return new ViewCompileResult(statements, view.viewFactory.name, dependencies);
	    };
	    ViewCompiler = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [config_1.CompilerConfig])
	    ], ViewCompiler);
	    return ViewCompiler;
	}());
	exports.ViewCompiler = ViewCompiler;


/***/ },
/* 171 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var exceptions_1 = __webpack_require__(12);
	var o = __webpack_require__(166);
	var identifiers_1 = __webpack_require__(156);
	var constants_1 = __webpack_require__(172);
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var template_ast_1 = __webpack_require__(141);
	var compile_metadata_1 = __webpack_require__(157);
	var util_1 = __webpack_require__(173);
	var compile_query_1 = __webpack_require__(174);
	var compile_method_1 = __webpack_require__(175);
	var util_2 = __webpack_require__(155);
	var CompileNode = (function () {
	    function CompileNode(parent, view, nodeIndex, renderNode, sourceAst) {
	        this.parent = parent;
	        this.view = view;
	        this.nodeIndex = nodeIndex;
	        this.renderNode = renderNode;
	        this.sourceAst = sourceAst;
	    }
	    CompileNode.prototype.isNull = function () { return lang_1.isBlank(this.renderNode); };
	    CompileNode.prototype.isRootElement = function () { return this.view != this.parent.view; };
	    return CompileNode;
	}());
	exports.CompileNode = CompileNode;
	var CompileElement = (function (_super) {
	    __extends(CompileElement, _super);
	    function CompileElement(parent, view, nodeIndex, renderNode, sourceAst, component, _directives, _resolvedProvidersArray, hasViewContainer, hasEmbeddedView, references) {
	        var _this = this;
	        _super.call(this, parent, view, nodeIndex, renderNode, sourceAst);
	        this.component = component;
	        this._directives = _directives;
	        this._resolvedProvidersArray = _resolvedProvidersArray;
	        this.hasViewContainer = hasViewContainer;
	        this.hasEmbeddedView = hasEmbeddedView;
	        this._compViewExpr = null;
	        this._instances = new compile_metadata_1.CompileTokenMap();
	        this._queryCount = 0;
	        this._queries = new compile_metadata_1.CompileTokenMap();
	        this._componentConstructorViewQueryLists = [];
	        this.contentNodesByNgContentIndex = null;
	        this.referenceTokens = {};
	        references.forEach(function (ref) { return _this.referenceTokens[ref.name] = ref.value; });
	        this.elementRef = o.importExpr(identifiers_1.Identifiers.ElementRef).instantiate([this.renderNode]);
	        this._instances.add(identifiers_1.identifierToken(identifiers_1.Identifiers.ElementRef), this.elementRef);
	        this.injector = o.THIS_EXPR.callMethod('injector', [o.literal(this.nodeIndex)]);
	        this._instances.add(identifiers_1.identifierToken(identifiers_1.Identifiers.Injector), this.injector);
	        this._instances.add(identifiers_1.identifierToken(identifiers_1.Identifiers.Renderer), o.THIS_EXPR.prop('renderer'));
	        if (this.hasViewContainer || this.hasEmbeddedView || lang_1.isPresent(this.component)) {
	            this._createAppElement();
	        }
	    }
	    CompileElement.createNull = function () {
	        return new CompileElement(null, null, null, null, null, null, [], [], false, false, []);
	    };
	    CompileElement.prototype._createAppElement = function () {
	        var fieldName = "_appEl_" + this.nodeIndex;
	        var parentNodeIndex = this.isRootElement() ? null : this.parent.nodeIndex;
	        // private is fine here as no child view will reference an AppElement
	        this.view.fields.push(new o.ClassField(fieldName, o.importType(identifiers_1.Identifiers.AppElement), [o.StmtModifier.Private]));
	        var statement = o.THIS_EXPR.prop(fieldName)
	            .set(o.importExpr(identifiers_1.Identifiers.AppElement)
	            .instantiate([
	            o.literal(this.nodeIndex),
	            o.literal(parentNodeIndex),
	            o.THIS_EXPR,
	            this.renderNode
	        ]))
	            .toStmt();
	        this.view.createMethod.addStmt(statement);
	        this.appElement = o.THIS_EXPR.prop(fieldName);
	        this._instances.add(identifiers_1.identifierToken(identifiers_1.Identifiers.AppElement), this.appElement);
	    };
	    CompileElement.prototype.setComponentView = function (compViewExpr) {
	        this._compViewExpr = compViewExpr;
	        this.contentNodesByNgContentIndex =
	            collection_1.ListWrapper.createFixedSize(this.component.template.ngContentSelectors.length);
	        for (var i = 0; i < this.contentNodesByNgContentIndex.length; i++) {
	            this.contentNodesByNgContentIndex[i] = [];
	        }
	    };
	    CompileElement.prototype.setEmbeddedView = function (embeddedView) {
	        this.embeddedView = embeddedView;
	        if (lang_1.isPresent(embeddedView)) {
	            var createTemplateRefExpr = o.importExpr(identifiers_1.Identifiers.TemplateRef_)
	                .instantiate([this.appElement, this.embeddedView.viewFactory]);
	            var provider = new compile_metadata_1.CompileProviderMetadata({ token: identifiers_1.identifierToken(identifiers_1.Identifiers.TemplateRef), useValue: createTemplateRefExpr });
	            // Add TemplateRef as first provider as it does not have deps on other providers
	            this._resolvedProvidersArray.unshift(new template_ast_1.ProviderAst(provider.token, false, true, [provider], template_ast_1.ProviderAstType.Builtin, this.sourceAst.sourceSpan));
	        }
	    };
	    CompileElement.prototype.beforeChildren = function () {
	        var _this = this;
	        if (this.hasViewContainer) {
	            this._instances.add(identifiers_1.identifierToken(identifiers_1.Identifiers.ViewContainerRef), this.appElement.prop('vcRef'));
	        }
	        this._resolvedProviders = new compile_metadata_1.CompileTokenMap();
	        this._resolvedProvidersArray.forEach(function (provider) {
	            return _this._resolvedProviders.add(provider.token, provider);
	        });
	        // create all the provider instances, some in the view constructor,
	        // some as getters. We rely on the fact that they are already sorted topologically.
	        this._resolvedProviders.values().forEach(function (resolvedProvider) {
	            var providerValueExpressions = resolvedProvider.providers.map(function (provider) {
	                if (lang_1.isPresent(provider.useExisting)) {
	                    return _this._getDependency(resolvedProvider.providerType, new compile_metadata_1.CompileDiDependencyMetadata({ token: provider.useExisting }));
	                }
	                else if (lang_1.isPresent(provider.useFactory)) {
	                    var deps = lang_1.isPresent(provider.deps) ? provider.deps : provider.useFactory.diDeps;
	                    var depsExpr = deps.map(function (dep) { return _this._getDependency(resolvedProvider.providerType, dep); });
	                    return o.importExpr(provider.useFactory).callFn(depsExpr);
	                }
	                else if (lang_1.isPresent(provider.useClass)) {
	                    var deps = lang_1.isPresent(provider.deps) ? provider.deps : provider.useClass.diDeps;
	                    var depsExpr = deps.map(function (dep) { return _this._getDependency(resolvedProvider.providerType, dep); });
	                    return o.importExpr(provider.useClass)
	                        .instantiate(depsExpr, o.importType(provider.useClass));
	                }
	                else {
	                    return _convertValueToOutputAst(provider.useValue);
	                }
	            });
	            var propName = "_" + resolvedProvider.token.name + "_" + _this.nodeIndex + "_" + _this._instances.size;
	            var instance = createProviderProperty(propName, resolvedProvider, providerValueExpressions, resolvedProvider.multiProvider, resolvedProvider.eager, _this);
	            _this._instances.add(resolvedProvider.token, instance);
	        });
	        this.directiveInstances =
	            this._directives.map(function (directive) { return _this._instances.get(identifiers_1.identifierToken(directive.type)); });
	        for (var i = 0; i < this.directiveInstances.length; i++) {
	            var directiveInstance = this.directiveInstances[i];
	            var directive = this._directives[i];
	            directive.queries.forEach(function (queryMeta) { _this._addQuery(queryMeta, directiveInstance); });
	        }
	        var queriesWithReads = [];
	        this._resolvedProviders.values().forEach(function (resolvedProvider) {
	            var queriesForProvider = _this._getQueriesFor(resolvedProvider.token);
	            collection_1.ListWrapper.addAll(queriesWithReads, queriesForProvider.map(function (query) { return new _QueryWithRead(query, resolvedProvider.token); }));
	        });
	        collection_1.StringMapWrapper.forEach(this.referenceTokens, function (_, varName) {
	            var token = _this.referenceTokens[varName];
	            var varValue;
	            if (lang_1.isPresent(token)) {
	                varValue = _this._instances.get(token);
	            }
	            else {
	                varValue = _this.renderNode;
	            }
	            _this.view.locals.set(varName, varValue);
	            var varToken = new compile_metadata_1.CompileTokenMetadata({ value: varName });
	            collection_1.ListWrapper.addAll(queriesWithReads, _this._getQueriesFor(varToken)
	                .map(function (query) { return new _QueryWithRead(query, varToken); }));
	        });
	        queriesWithReads.forEach(function (queryWithRead) {
	            var value;
	            if (lang_1.isPresent(queryWithRead.read.identifier)) {
	                // query for an identifier
	                value = _this._instances.get(queryWithRead.read);
	            }
	            else {
	                // query for a reference
	                var token = _this.referenceTokens[queryWithRead.read.value];
	                if (lang_1.isPresent(token)) {
	                    value = _this._instances.get(token);
	                }
	                else {
	                    value = _this.elementRef;
	                }
	            }
	            if (lang_1.isPresent(value)) {
	                queryWithRead.query.addValue(value, _this.view);
	            }
	        });
	        if (lang_1.isPresent(this.component)) {
	            var componentConstructorViewQueryList = lang_1.isPresent(this.component) ? o.literalArr(this._componentConstructorViewQueryLists) :
	                o.NULL_EXPR;
	            var compExpr = lang_1.isPresent(this.getComponent()) ? this.getComponent() : o.NULL_EXPR;
	            this.view.createMethod.addStmt(this.appElement.callMethod('initComponent', [compExpr, componentConstructorViewQueryList, this._compViewExpr])
	                .toStmt());
	        }
	    };
	    CompileElement.prototype.afterChildren = function (childNodeCount) {
	        var _this = this;
	        this._resolvedProviders.values().forEach(function (resolvedProvider) {
	            // Note: afterChildren is called after recursing into children.
	            // This is good so that an injector match in an element that is closer to a requesting element
	            // matches first.
	            var providerExpr = _this._instances.get(resolvedProvider.token);
	            // Note: view providers are only visible on the injector of that element.
	            // This is not fully correct as the rules during codegen don't allow a directive
	            // to get hold of a view provdier on the same element. We still do this semantic
	            // as it simplifies our model to having only one runtime injector per element.
	            var providerChildNodeCount = resolvedProvider.providerType === template_ast_1.ProviderAstType.PrivateService ? 0 : childNodeCount;
	            _this.view.injectorGetMethod.addStmt(createInjectInternalCondition(_this.nodeIndex, providerChildNodeCount, resolvedProvider, providerExpr));
	        });
	        this._queries.values().forEach(function (queries) {
	            return queries.forEach(function (query) { return query.afterChildren(_this.view.updateContentQueriesMethod); });
	        });
	    };
	    CompileElement.prototype.addContentNode = function (ngContentIndex, nodeExpr) {
	        this.contentNodesByNgContentIndex[ngContentIndex].push(nodeExpr);
	    };
	    CompileElement.prototype.getComponent = function () {
	        return lang_1.isPresent(this.component) ? this._instances.get(identifiers_1.identifierToken(this.component.type)) :
	            null;
	    };
	    CompileElement.prototype.getProviderTokens = function () {
	        return this._resolvedProviders.values().map(function (resolvedProvider) { return util_1.createDiTokenExpression(resolvedProvider.token); });
	    };
	    CompileElement.prototype._getQueriesFor = function (token) {
	        var result = [];
	        var currentEl = this;
	        var distance = 0;
	        var queries;
	        while (!currentEl.isNull()) {
	            queries = currentEl._queries.get(token);
	            if (lang_1.isPresent(queries)) {
	                collection_1.ListWrapper.addAll(result, queries.filter(function (query) { return query.meta.descendants || distance <= 1; }));
	            }
	            if (currentEl._directives.length > 0) {
	                distance++;
	            }
	            currentEl = currentEl.parent;
	        }
	        queries = this.view.componentView.viewQueries.get(token);
	        if (lang_1.isPresent(queries)) {
	            collection_1.ListWrapper.addAll(result, queries);
	        }
	        return result;
	    };
	    CompileElement.prototype._addQuery = function (queryMeta, directiveInstance) {
	        var propName = "_query_" + queryMeta.selectors[0].name + "_" + this.nodeIndex + "_" + this._queryCount++;
	        var queryList = compile_query_1.createQueryList(queryMeta, directiveInstance, propName, this.view);
	        var query = new compile_query_1.CompileQuery(queryMeta, queryList, directiveInstance, this.view);
	        compile_query_1.addQueryToTokenMap(this._queries, query);
	        return query;
	    };
	    CompileElement.prototype._getLocalDependency = function (requestingProviderType, dep) {
	        var result = null;
	        // constructor content query
	        if (lang_1.isBlank(result) && lang_1.isPresent(dep.query)) {
	            result = this._addQuery(dep.query, null).queryList;
	        }
	        // constructor view query
	        if (lang_1.isBlank(result) && lang_1.isPresent(dep.viewQuery)) {
	            result = compile_query_1.createQueryList(dep.viewQuery, null, "_viewQuery_" + dep.viewQuery.selectors[0].name + "_" + this.nodeIndex + "_" + this._componentConstructorViewQueryLists.length, this.view);
	            this._componentConstructorViewQueryLists.push(result);
	        }
	        if (lang_1.isPresent(dep.token)) {
	            // access builtins with special visibility
	            if (lang_1.isBlank(result)) {
	                if (dep.token.equalsTo(identifiers_1.identifierToken(identifiers_1.Identifiers.ChangeDetectorRef))) {
	                    if (requestingProviderType === template_ast_1.ProviderAstType.Component) {
	                        return this._compViewExpr.prop('ref');
	                    }
	                    else {
	                        return util_1.getPropertyInView(o.THIS_EXPR.prop('ref'), this.view, this.view.componentView);
	                    }
	                }
	            }
	            // access regular providers on the element
	            if (lang_1.isBlank(result)) {
	                result = this._instances.get(dep.token);
	            }
	        }
	        return result;
	    };
	    CompileElement.prototype._getDependency = function (requestingProviderType, dep) {
	        var currElement = this;
	        var result = null;
	        if (dep.isValue) {
	            result = o.literal(dep.value);
	        }
	        if (lang_1.isBlank(result) && !dep.isSkipSelf) {
	            result = this._getLocalDependency(requestingProviderType, dep);
	        }
	        // check parent elements
	        while (lang_1.isBlank(result) && !currElement.parent.isNull()) {
	            currElement = currElement.parent;
	            result = currElement._getLocalDependency(template_ast_1.ProviderAstType.PublicService, new compile_metadata_1.CompileDiDependencyMetadata({ token: dep.token }));
	        }
	        if (lang_1.isBlank(result)) {
	            result = util_1.injectFromViewParentInjector(dep.token, dep.isOptional);
	        }
	        if (lang_1.isBlank(result)) {
	            result = o.NULL_EXPR;
	        }
	        return util_1.getPropertyInView(result, this.view, currElement.view);
	    };
	    return CompileElement;
	}(CompileNode));
	exports.CompileElement = CompileElement;
	function createInjectInternalCondition(nodeIndex, childNodeCount, provider, providerExpr) {
	    var indexCondition;
	    if (childNodeCount > 0) {
	        indexCondition = o.literal(nodeIndex)
	            .lowerEquals(constants_1.InjectMethodVars.requestNodeIndex)
	            .and(constants_1.InjectMethodVars.requestNodeIndex.lowerEquals(o.literal(nodeIndex + childNodeCount)));
	    }
	    else {
	        indexCondition = o.literal(nodeIndex).identical(constants_1.InjectMethodVars.requestNodeIndex);
	    }
	    return new o.IfStmt(constants_1.InjectMethodVars.token.identical(util_1.createDiTokenExpression(provider.token)).and(indexCondition), [new o.ReturnStatement(providerExpr)]);
	}
	function createProviderProperty(propName, provider, providerValueExpressions, isMulti, isEager, compileElement) {
	    var view = compileElement.view;
	    var resolvedProviderValueExpr;
	    var type;
	    if (isMulti) {
	        resolvedProviderValueExpr = o.literalArr(providerValueExpressions);
	        type = new o.ArrayType(o.DYNAMIC_TYPE);
	    }
	    else {
	        resolvedProviderValueExpr = providerValueExpressions[0];
	        type = providerValueExpressions[0].type;
	    }
	    if (lang_1.isBlank(type)) {
	        type = o.DYNAMIC_TYPE;
	    }
	    if (isEager) {
	        view.fields.push(new o.ClassField(propName, type));
	        view.createMethod.addStmt(o.THIS_EXPR.prop(propName).set(resolvedProviderValueExpr).toStmt());
	    }
	    else {
	        var internalField = "_" + propName;
	        view.fields.push(new o.ClassField(internalField, type));
	        var getter = new compile_method_1.CompileMethod(view);
	        getter.resetDebugInfo(compileElement.nodeIndex, compileElement.sourceAst);
	        // Note: Equals is important for JS so that it also checks the undefined case!
	        getter.addStmt(new o.IfStmt(o.THIS_EXPR.prop(internalField).isBlank(), [o.THIS_EXPR.prop(internalField).set(resolvedProviderValueExpr).toStmt()]));
	        getter.addStmt(new o.ReturnStatement(o.THIS_EXPR.prop(internalField)));
	        view.getters.push(new o.ClassGetter(propName, getter.finish(), type));
	    }
	    return o.THIS_EXPR.prop(propName);
	}
	var _QueryWithRead = (function () {
	    function _QueryWithRead(query, match) {
	        this.query = query;
	        this.read = lang_1.isPresent(query.meta.read) ? query.meta.read : match;
	    }
	    return _QueryWithRead;
	}());
	function _convertValueToOutputAst(value) {
	    return util_2.visitValue(value, new _ValueOutputAstTransformer(), null);
	}
	var _ValueOutputAstTransformer = (function (_super) {
	    __extends(_ValueOutputAstTransformer, _super);
	    function _ValueOutputAstTransformer() {
	        _super.apply(this, arguments);
	    }
	    _ValueOutputAstTransformer.prototype.visitArray = function (arr, context) {
	        var _this = this;
	        return o.literalArr(arr.map(function (value) { return util_2.visitValue(value, _this, context); }));
	    };
	    _ValueOutputAstTransformer.prototype.visitStringMap = function (map, context) {
	        var _this = this;
	        var entries = [];
	        collection_1.StringMapWrapper.forEach(map, function (value, key) { entries.push([key, util_2.visitValue(value, _this, context)]); });
	        return o.literalMap(entries);
	    };
	    _ValueOutputAstTransformer.prototype.visitPrimitive = function (value, context) { return o.literal(value); };
	    _ValueOutputAstTransformer.prototype.visitOther = function (value, context) {
	        if (value instanceof compile_metadata_1.CompileIdentifierMetadata) {
	            return o.importExpr(value);
	        }
	        else if (value instanceof o.Expression) {
	            return value;
	        }
	        else {
	            throw new exceptions_1.BaseException("Illegal state: Don't now how to compile value " + value);
	        }
	    };
	    return _ValueOutputAstTransformer;
	}(util_2.ValueTransformer));


/***/ },
/* 172 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var compile_metadata_1 = __webpack_require__(157);
	var change_detection_1 = __webpack_require__(29);
	var view_1 = __webpack_require__(37);
	var view_type_1 = __webpack_require__(70);
	var o = __webpack_require__(166);
	var identifiers_1 = __webpack_require__(156);
	function _enumExpression(classIdentifier, value) {
	    if (lang_1.isBlank(value))
	        return o.NULL_EXPR;
	    var name = lang_1.resolveEnumToken(classIdentifier.runtime, value);
	    return o.importExpr(new compile_metadata_1.CompileIdentifierMetadata({
	        name: classIdentifier.name + "." + name,
	        moduleUrl: classIdentifier.moduleUrl,
	        runtime: value
	    }));
	}
	var ViewTypeEnum = (function () {
	    function ViewTypeEnum() {
	    }
	    ViewTypeEnum.fromValue = function (value) {
	        return _enumExpression(identifiers_1.Identifiers.ViewType, value);
	    };
	    ViewTypeEnum.HOST = ViewTypeEnum.fromValue(view_type_1.ViewType.HOST);
	    ViewTypeEnum.COMPONENT = ViewTypeEnum.fromValue(view_type_1.ViewType.COMPONENT);
	    ViewTypeEnum.EMBEDDED = ViewTypeEnum.fromValue(view_type_1.ViewType.EMBEDDED);
	    return ViewTypeEnum;
	}());
	exports.ViewTypeEnum = ViewTypeEnum;
	var ViewEncapsulationEnum = (function () {
	    function ViewEncapsulationEnum() {
	    }
	    ViewEncapsulationEnum.fromValue = function (value) {
	        return _enumExpression(identifiers_1.Identifiers.ViewEncapsulation, value);
	    };
	    ViewEncapsulationEnum.Emulated = ViewEncapsulationEnum.fromValue(view_1.ViewEncapsulation.Emulated);
	    ViewEncapsulationEnum.Native = ViewEncapsulationEnum.fromValue(view_1.ViewEncapsulation.Native);
	    ViewEncapsulationEnum.None = ViewEncapsulationEnum.fromValue(view_1.ViewEncapsulation.None);
	    return ViewEncapsulationEnum;
	}());
	exports.ViewEncapsulationEnum = ViewEncapsulationEnum;
	var ChangeDetectorStateEnum = (function () {
	    function ChangeDetectorStateEnum() {
	    }
	    ChangeDetectorStateEnum.fromValue = function (value) {
	        return _enumExpression(identifiers_1.Identifiers.ChangeDetectorState, value);
	    };
	    ChangeDetectorStateEnum.NeverChecked = ChangeDetectorStateEnum.fromValue(change_detection_1.ChangeDetectorState.NeverChecked);
	    ChangeDetectorStateEnum.CheckedBefore = ChangeDetectorStateEnum.fromValue(change_detection_1.ChangeDetectorState.CheckedBefore);
	    ChangeDetectorStateEnum.Errored = ChangeDetectorStateEnum.fromValue(change_detection_1.ChangeDetectorState.Errored);
	    return ChangeDetectorStateEnum;
	}());
	exports.ChangeDetectorStateEnum = ChangeDetectorStateEnum;
	var ChangeDetectionStrategyEnum = (function () {
	    function ChangeDetectionStrategyEnum() {
	    }
	    ChangeDetectionStrategyEnum.fromValue = function (value) {
	        return _enumExpression(identifiers_1.Identifiers.ChangeDetectionStrategy, value);
	    };
	    ChangeDetectionStrategyEnum.CheckOnce = ChangeDetectionStrategyEnum.fromValue(change_detection_1.ChangeDetectionStrategy.CheckOnce);
	    ChangeDetectionStrategyEnum.Checked = ChangeDetectionStrategyEnum.fromValue(change_detection_1.ChangeDetectionStrategy.Checked);
	    ChangeDetectionStrategyEnum.CheckAlways = ChangeDetectionStrategyEnum.fromValue(change_detection_1.ChangeDetectionStrategy.CheckAlways);
	    ChangeDetectionStrategyEnum.Detached = ChangeDetectionStrategyEnum.fromValue(change_detection_1.ChangeDetectionStrategy.Detached);
	    ChangeDetectionStrategyEnum.OnPush = ChangeDetectionStrategyEnum.fromValue(change_detection_1.ChangeDetectionStrategy.OnPush);
	    ChangeDetectionStrategyEnum.Default = ChangeDetectionStrategyEnum.fromValue(change_detection_1.ChangeDetectionStrategy.Default);
	    return ChangeDetectionStrategyEnum;
	}());
	exports.ChangeDetectionStrategyEnum = ChangeDetectionStrategyEnum;
	var ViewConstructorVars = (function () {
	    function ViewConstructorVars() {
	    }
	    ViewConstructorVars.viewUtils = o.variable('viewUtils');
	    ViewConstructorVars.parentInjector = o.variable('parentInjector');
	    ViewConstructorVars.declarationEl = o.variable('declarationEl');
	    return ViewConstructorVars;
	}());
	exports.ViewConstructorVars = ViewConstructorVars;
	var ViewProperties = (function () {
	    function ViewProperties() {
	    }
	    ViewProperties.renderer = o.THIS_EXPR.prop('renderer');
	    ViewProperties.projectableNodes = o.THIS_EXPR.prop('projectableNodes');
	    ViewProperties.viewUtils = o.THIS_EXPR.prop('viewUtils');
	    return ViewProperties;
	}());
	exports.ViewProperties = ViewProperties;
	var EventHandlerVars = (function () {
	    function EventHandlerVars() {
	    }
	    EventHandlerVars.event = o.variable('$event');
	    return EventHandlerVars;
	}());
	exports.EventHandlerVars = EventHandlerVars;
	var InjectMethodVars = (function () {
	    function InjectMethodVars() {
	    }
	    InjectMethodVars.token = o.variable('token');
	    InjectMethodVars.requestNodeIndex = o.variable('requestNodeIndex');
	    InjectMethodVars.notFoundResult = o.variable('notFoundResult');
	    return InjectMethodVars;
	}());
	exports.InjectMethodVars = InjectMethodVars;
	var DetectChangesVars = (function () {
	    function DetectChangesVars() {
	    }
	    DetectChangesVars.throwOnChange = o.variable("throwOnChange");
	    DetectChangesVars.changes = o.variable("changes");
	    DetectChangesVars.changed = o.variable("changed");
	    DetectChangesVars.valUnwrapper = o.variable("valUnwrapper");
	    return DetectChangesVars;
	}());
	exports.DetectChangesVars = DetectChangesVars;


/***/ },
/* 173 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var o = __webpack_require__(166);
	var identifiers_1 = __webpack_require__(156);
	function getPropertyInView(property, callingView, definedView) {
	    if (callingView === definedView) {
	        return property;
	    }
	    else {
	        var viewProp = o.THIS_EXPR;
	        var currView = callingView;
	        while (currView !== definedView && lang_1.isPresent(currView.declarationElement.view)) {
	            currView = currView.declarationElement.view;
	            viewProp = viewProp.prop('parent');
	        }
	        if (currView !== definedView) {
	            throw new exceptions_1.BaseException("Internal error: Could not calculate a property in a parent view: " + property);
	        }
	        if (property instanceof o.ReadPropExpr) {
	            var readPropExpr_1 = property;
	            // Note: Don't cast for members of the AppView base class...
	            if (definedView.fields.some(function (field) { return field.name == readPropExpr_1.name; }) ||
	                definedView.getters.some(function (field) { return field.name == readPropExpr_1.name; })) {
	                viewProp = viewProp.cast(definedView.classType);
	            }
	        }
	        return o.replaceVarInExpression(o.THIS_EXPR.name, viewProp, property);
	    }
	}
	exports.getPropertyInView = getPropertyInView;
	function injectFromViewParentInjector(token, optional) {
	    var args = [createDiTokenExpression(token)];
	    if (optional) {
	        args.push(o.NULL_EXPR);
	    }
	    return o.THIS_EXPR.prop('parentInjector').callMethod('get', args);
	}
	exports.injectFromViewParentInjector = injectFromViewParentInjector;
	function getViewFactoryName(component, embeddedTemplateIndex) {
	    return "viewFactory_" + component.type.name + embeddedTemplateIndex;
	}
	exports.getViewFactoryName = getViewFactoryName;
	function createDiTokenExpression(token) {
	    if (lang_1.isPresent(token.value)) {
	        return o.literal(token.value);
	    }
	    else if (token.identifierIsInstance) {
	        return o.importExpr(token.identifier)
	            .instantiate([], o.importType(token.identifier, [], [o.TypeModifier.Const]));
	    }
	    else {
	        return o.importExpr(token.identifier);
	    }
	}
	exports.createDiTokenExpression = createDiTokenExpression;
	function createFlatArray(expressions) {
	    var lastNonArrayExpressions = [];
	    var result = o.literalArr([]);
	    for (var i = 0; i < expressions.length; i++) {
	        var expr = expressions[i];
	        if (expr.type instanceof o.ArrayType) {
	            if (lastNonArrayExpressions.length > 0) {
	                result =
	                    result.callMethod(o.BuiltinMethod.ConcatArray, [o.literalArr(lastNonArrayExpressions)]);
	                lastNonArrayExpressions = [];
	            }
	            result = result.callMethod(o.BuiltinMethod.ConcatArray, [expr]);
	        }
	        else {
	            lastNonArrayExpressions.push(expr);
	        }
	    }
	    if (lastNonArrayExpressions.length > 0) {
	        result =
	            result.callMethod(o.BuiltinMethod.ConcatArray, [o.literalArr(lastNonArrayExpressions)]);
	    }
	    return result;
	}
	exports.createFlatArray = createFlatArray;
	function createPureProxy(fn, argCount, pureProxyProp, view) {
	    view.fields.push(new o.ClassField(pureProxyProp.name, null));
	    var pureProxyId = argCount < identifiers_1.Identifiers.pureProxies.length ? identifiers_1.Identifiers.pureProxies[argCount] : null;
	    if (lang_1.isBlank(pureProxyId)) {
	        throw new exceptions_1.BaseException("Unsupported number of argument for pure functions: " + argCount);
	    }
	    view.createMethod.addStmt(o.THIS_EXPR.prop(pureProxyProp.name).set(o.importExpr(pureProxyId).callFn([fn])).toStmt());
	}
	exports.createPureProxy = createPureProxy;


/***/ },
/* 174 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var o = __webpack_require__(166);
	var identifiers_1 = __webpack_require__(156);
	var util_1 = __webpack_require__(173);
	var ViewQueryValues = (function () {
	    function ViewQueryValues(view, values) {
	        this.view = view;
	        this.values = values;
	    }
	    return ViewQueryValues;
	}());
	var CompileQuery = (function () {
	    function CompileQuery(meta, queryList, ownerDirectiveExpression, view) {
	        this.meta = meta;
	        this.queryList = queryList;
	        this.ownerDirectiveExpression = ownerDirectiveExpression;
	        this.view = view;
	        this._values = new ViewQueryValues(view, []);
	    }
	    CompileQuery.prototype.addValue = function (value, view) {
	        var currentView = view;
	        var elPath = [];
	        while (lang_1.isPresent(currentView) && currentView !== this.view) {
	            var parentEl = currentView.declarationElement;
	            elPath.unshift(parentEl);
	            currentView = parentEl.view;
	        }
	        var queryListForDirtyExpr = util_1.getPropertyInView(this.queryList, view, this.view);
	        var viewValues = this._values;
	        elPath.forEach(function (el) {
	            var last = viewValues.values.length > 0 ? viewValues.values[viewValues.values.length - 1] : null;
	            if (last instanceof ViewQueryValues && last.view === el.embeddedView) {
	                viewValues = last;
	            }
	            else {
	                var newViewValues = new ViewQueryValues(el.embeddedView, []);
	                viewValues.values.push(newViewValues);
	                viewValues = newViewValues;
	            }
	        });
	        viewValues.values.push(value);
	        if (elPath.length > 0) {
	            view.dirtyParentQueriesMethod.addStmt(queryListForDirtyExpr.callMethod('setDirty', []).toStmt());
	        }
	    };
	    CompileQuery.prototype.afterChildren = function (targetMethod) {
	        var values = createQueryValues(this._values);
	        var updateStmts = [this.queryList.callMethod('reset', [o.literalArr(values)]).toStmt()];
	        if (lang_1.isPresent(this.ownerDirectiveExpression)) {
	            var valueExpr = this.meta.first ? this.queryList.prop('first') : this.queryList;
	            updateStmts.push(this.ownerDirectiveExpression.prop(this.meta.propertyName).set(valueExpr).toStmt());
	        }
	        if (!this.meta.first) {
	            updateStmts.push(this.queryList.callMethod('notifyOnChanges', []).toStmt());
	        }
	        targetMethod.addStmt(new o.IfStmt(this.queryList.prop('dirty'), updateStmts));
	    };
	    return CompileQuery;
	}());
	exports.CompileQuery = CompileQuery;
	function createQueryValues(viewValues) {
	    return collection_1.ListWrapper.flatten(viewValues.values.map(function (entry) {
	        if (entry instanceof ViewQueryValues) {
	            return mapNestedViews(entry.view.declarationElement.appElement, entry.view, createQueryValues(entry));
	        }
	        else {
	            return entry;
	        }
	    }));
	}
	function mapNestedViews(declarationAppElement, view, expressions) {
	    var adjustedExpressions = expressions.map(function (expr) {
	        return o.replaceVarInExpression(o.THIS_EXPR.name, o.variable('nestedView'), expr);
	    });
	    return declarationAppElement.callMethod('mapNestedViews', [
	        o.variable(view.className),
	        o.fn([new o.FnParam('nestedView', view.classType)], [new o.ReturnStatement(o.literalArr(adjustedExpressions))])
	    ]);
	}
	function createQueryList(query, directiveInstance, propertyName, compileView) {
	    compileView.fields.push(new o.ClassField(propertyName, o.importType(identifiers_1.Identifiers.QueryList)));
	    var expr = o.THIS_EXPR.prop(propertyName);
	    compileView.createMethod.addStmt(o.THIS_EXPR.prop(propertyName)
	        .set(o.importExpr(identifiers_1.Identifiers.QueryList).instantiate([]))
	        .toStmt());
	    return expr;
	}
	exports.createQueryList = createQueryList;
	function addQueryToTokenMap(map, query) {
	    query.meta.selectors.forEach(function (selector) {
	        var entry = map.get(selector);
	        if (lang_1.isBlank(entry)) {
	            entry = [];
	            map.add(selector, entry);
	        }
	        entry.push(query);
	    });
	}
	exports.addQueryToTokenMap = addQueryToTokenMap;


/***/ },
/* 175 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var o = __webpack_require__(166);
	var _DebugState = (function () {
	    function _DebugState(nodeIndex, sourceAst) {
	        this.nodeIndex = nodeIndex;
	        this.sourceAst = sourceAst;
	    }
	    return _DebugState;
	}());
	var NULL_DEBUG_STATE = new _DebugState(null, null);
	var CompileMethod = (function () {
	    function CompileMethod(_view) {
	        this._view = _view;
	        this._newState = NULL_DEBUG_STATE;
	        this._currState = NULL_DEBUG_STATE;
	        this._bodyStatements = [];
	        this._debugEnabled = this._view.genConfig.genDebugInfo;
	    }
	    CompileMethod.prototype._updateDebugContextIfNeeded = function () {
	        if (this._newState.nodeIndex !== this._currState.nodeIndex ||
	            this._newState.sourceAst !== this._currState.sourceAst) {
	            var expr = this._updateDebugContext(this._newState);
	            if (lang_1.isPresent(expr)) {
	                this._bodyStatements.push(expr.toStmt());
	            }
	        }
	    };
	    CompileMethod.prototype._updateDebugContext = function (newState) {
	        this._currState = this._newState = newState;
	        if (this._debugEnabled) {
	            var sourceLocation = lang_1.isPresent(newState.sourceAst) ? newState.sourceAst.sourceSpan.start : null;
	            return o.THIS_EXPR.callMethod('debug', [
	                o.literal(newState.nodeIndex),
	                lang_1.isPresent(sourceLocation) ? o.literal(sourceLocation.line) : o.NULL_EXPR,
	                lang_1.isPresent(sourceLocation) ? o.literal(sourceLocation.col) : o.NULL_EXPR
	            ]);
	        }
	        else {
	            return null;
	        }
	    };
	    CompileMethod.prototype.resetDebugInfoExpr = function (nodeIndex, templateAst) {
	        var res = this._updateDebugContext(new _DebugState(nodeIndex, templateAst));
	        return lang_1.isPresent(res) ? res : o.NULL_EXPR;
	    };
	    CompileMethod.prototype.resetDebugInfo = function (nodeIndex, templateAst) {
	        this._newState = new _DebugState(nodeIndex, templateAst);
	    };
	    CompileMethod.prototype.addStmt = function (stmt) {
	        this._updateDebugContextIfNeeded();
	        this._bodyStatements.push(stmt);
	    };
	    CompileMethod.prototype.addStmts = function (stmts) {
	        this._updateDebugContextIfNeeded();
	        collection_1.ListWrapper.addAll(this._bodyStatements, stmts);
	    };
	    CompileMethod.prototype.finish = function () { return this._bodyStatements; };
	    CompileMethod.prototype.isEmpty = function () { return this._bodyStatements.length === 0; };
	    return CompileMethod;
	}());
	exports.CompileMethod = CompileMethod;


/***/ },
/* 176 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var o = __webpack_require__(166);
	var constants_1 = __webpack_require__(172);
	var compile_query_1 = __webpack_require__(174);
	var compile_method_1 = __webpack_require__(175);
	var compile_pipe_1 = __webpack_require__(177);
	var view_type_1 = __webpack_require__(70);
	var compile_metadata_1 = __webpack_require__(157);
	var util_1 = __webpack_require__(173);
	var identifiers_1 = __webpack_require__(156);
	var CompileView = (function () {
	    function CompileView(component, genConfig, pipeMetas, styles, viewIndex, declarationElement, templateVariableBindings) {
	        var _this = this;
	        this.component = component;
	        this.genConfig = genConfig;
	        this.pipeMetas = pipeMetas;
	        this.styles = styles;
	        this.viewIndex = viewIndex;
	        this.declarationElement = declarationElement;
	        this.templateVariableBindings = templateVariableBindings;
	        this.nodes = [];
	        // root nodes or AppElements for ViewContainers
	        this.rootNodesOrAppElements = [];
	        this.bindings = [];
	        this.classStatements = [];
	        this.eventHandlerMethods = [];
	        this.fields = [];
	        this.getters = [];
	        this.disposables = [];
	        this.subscriptions = [];
	        this.purePipes = new Map();
	        this.pipes = [];
	        this.locals = new Map();
	        this.literalArrayCount = 0;
	        this.literalMapCount = 0;
	        this.pipeCount = 0;
	        this.createMethod = new compile_method_1.CompileMethod(this);
	        this.injectorGetMethod = new compile_method_1.CompileMethod(this);
	        this.updateContentQueriesMethod = new compile_method_1.CompileMethod(this);
	        this.dirtyParentQueriesMethod = new compile_method_1.CompileMethod(this);
	        this.updateViewQueriesMethod = new compile_method_1.CompileMethod(this);
	        this.detectChangesInInputsMethod = new compile_method_1.CompileMethod(this);
	        this.detectChangesRenderPropertiesMethod = new compile_method_1.CompileMethod(this);
	        this.afterContentLifecycleCallbacksMethod = new compile_method_1.CompileMethod(this);
	        this.afterViewLifecycleCallbacksMethod = new compile_method_1.CompileMethod(this);
	        this.destroyMethod = new compile_method_1.CompileMethod(this);
	        this.viewType = getViewType(component, viewIndex);
	        this.className = "_View_" + component.type.name + viewIndex;
	        this.classType = o.importType(new compile_metadata_1.CompileIdentifierMetadata({ name: this.className }));
	        this.viewFactory = o.variable(util_1.getViewFactoryName(component, viewIndex));
	        if (this.viewType === view_type_1.ViewType.COMPONENT || this.viewType === view_type_1.ViewType.HOST) {
	            this.componentView = this;
	        }
	        else {
	            this.componentView = this.declarationElement.view.componentView;
	        }
	        this.componentContext =
	            util_1.getPropertyInView(o.THIS_EXPR.prop('context'), this, this.componentView);
	        var viewQueries = new compile_metadata_1.CompileTokenMap();
	        if (this.viewType === view_type_1.ViewType.COMPONENT) {
	            var directiveInstance = o.THIS_EXPR.prop('context');
	            collection_1.ListWrapper.forEachWithIndex(this.component.viewQueries, function (queryMeta, queryIndex) {
	                var propName = "_viewQuery_" + queryMeta.selectors[0].name + "_" + queryIndex;
	                var queryList = compile_query_1.createQueryList(queryMeta, directiveInstance, propName, _this);
	                var query = new compile_query_1.CompileQuery(queryMeta, queryList, directiveInstance, _this);
	                compile_query_1.addQueryToTokenMap(viewQueries, query);
	            });
	            var constructorViewQueryCount = 0;
	            this.component.type.diDeps.forEach(function (dep) {
	                if (lang_1.isPresent(dep.viewQuery)) {
	                    var queryList = o.THIS_EXPR.prop('declarationAppElement')
	                        .prop('componentConstructorViewQueries')
	                        .key(o.literal(constructorViewQueryCount++));
	                    var query = new compile_query_1.CompileQuery(dep.viewQuery, queryList, null, _this);
	                    compile_query_1.addQueryToTokenMap(viewQueries, query);
	                }
	            });
	        }
	        this.viewQueries = viewQueries;
	        templateVariableBindings.forEach(function (entry) { _this.locals.set(entry[1], o.THIS_EXPR.prop('context').prop(entry[0])); });
	        if (!this.declarationElement.isNull()) {
	            this.declarationElement.setEmbeddedView(this);
	        }
	    }
	    CompileView.prototype.callPipe = function (name, input, args) {
	        var compView = this.componentView;
	        var pipe = compView.purePipes.get(name);
	        if (lang_1.isBlank(pipe)) {
	            pipe = new compile_pipe_1.CompilePipe(compView, name);
	            if (pipe.pure) {
	                compView.purePipes.set(name, pipe);
	            }
	            compView.pipes.push(pipe);
	        }
	        return pipe.call(this, [input].concat(args));
	    };
	    CompileView.prototype.getLocal = function (name) {
	        if (name == constants_1.EventHandlerVars.event.name) {
	            return constants_1.EventHandlerVars.event;
	        }
	        var currView = this;
	        var result = currView.locals.get(name);
	        while (lang_1.isBlank(result) && lang_1.isPresent(currView.declarationElement.view)) {
	            currView = currView.declarationElement.view;
	            result = currView.locals.get(name);
	        }
	        if (lang_1.isPresent(result)) {
	            return util_1.getPropertyInView(result, this, currView);
	        }
	        else {
	            return null;
	        }
	    };
	    CompileView.prototype.createLiteralArray = function (values) {
	        if (values.length === 0) {
	            return o.importExpr(identifiers_1.Identifiers.EMPTY_ARRAY);
	        }
	        var proxyExpr = o.THIS_EXPR.prop("_arr_" + this.literalArrayCount++);
	        var proxyParams = [];
	        var proxyReturnEntries = [];
	        for (var i = 0; i < values.length; i++) {
	            var paramName = "p" + i;
	            proxyParams.push(new o.FnParam(paramName));
	            proxyReturnEntries.push(o.variable(paramName));
	        }
	        util_1.createPureProxy(o.fn(proxyParams, [new o.ReturnStatement(o.literalArr(proxyReturnEntries))]), values.length, proxyExpr, this);
	        return proxyExpr.callFn(values);
	    };
	    CompileView.prototype.createLiteralMap = function (entries) {
	        if (entries.length === 0) {
	            return o.importExpr(identifiers_1.Identifiers.EMPTY_MAP);
	        }
	        var proxyExpr = o.THIS_EXPR.prop("_map_" + this.literalMapCount++);
	        var proxyParams = [];
	        var proxyReturnEntries = [];
	        var values = [];
	        for (var i = 0; i < entries.length; i++) {
	            var paramName = "p" + i;
	            proxyParams.push(new o.FnParam(paramName));
	            proxyReturnEntries.push([entries[i][0], o.variable(paramName)]);
	            values.push(entries[i][1]);
	        }
	        util_1.createPureProxy(o.fn(proxyParams, [new o.ReturnStatement(o.literalMap(proxyReturnEntries))]), entries.length, proxyExpr, this);
	        return proxyExpr.callFn(values);
	    };
	    CompileView.prototype.afterNodes = function () {
	        var _this = this;
	        this.pipes.forEach(function (pipe) { return pipe.create(); });
	        this.viewQueries.values().forEach(function (queries) { return queries.forEach(function (query) { return query.afterChildren(_this.updateViewQueriesMethod); }); });
	    };
	    return CompileView;
	}());
	exports.CompileView = CompileView;
	function getViewType(component, embeddedTemplateIndex) {
	    if (embeddedTemplateIndex > 0) {
	        return view_type_1.ViewType.EMBEDDED;
	    }
	    else if (component.type.isHost) {
	        return view_type_1.ViewType.HOST;
	    }
	    else {
	        return view_type_1.ViewType.COMPONENT;
	    }
	}


/***/ },
/* 177 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var o = __webpack_require__(166);
	var identifiers_1 = __webpack_require__(156);
	var util_1 = __webpack_require__(173);
	var _PurePipeProxy = (function () {
	    function _PurePipeProxy(instance, argCount) {
	        this.instance = instance;
	        this.argCount = argCount;
	    }
	    return _PurePipeProxy;
	}());
	var CompilePipe = (function () {
	    function CompilePipe(view, name) {
	        this.view = view;
	        this._purePipeProxies = [];
	        this.meta = _findPipeMeta(view, name);
	        this.instance = o.THIS_EXPR.prop("_pipe_" + name + "_" + view.pipeCount++);
	    }
	    Object.defineProperty(CompilePipe.prototype, "pure", {
	        get: function () { return this.meta.pure; },
	        enumerable: true,
	        configurable: true
	    });
	    CompilePipe.prototype.create = function () {
	        var _this = this;
	        var deps = this.meta.type.diDeps.map(function (diDep) {
	            if (diDep.token.equalsTo(identifiers_1.identifierToken(identifiers_1.Identifiers.ChangeDetectorRef))) {
	                return util_1.getPropertyInView(o.THIS_EXPR.prop('ref'), _this.view, _this.view.componentView);
	            }
	            return util_1.injectFromViewParentInjector(diDep.token, false);
	        });
	        this.view.fields.push(new o.ClassField(this.instance.name, o.importType(this.meta.type)));
	        this.view.createMethod.resetDebugInfo(null, null);
	        this.view.createMethod.addStmt(o.THIS_EXPR.prop(this.instance.name)
	            .set(o.importExpr(this.meta.type).instantiate(deps))
	            .toStmt());
	        this._purePipeProxies.forEach(function (purePipeProxy) {
	            util_1.createPureProxy(_this.instance.prop('transform').callMethod(o.BuiltinMethod.bind, [_this.instance]), purePipeProxy.argCount, purePipeProxy.instance, _this.view);
	        });
	    };
	    CompilePipe.prototype.call = function (callingView, args) {
	        if (this.meta.pure) {
	            var purePipeProxy = new _PurePipeProxy(o.THIS_EXPR.prop(this.instance.name + "_" + this._purePipeProxies.length), args.length);
	            this._purePipeProxies.push(purePipeProxy);
	            return util_1.getPropertyInView(o.importExpr(identifiers_1.Identifiers.castByValue)
	                .callFn([purePipeProxy.instance, this.instance.prop('transform')]), callingView, this.view)
	                .callFn(args);
	        }
	        else {
	            return util_1.getPropertyInView(this.instance, callingView, this.view).callMethod('transform', args);
	        }
	    };
	    return CompilePipe;
	}());
	exports.CompilePipe = CompilePipe;
	function _findPipeMeta(view, name) {
	    var pipeMeta = null;
	    for (var i = view.pipeMetas.length - 1; i >= 0; i--) {
	        var localPipeMeta = view.pipeMetas[i];
	        if (localPipeMeta.name == name) {
	            pipeMeta = localPipeMeta;
	            break;
	        }
	    }
	    if (lang_1.isBlank(pipeMeta)) {
	        throw new exceptions_1.BaseException("Illegal state: Could not find pipe " + name + " although the parser should have detected this error!");
	    }
	    return pipeMeta;
	}


/***/ },
/* 178 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var o = __webpack_require__(166);
	var identifiers_1 = __webpack_require__(156);
	var constants_1 = __webpack_require__(172);
	var change_detection_1 = __webpack_require__(29);
	var compile_view_1 = __webpack_require__(176);
	var compile_element_1 = __webpack_require__(171);
	var template_ast_1 = __webpack_require__(141);
	var util_1 = __webpack_require__(173);
	var view_type_1 = __webpack_require__(70);
	var view_1 = __webpack_require__(37);
	var compile_metadata_1 = __webpack_require__(157);
	var IMPLICIT_TEMPLATE_VAR = '\$implicit';
	var CLASS_ATTR = 'class';
	var STYLE_ATTR = 'style';
	var parentRenderNodeVar = o.variable('parentRenderNode');
	var rootSelectorVar = o.variable('rootSelector');
	var ViewCompileDependency = (function () {
	    function ViewCompileDependency(comp, factoryPlaceholder) {
	        this.comp = comp;
	        this.factoryPlaceholder = factoryPlaceholder;
	    }
	    return ViewCompileDependency;
	}());
	exports.ViewCompileDependency = ViewCompileDependency;
	function buildView(view, template, targetDependencies) {
	    var builderVisitor = new ViewBuilderVisitor(view, targetDependencies);
	    template_ast_1.templateVisitAll(builderVisitor, template, view.declarationElement.isNull() ?
	        view.declarationElement :
	        view.declarationElement.parent);
	    return builderVisitor.nestedViewCount;
	}
	exports.buildView = buildView;
	function finishView(view, targetStatements) {
	    view.afterNodes();
	    createViewTopLevelStmts(view, targetStatements);
	    view.nodes.forEach(function (node) {
	        if (node instanceof compile_element_1.CompileElement && node.hasEmbeddedView) {
	            finishView(node.embeddedView, targetStatements);
	        }
	    });
	}
	exports.finishView = finishView;
	var ViewBuilderVisitor = (function () {
	    function ViewBuilderVisitor(view, targetDependencies) {
	        this.view = view;
	        this.targetDependencies = targetDependencies;
	        this.nestedViewCount = 0;
	    }
	    ViewBuilderVisitor.prototype._isRootNode = function (parent) { return parent.view !== this.view; };
	    ViewBuilderVisitor.prototype._addRootNodeAndProject = function (node, ngContentIndex, parent) {
	        var vcAppEl = (node instanceof compile_element_1.CompileElement && node.hasViewContainer) ? node.appElement : null;
	        if (this._isRootNode(parent)) {
	            // store appElement as root node only for ViewContainers
	            if (this.view.viewType !== view_type_1.ViewType.COMPONENT) {
	                this.view.rootNodesOrAppElements.push(lang_1.isPresent(vcAppEl) ? vcAppEl : node.renderNode);
	            }
	        }
	        else if (lang_1.isPresent(parent.component) && lang_1.isPresent(ngContentIndex)) {
	            parent.addContentNode(ngContentIndex, lang_1.isPresent(vcAppEl) ? vcAppEl : node.renderNode);
	        }
	    };
	    ViewBuilderVisitor.prototype._getParentRenderNode = function (parent) {
	        if (this._isRootNode(parent)) {
	            if (this.view.viewType === view_type_1.ViewType.COMPONENT) {
	                return parentRenderNodeVar;
	            }
	            else {
	                // root node of an embedded/host view
	                return o.NULL_EXPR;
	            }
	        }
	        else {
	            return lang_1.isPresent(parent.component) &&
	                parent.component.template.encapsulation !== view_1.ViewEncapsulation.Native ?
	                o.NULL_EXPR :
	                parent.renderNode;
	        }
	    };
	    ViewBuilderVisitor.prototype.visitBoundText = function (ast, parent) {
	        return this._visitText(ast, '', ast.ngContentIndex, parent);
	    };
	    ViewBuilderVisitor.prototype.visitText = function (ast, parent) {
	        return this._visitText(ast, ast.value, ast.ngContentIndex, parent);
	    };
	    ViewBuilderVisitor.prototype._visitText = function (ast, value, ngContentIndex, parent) {
	        var fieldName = "_text_" + this.view.nodes.length;
	        this.view.fields.push(new o.ClassField(fieldName, o.importType(this.view.genConfig.renderTypes.renderText)));
	        var renderNode = o.THIS_EXPR.prop(fieldName);
	        var compileNode = new compile_element_1.CompileNode(parent, this.view, this.view.nodes.length, renderNode, ast);
	        var createRenderNode = o.THIS_EXPR.prop(fieldName)
	            .set(constants_1.ViewProperties.renderer.callMethod('createText', [
	            this._getParentRenderNode(parent),
	            o.literal(value),
	            this.view.createMethod.resetDebugInfoExpr(this.view.nodes.length, ast)
	        ]))
	            .toStmt();
	        this.view.nodes.push(compileNode);
	        this.view.createMethod.addStmt(createRenderNode);
	        this._addRootNodeAndProject(compileNode, ngContentIndex, parent);
	        return renderNode;
	    };
	    ViewBuilderVisitor.prototype.visitNgContent = function (ast, parent) {
	        // the projected nodes originate from a different view, so we don't
	        // have debug information for them...
	        this.view.createMethod.resetDebugInfo(null, ast);
	        var parentRenderNode = this._getParentRenderNode(parent);
	        var nodesExpression = constants_1.ViewProperties.projectableNodes.key(o.literal(ast.index), new o.ArrayType(o.importType(this.view.genConfig.renderTypes.renderNode)));
	        if (parentRenderNode !== o.NULL_EXPR) {
	            this.view.createMethod.addStmt(constants_1.ViewProperties.renderer.callMethod('projectNodes', [
	                parentRenderNode,
	                o.importExpr(identifiers_1.Identifiers.flattenNestedViewRenderNodes)
	                    .callFn([nodesExpression])
	            ])
	                .toStmt());
	        }
	        else if (this._isRootNode(parent)) {
	            if (this.view.viewType !== view_type_1.ViewType.COMPONENT) {
	                // store root nodes only for embedded/host views
	                this.view.rootNodesOrAppElements.push(nodesExpression);
	            }
	        }
	        else {
	            if (lang_1.isPresent(parent.component) && lang_1.isPresent(ast.ngContentIndex)) {
	                parent.addContentNode(ast.ngContentIndex, nodesExpression);
	            }
	        }
	        return null;
	    };
	    ViewBuilderVisitor.prototype.visitElement = function (ast, parent) {
	        var nodeIndex = this.view.nodes.length;
	        var createRenderNodeExpr;
	        var debugContextExpr = this.view.createMethod.resetDebugInfoExpr(nodeIndex, ast);
	        if (nodeIndex === 0 && this.view.viewType === view_type_1.ViewType.HOST) {
	            createRenderNodeExpr = o.THIS_EXPR.callMethod('selectOrCreateHostElement', [o.literal(ast.name), rootSelectorVar, debugContextExpr]);
	        }
	        else {
	            createRenderNodeExpr = constants_1.ViewProperties.renderer.callMethod('createElement', [this._getParentRenderNode(parent), o.literal(ast.name), debugContextExpr]);
	        }
	        var fieldName = "_el_" + nodeIndex;
	        this.view.fields.push(new o.ClassField(fieldName, o.importType(this.view.genConfig.renderTypes.renderElement)));
	        this.view.createMethod.addStmt(o.THIS_EXPR.prop(fieldName).set(createRenderNodeExpr).toStmt());
	        var renderNode = o.THIS_EXPR.prop(fieldName);
	        var directives = ast.directives.map(function (directiveAst) { return directiveAst.directive; });
	        var component = directives.find(function (directive) { return directive.isComponent; });
	        var htmlAttrs = _readHtmlAttrs(ast.attrs);
	        var attrNameAndValues = _mergeHtmlAndDirectiveAttrs(htmlAttrs, directives);
	        for (var i = 0; i < attrNameAndValues.length; i++) {
	            var attrName = attrNameAndValues[i][0];
	            var attrValue = attrNameAndValues[i][1];
	            this.view.createMethod.addStmt(constants_1.ViewProperties.renderer.callMethod('setElementAttribute', [renderNode, o.literal(attrName), o.literal(attrValue)])
	                .toStmt());
	        }
	        var compileElement = new compile_element_1.CompileElement(parent, this.view, nodeIndex, renderNode, ast, component, directives, ast.providers, ast.hasViewContainer, false, ast.references);
	        this.view.nodes.push(compileElement);
	        var compViewExpr = null;
	        if (lang_1.isPresent(component)) {
	            var nestedComponentIdentifier = new compile_metadata_1.CompileIdentifierMetadata({ name: util_1.getViewFactoryName(component, 0) });
	            this.targetDependencies.push(new ViewCompileDependency(component, nestedComponentIdentifier));
	            compViewExpr = o.variable("compView_" + nodeIndex);
	            compileElement.setComponentView(compViewExpr);
	            this.view.createMethod.addStmt(compViewExpr.set(o.importExpr(nestedComponentIdentifier)
	                .callFn([
	                constants_1.ViewProperties.viewUtils,
	                compileElement.injector,
	                compileElement.appElement
	            ]))
	                .toDeclStmt());
	        }
	        compileElement.beforeChildren();
	        this._addRootNodeAndProject(compileElement, ast.ngContentIndex, parent);
	        template_ast_1.templateVisitAll(this, ast.children, compileElement);
	        compileElement.afterChildren(this.view.nodes.length - nodeIndex - 1);
	        if (lang_1.isPresent(compViewExpr)) {
	            var codeGenContentNodes;
	            if (this.view.component.type.isHost) {
	                codeGenContentNodes = constants_1.ViewProperties.projectableNodes;
	            }
	            else {
	                codeGenContentNodes = o.literalArr(compileElement.contentNodesByNgContentIndex.map(function (nodes) { return util_1.createFlatArray(nodes); }));
	            }
	            this.view.createMethod.addStmt(compViewExpr.callMethod('create', [compileElement.getComponent(), codeGenContentNodes, o.NULL_EXPR])
	                .toStmt());
	        }
	        return null;
	    };
	    ViewBuilderVisitor.prototype.visitEmbeddedTemplate = function (ast, parent) {
	        var nodeIndex = this.view.nodes.length;
	        var fieldName = "_anchor_" + nodeIndex;
	        this.view.fields.push(new o.ClassField(fieldName, o.importType(this.view.genConfig.renderTypes.renderComment)));
	        this.view.createMethod.addStmt(o.THIS_EXPR.prop(fieldName)
	            .set(constants_1.ViewProperties.renderer.callMethod('createTemplateAnchor', [
	            this._getParentRenderNode(parent),
	            this.view.createMethod.resetDebugInfoExpr(nodeIndex, ast)
	        ]))
	            .toStmt());
	        var renderNode = o.THIS_EXPR.prop(fieldName);
	        var templateVariableBindings = ast.variables.map(function (varAst) { return [varAst.value.length > 0 ? varAst.value : IMPLICIT_TEMPLATE_VAR, varAst.name]; });
	        var directives = ast.directives.map(function (directiveAst) { return directiveAst.directive; });
	        var compileElement = new compile_element_1.CompileElement(parent, this.view, nodeIndex, renderNode, ast, null, directives, ast.providers, ast.hasViewContainer, true, ast.references);
	        this.view.nodes.push(compileElement);
	        this.nestedViewCount++;
	        var embeddedView = new compile_view_1.CompileView(this.view.component, this.view.genConfig, this.view.pipeMetas, o.NULL_EXPR, this.view.viewIndex + this.nestedViewCount, compileElement, templateVariableBindings);
	        this.nestedViewCount += buildView(embeddedView, ast.children, this.targetDependencies);
	        compileElement.beforeChildren();
	        this._addRootNodeAndProject(compileElement, ast.ngContentIndex, parent);
	        compileElement.afterChildren(0);
	        return null;
	    };
	    ViewBuilderVisitor.prototype.visitAttr = function (ast, ctx) { return null; };
	    ViewBuilderVisitor.prototype.visitDirective = function (ast, ctx) { return null; };
	    ViewBuilderVisitor.prototype.visitEvent = function (ast, eventTargetAndNames) {
	        return null;
	    };
	    ViewBuilderVisitor.prototype.visitReference = function (ast, ctx) { return null; };
	    ViewBuilderVisitor.prototype.visitVariable = function (ast, ctx) { return null; };
	    ViewBuilderVisitor.prototype.visitDirectiveProperty = function (ast, context) { return null; };
	    ViewBuilderVisitor.prototype.visitElementProperty = function (ast, context) { return null; };
	    return ViewBuilderVisitor;
	}());
	function _mergeHtmlAndDirectiveAttrs(declaredHtmlAttrs, directives) {
	    var result = {};
	    collection_1.StringMapWrapper.forEach(declaredHtmlAttrs, function (value, key) { result[key] = value; });
	    directives.forEach(function (directiveMeta) {
	        collection_1.StringMapWrapper.forEach(directiveMeta.hostAttributes, function (value, name) {
	            var prevValue = result[name];
	            result[name] = lang_1.isPresent(prevValue) ? mergeAttributeValue(name, prevValue, value) : value;
	        });
	    });
	    return mapToKeyValueArray(result);
	}
	function _readHtmlAttrs(attrs) {
	    var htmlAttrs = {};
	    attrs.forEach(function (ast) { htmlAttrs[ast.name] = ast.value; });
	    return htmlAttrs;
	}
	function mergeAttributeValue(attrName, attrValue1, attrValue2) {
	    if (attrName == CLASS_ATTR || attrName == STYLE_ATTR) {
	        return attrValue1 + " " + attrValue2;
	    }
	    else {
	        return attrValue2;
	    }
	}
	function mapToKeyValueArray(data) {
	    var entryArray = [];
	    collection_1.StringMapWrapper.forEach(data, function (value, name) { entryArray.push([name, value]); });
	    // We need to sort to get a defined output order
	    // for tests and for caching generated artifacts...
	    collection_1.ListWrapper.sort(entryArray, function (entry1, entry2) { return lang_1.StringWrapper.compare(entry1[0], entry2[0]); });
	    var keyValueArray = [];
	    entryArray.forEach(function (entry) { keyValueArray.push([entry[0], entry[1]]); });
	    return keyValueArray;
	}
	function createViewTopLevelStmts(view, targetStatements) {
	    var nodeDebugInfosVar = o.NULL_EXPR;
	    if (view.genConfig.genDebugInfo) {
	        nodeDebugInfosVar = o.variable("nodeDebugInfos_" + view.component.type.name + view.viewIndex);
	        targetStatements.push(nodeDebugInfosVar
	            .set(o.literalArr(view.nodes.map(createStaticNodeDebugInfo), new o.ArrayType(new o.ExternalType(identifiers_1.Identifiers.StaticNodeDebugInfo), [o.TypeModifier.Const])))
	            .toDeclStmt(null, [o.StmtModifier.Final]));
	    }
	    var renderCompTypeVar = o.variable("renderType_" + view.component.type.name);
	    if (view.viewIndex === 0) {
	        targetStatements.push(renderCompTypeVar.set(o.NULL_EXPR)
	            .toDeclStmt(o.importType(identifiers_1.Identifiers.RenderComponentType)));
	    }
	    var viewClass = createViewClass(view, renderCompTypeVar, nodeDebugInfosVar);
	    targetStatements.push(viewClass);
	    targetStatements.push(createViewFactory(view, viewClass, renderCompTypeVar));
	}
	function createStaticNodeDebugInfo(node) {
	    var compileElement = node instanceof compile_element_1.CompileElement ? node : null;
	    var providerTokens = [];
	    var componentToken = o.NULL_EXPR;
	    var varTokenEntries = [];
	    if (lang_1.isPresent(compileElement)) {
	        providerTokens = compileElement.getProviderTokens();
	        if (lang_1.isPresent(compileElement.component)) {
	            componentToken = util_1.createDiTokenExpression(identifiers_1.identifierToken(compileElement.component.type));
	        }
	        collection_1.StringMapWrapper.forEach(compileElement.referenceTokens, function (token, varName) {
	            varTokenEntries.push([varName, lang_1.isPresent(token) ? util_1.createDiTokenExpression(token) : o.NULL_EXPR]);
	        });
	    }
	    return o.importExpr(identifiers_1.Identifiers.StaticNodeDebugInfo)
	        .instantiate([
	        o.literalArr(providerTokens, new o.ArrayType(o.DYNAMIC_TYPE, [o.TypeModifier.Const])),
	        componentToken,
	        o.literalMap(varTokenEntries, new o.MapType(o.DYNAMIC_TYPE, [o.TypeModifier.Const]))
	    ], o.importType(identifiers_1.Identifiers.StaticNodeDebugInfo, null, [o.TypeModifier.Const]));
	}
	function createViewClass(view, renderCompTypeVar, nodeDebugInfosVar) {
	    var viewConstructorArgs = [
	        new o.FnParam(constants_1.ViewConstructorVars.viewUtils.name, o.importType(identifiers_1.Identifiers.ViewUtils)),
	        new o.FnParam(constants_1.ViewConstructorVars.parentInjector.name, o.importType(identifiers_1.Identifiers.Injector)),
	        new o.FnParam(constants_1.ViewConstructorVars.declarationEl.name, o.importType(identifiers_1.Identifiers.AppElement))
	    ];
	    var superConstructorArgs = [
	        o.variable(view.className),
	        renderCompTypeVar,
	        constants_1.ViewTypeEnum.fromValue(view.viewType),
	        constants_1.ViewConstructorVars.viewUtils,
	        constants_1.ViewConstructorVars.parentInjector,
	        constants_1.ViewConstructorVars.declarationEl,
	        constants_1.ChangeDetectionStrategyEnum.fromValue(getChangeDetectionMode(view))
	    ];
	    if (view.genConfig.genDebugInfo) {
	        superConstructorArgs.push(nodeDebugInfosVar);
	    }
	    var viewConstructor = new o.ClassMethod(null, viewConstructorArgs, [o.SUPER_EXPR.callFn(superConstructorArgs).toStmt()]);
	    var viewMethods = [
	        new o.ClassMethod('createInternal', [new o.FnParam(rootSelectorVar.name, o.STRING_TYPE)], generateCreateMethod(view), o.importType(identifiers_1.Identifiers.AppElement)),
	        new o.ClassMethod('injectorGetInternal', [
	            new o.FnParam(constants_1.InjectMethodVars.token.name, o.DYNAMIC_TYPE),
	            // Note: Can't use o.INT_TYPE here as the method in AppView uses number
	            new o.FnParam(constants_1.InjectMethodVars.requestNodeIndex.name, o.NUMBER_TYPE),
	            new o.FnParam(constants_1.InjectMethodVars.notFoundResult.name, o.DYNAMIC_TYPE)
	        ], addReturnValuefNotEmpty(view.injectorGetMethod.finish(), constants_1.InjectMethodVars.notFoundResult), o.DYNAMIC_TYPE),
	        new o.ClassMethod('detectChangesInternal', [new o.FnParam(constants_1.DetectChangesVars.throwOnChange.name, o.BOOL_TYPE)], generateDetectChangesMethod(view)),
	        new o.ClassMethod('dirtyParentQueriesInternal', [], view.dirtyParentQueriesMethod.finish()),
	        new o.ClassMethod('destroyInternal', [], view.destroyMethod.finish())
	    ].concat(view.eventHandlerMethods);
	    var superClass = view.genConfig.genDebugInfo ? identifiers_1.Identifiers.DebugAppView : identifiers_1.Identifiers.AppView;
	    var viewClass = new o.ClassStmt(view.className, o.importExpr(superClass, [getContextType(view)]), view.fields, view.getters, viewConstructor, viewMethods.filter(function (method) { return method.body.length > 0; }));
	    return viewClass;
	}
	function createViewFactory(view, viewClass, renderCompTypeVar) {
	    var viewFactoryArgs = [
	        new o.FnParam(constants_1.ViewConstructorVars.viewUtils.name, o.importType(identifiers_1.Identifiers.ViewUtils)),
	        new o.FnParam(constants_1.ViewConstructorVars.parentInjector.name, o.importType(identifiers_1.Identifiers.Injector)),
	        new o.FnParam(constants_1.ViewConstructorVars.declarationEl.name, o.importType(identifiers_1.Identifiers.AppElement))
	    ];
	    var initRenderCompTypeStmts = [];
	    var templateUrlInfo;
	    if (view.component.template.templateUrl == view.component.type.moduleUrl) {
	        templateUrlInfo =
	            view.component.type.moduleUrl + " class " + view.component.type.name + " - inline template";
	    }
	    else {
	        templateUrlInfo = view.component.template.templateUrl;
	    }
	    if (view.viewIndex === 0) {
	        initRenderCompTypeStmts = [
	            new o.IfStmt(renderCompTypeVar.identical(o.NULL_EXPR), [
	                renderCompTypeVar.set(constants_1.ViewConstructorVars
	                    .viewUtils.callMethod('createRenderComponentType', [
	                    o.literal(templateUrlInfo),
	                    o.literal(view.component
	                        .template.ngContentSelectors.length),
	                    constants_1.ViewEncapsulationEnum
	                        .fromValue(view.component.template.encapsulation),
	                    view.styles
	                ]))
	                    .toStmt()
	            ])
	        ];
	    }
	    return o.fn(viewFactoryArgs, initRenderCompTypeStmts.concat([
	        new o.ReturnStatement(o.variable(viewClass.name)
	            .instantiate(viewClass.constructorMethod.params.map(function (param) { return o.variable(param.name); })))
	    ]), o.importType(identifiers_1.Identifiers.AppView, [getContextType(view)]))
	        .toDeclStmt(view.viewFactory.name, [o.StmtModifier.Final]);
	}
	function generateCreateMethod(view) {
	    var parentRenderNodeExpr = o.NULL_EXPR;
	    var parentRenderNodeStmts = [];
	    if (view.viewType === view_type_1.ViewType.COMPONENT) {
	        parentRenderNodeExpr = constants_1.ViewProperties.renderer.callMethod('createViewRoot', [o.THIS_EXPR.prop('declarationAppElement').prop('nativeElement')]);
	        parentRenderNodeStmts = [
	            parentRenderNodeVar.set(parentRenderNodeExpr)
	                .toDeclStmt(o.importType(view.genConfig.renderTypes.renderNode), [o.StmtModifier.Final])
	        ];
	    }
	    var resultExpr;
	    if (view.viewType === view_type_1.ViewType.HOST) {
	        resultExpr = view.nodes[0].appElement;
	    }
	    else {
	        resultExpr = o.NULL_EXPR;
	    }
	    return parentRenderNodeStmts.concat(view.createMethod.finish())
	        .concat([
	        o.THIS_EXPR.callMethod('init', [
	            util_1.createFlatArray(view.rootNodesOrAppElements),
	            o.literalArr(view.nodes.map(function (node) { return node.renderNode; })),
	            o.literalArr(view.disposables),
	            o.literalArr(view.subscriptions)
	        ])
	            .toStmt(),
	        new o.ReturnStatement(resultExpr)
	    ]);
	}
	function generateDetectChangesMethod(view) {
	    var stmts = [];
	    if (view.detectChangesInInputsMethod.isEmpty() && view.updateContentQueriesMethod.isEmpty() &&
	        view.afterContentLifecycleCallbacksMethod.isEmpty() &&
	        view.detectChangesRenderPropertiesMethod.isEmpty() &&
	        view.updateViewQueriesMethod.isEmpty() && view.afterViewLifecycleCallbacksMethod.isEmpty()) {
	        return stmts;
	    }
	    collection_1.ListWrapper.addAll(stmts, view.detectChangesInInputsMethod.finish());
	    stmts.push(o.THIS_EXPR.callMethod('detectContentChildrenChanges', [constants_1.DetectChangesVars.throwOnChange])
	        .toStmt());
	    var afterContentStmts = view.updateContentQueriesMethod.finish().concat(view.afterContentLifecycleCallbacksMethod.finish());
	    if (afterContentStmts.length > 0) {
	        stmts.push(new o.IfStmt(o.not(constants_1.DetectChangesVars.throwOnChange), afterContentStmts));
	    }
	    collection_1.ListWrapper.addAll(stmts, view.detectChangesRenderPropertiesMethod.finish());
	    stmts.push(o.THIS_EXPR.callMethod('detectViewChildrenChanges', [constants_1.DetectChangesVars.throwOnChange])
	        .toStmt());
	    var afterViewStmts = view.updateViewQueriesMethod.finish().concat(view.afterViewLifecycleCallbacksMethod.finish());
	    if (afterViewStmts.length > 0) {
	        stmts.push(new o.IfStmt(o.not(constants_1.DetectChangesVars.throwOnChange), afterViewStmts));
	    }
	    var varStmts = [];
	    var readVars = o.findReadVarNames(stmts);
	    if (collection_1.SetWrapper.has(readVars, constants_1.DetectChangesVars.changed.name)) {
	        varStmts.push(constants_1.DetectChangesVars.changed.set(o.literal(true)).toDeclStmt(o.BOOL_TYPE));
	    }
	    if (collection_1.SetWrapper.has(readVars, constants_1.DetectChangesVars.changes.name)) {
	        varStmts.push(constants_1.DetectChangesVars.changes.set(o.NULL_EXPR)
	            .toDeclStmt(new o.MapType(o.importType(identifiers_1.Identifiers.SimpleChange))));
	    }
	    if (collection_1.SetWrapper.has(readVars, constants_1.DetectChangesVars.valUnwrapper.name)) {
	        varStmts.push(constants_1.DetectChangesVars.valUnwrapper.set(o.importExpr(identifiers_1.Identifiers.ValueUnwrapper).instantiate([]))
	            .toDeclStmt(null, [o.StmtModifier.Final]));
	    }
	    return varStmts.concat(stmts);
	}
	function addReturnValuefNotEmpty(statements, value) {
	    if (statements.length > 0) {
	        return statements.concat([new o.ReturnStatement(value)]);
	    }
	    else {
	        return statements;
	    }
	}
	function getContextType(view) {
	    if (view.viewType === view_type_1.ViewType.COMPONENT) {
	        return o.importType(view.component.type);
	    }
	    return o.DYNAMIC_TYPE;
	}
	function getChangeDetectionMode(view) {
	    var mode;
	    if (view.viewType === view_type_1.ViewType.COMPONENT) {
	        mode = change_detection_1.isDefaultChangeDetectionStrategy(view.component.changeDetection) ?
	            change_detection_1.ChangeDetectionStrategy.CheckAlways :
	            change_detection_1.ChangeDetectionStrategy.CheckOnce;
	    }
	    else {
	        mode = change_detection_1.ChangeDetectionStrategy.CheckAlways;
	    }
	    return mode;
	}


/***/ },
/* 179 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var collection_1 = __webpack_require__(15);
	var template_ast_1 = __webpack_require__(141);
	var property_binder_1 = __webpack_require__(180);
	var event_binder_1 = __webpack_require__(183);
	var lifecycle_binder_1 = __webpack_require__(184);
	function bindView(view, parsedTemplate) {
	    var visitor = new ViewBinderVisitor(view);
	    template_ast_1.templateVisitAll(visitor, parsedTemplate);
	    view.pipes.forEach(function (pipe) { lifecycle_binder_1.bindPipeDestroyLifecycleCallbacks(pipe.meta, pipe.instance, pipe.view); });
	}
	exports.bindView = bindView;
	var ViewBinderVisitor = (function () {
	    function ViewBinderVisitor(view) {
	        this.view = view;
	        this._nodeIndex = 0;
	    }
	    ViewBinderVisitor.prototype.visitBoundText = function (ast, parent) {
	        var node = this.view.nodes[this._nodeIndex++];
	        property_binder_1.bindRenderText(ast, node, this.view);
	        return null;
	    };
	    ViewBinderVisitor.prototype.visitText = function (ast, parent) {
	        this._nodeIndex++;
	        return null;
	    };
	    ViewBinderVisitor.prototype.visitNgContent = function (ast, parent) { return null; };
	    ViewBinderVisitor.prototype.visitElement = function (ast, parent) {
	        var compileElement = this.view.nodes[this._nodeIndex++];
	        var eventListeners = event_binder_1.collectEventListeners(ast.outputs, ast.directives, compileElement);
	        property_binder_1.bindRenderInputs(ast.inputs, compileElement);
	        event_binder_1.bindRenderOutputs(eventListeners);
	        collection_1.ListWrapper.forEachWithIndex(ast.directives, function (directiveAst, index) {
	            var directiveInstance = compileElement.directiveInstances[index];
	            property_binder_1.bindDirectiveInputs(directiveAst, directiveInstance, compileElement);
	            lifecycle_binder_1.bindDirectiveDetectChangesLifecycleCallbacks(directiveAst, directiveInstance, compileElement);
	            property_binder_1.bindDirectiveHostProps(directiveAst, directiveInstance, compileElement);
	            event_binder_1.bindDirectiveOutputs(directiveAst, directiveInstance, eventListeners);
	        });
	        template_ast_1.templateVisitAll(this, ast.children, compileElement);
	        // afterContent and afterView lifecycles need to be called bottom up
	        // so that children are notified before parents
	        collection_1.ListWrapper.forEachWithIndex(ast.directives, function (directiveAst, index) {
	            var directiveInstance = compileElement.directiveInstances[index];
	            lifecycle_binder_1.bindDirectiveAfterContentLifecycleCallbacks(directiveAst.directive, directiveInstance, compileElement);
	            lifecycle_binder_1.bindDirectiveAfterViewLifecycleCallbacks(directiveAst.directive, directiveInstance, compileElement);
	            lifecycle_binder_1.bindDirectiveDestroyLifecycleCallbacks(directiveAst.directive, directiveInstance, compileElement);
	        });
	        return null;
	    };
	    ViewBinderVisitor.prototype.visitEmbeddedTemplate = function (ast, parent) {
	        var compileElement = this.view.nodes[this._nodeIndex++];
	        var eventListeners = event_binder_1.collectEventListeners(ast.outputs, ast.directives, compileElement);
	        collection_1.ListWrapper.forEachWithIndex(ast.directives, function (directiveAst, index) {
	            var directiveInstance = compileElement.directiveInstances[index];
	            property_binder_1.bindDirectiveInputs(directiveAst, directiveInstance, compileElement);
	            lifecycle_binder_1.bindDirectiveDetectChangesLifecycleCallbacks(directiveAst, directiveInstance, compileElement);
	            event_binder_1.bindDirectiveOutputs(directiveAst, directiveInstance, eventListeners);
	            lifecycle_binder_1.bindDirectiveAfterContentLifecycleCallbacks(directiveAst.directive, directiveInstance, compileElement);
	            lifecycle_binder_1.bindDirectiveAfterViewLifecycleCallbacks(directiveAst.directive, directiveInstance, compileElement);
	            lifecycle_binder_1.bindDirectiveDestroyLifecycleCallbacks(directiveAst.directive, directiveInstance, compileElement);
	        });
	        bindView(compileElement.embeddedView, ast.children);
	        return null;
	    };
	    ViewBinderVisitor.prototype.visitAttr = function (ast, ctx) { return null; };
	    ViewBinderVisitor.prototype.visitDirective = function (ast, ctx) { return null; };
	    ViewBinderVisitor.prototype.visitEvent = function (ast, eventTargetAndNames) {
	        return null;
	    };
	    ViewBinderVisitor.prototype.visitReference = function (ast, ctx) { return null; };
	    ViewBinderVisitor.prototype.visitVariable = function (ast, ctx) { return null; };
	    ViewBinderVisitor.prototype.visitDirectiveProperty = function (ast, context) { return null; };
	    ViewBinderVisitor.prototype.visitElementProperty = function (ast, context) { return null; };
	    return ViewBinderVisitor;
	}());


/***/ },
/* 180 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var o = __webpack_require__(166);
	var identifiers_1 = __webpack_require__(156);
	var constants_1 = __webpack_require__(172);
	var template_ast_1 = __webpack_require__(141);
	var lang_1 = __webpack_require__(5);
	var lifecycle_hooks_1 = __webpack_require__(158);
	var constants_2 = __webpack_require__(34);
	var util_1 = __webpack_require__(155);
	var expression_converter_1 = __webpack_require__(181);
	var compile_binding_1 = __webpack_require__(182);
	function createBindFieldExpr(exprIndex) {
	    return o.THIS_EXPR.prop("_expr_" + exprIndex);
	}
	function createCurrValueExpr(exprIndex) {
	    return o.variable("currVal_" + exprIndex);
	}
	function bind(view, currValExpr, fieldExpr, parsedExpression, context, actions, method) {
	    var checkExpression = expression_converter_1.convertCdExpressionToIr(view, context, parsedExpression, constants_1.DetectChangesVars.valUnwrapper);
	    if (lang_1.isBlank(checkExpression.expression)) {
	        // e.g. an empty expression was given
	        return;
	    }
	    // private is fine here as no child view will reference the cached value...
	    view.fields.push(new o.ClassField(fieldExpr.name, null, [o.StmtModifier.Private]));
	    view.createMethod.addStmt(o.THIS_EXPR.prop(fieldExpr.name).set(o.importExpr(identifiers_1.Identifiers.uninitialized)).toStmt());
	    if (checkExpression.needsValueUnwrapper) {
	        var initValueUnwrapperStmt = constants_1.DetectChangesVars.valUnwrapper.callMethod('reset', []).toStmt();
	        method.addStmt(initValueUnwrapperStmt);
	    }
	    method.addStmt(currValExpr.set(checkExpression.expression).toDeclStmt(null, [o.StmtModifier.Final]));
	    var condition = o.importExpr(identifiers_1.Identifiers.checkBinding)
	        .callFn([constants_1.DetectChangesVars.throwOnChange, fieldExpr, currValExpr]);
	    if (checkExpression.needsValueUnwrapper) {
	        condition = constants_1.DetectChangesVars.valUnwrapper.prop('hasWrappedValue').or(condition);
	    }
	    method.addStmt(new o.IfStmt(condition, actions.concat([o.THIS_EXPR.prop(fieldExpr.name).set(currValExpr).toStmt()])));
	}
	function bindRenderText(boundText, compileNode, view) {
	    var bindingIndex = view.bindings.length;
	    view.bindings.push(new compile_binding_1.CompileBinding(compileNode, boundText));
	    var currValExpr = createCurrValueExpr(bindingIndex);
	    var valueField = createBindFieldExpr(bindingIndex);
	    view.detectChangesRenderPropertiesMethod.resetDebugInfo(compileNode.nodeIndex, boundText);
	    bind(view, currValExpr, valueField, boundText.value, view.componentContext, [
	        o.THIS_EXPR.prop('renderer')
	            .callMethod('setText', [compileNode.renderNode, currValExpr])
	            .toStmt()
	    ], view.detectChangesRenderPropertiesMethod);
	}
	exports.bindRenderText = bindRenderText;
	function bindAndWriteToRenderer(boundProps, context, compileElement) {
	    var view = compileElement.view;
	    var renderNode = compileElement.renderNode;
	    boundProps.forEach(function (boundProp) {
	        var bindingIndex = view.bindings.length;
	        view.bindings.push(new compile_binding_1.CompileBinding(compileElement, boundProp));
	        view.detectChangesRenderPropertiesMethod.resetDebugInfo(compileElement.nodeIndex, boundProp);
	        var fieldExpr = createBindFieldExpr(bindingIndex);
	        var currValExpr = createCurrValueExpr(bindingIndex);
	        var renderMethod;
	        var renderValue = currValExpr;
	        var updateStmts = [];
	        switch (boundProp.type) {
	            case template_ast_1.PropertyBindingType.Property:
	                renderMethod = 'setElementProperty';
	                if (view.genConfig.logBindingUpdate) {
	                    updateStmts.push(logBindingUpdateStmt(renderNode, boundProp.name, currValExpr));
	                }
	                break;
	            case template_ast_1.PropertyBindingType.Attribute:
	                renderMethod = 'setElementAttribute';
	                renderValue =
	                    renderValue.isBlank().conditional(o.NULL_EXPR, renderValue.callMethod('toString', []));
	                break;
	            case template_ast_1.PropertyBindingType.Class:
	                renderMethod = 'setElementClass';
	                break;
	            case template_ast_1.PropertyBindingType.Style:
	                renderMethod = 'setElementStyle';
	                var strValue = renderValue.callMethod('toString', []);
	                if (lang_1.isPresent(boundProp.unit)) {
	                    strValue = strValue.plus(o.literal(boundProp.unit));
	                }
	                renderValue = renderValue.isBlank().conditional(o.NULL_EXPR, strValue);
	                break;
	        }
	        updateStmts.push(o.THIS_EXPR.prop('renderer')
	            .callMethod(renderMethod, [renderNode, o.literal(boundProp.name), renderValue])
	            .toStmt());
	        bind(view, currValExpr, fieldExpr, boundProp.value, context, updateStmts, view.detectChangesRenderPropertiesMethod);
	    });
	}
	function bindRenderInputs(boundProps, compileElement) {
	    bindAndWriteToRenderer(boundProps, compileElement.view.componentContext, compileElement);
	}
	exports.bindRenderInputs = bindRenderInputs;
	function bindDirectiveHostProps(directiveAst, directiveInstance, compileElement) {
	    bindAndWriteToRenderer(directiveAst.hostProperties, directiveInstance, compileElement);
	}
	exports.bindDirectiveHostProps = bindDirectiveHostProps;
	function bindDirectiveInputs(directiveAst, directiveInstance, compileElement) {
	    if (directiveAst.inputs.length === 0) {
	        return;
	    }
	    var view = compileElement.view;
	    var detectChangesInInputsMethod = view.detectChangesInInputsMethod;
	    detectChangesInInputsMethod.resetDebugInfo(compileElement.nodeIndex, compileElement.sourceAst);
	    var lifecycleHooks = directiveAst.directive.lifecycleHooks;
	    var calcChangesMap = lifecycleHooks.indexOf(lifecycle_hooks_1.LifecycleHooks.OnChanges) !== -1;
	    var isOnPushComp = directiveAst.directive.isComponent &&
	        !constants_2.isDefaultChangeDetectionStrategy(directiveAst.directive.changeDetection);
	    if (calcChangesMap) {
	        detectChangesInInputsMethod.addStmt(constants_1.DetectChangesVars.changes.set(o.NULL_EXPR).toStmt());
	    }
	    if (isOnPushComp) {
	        detectChangesInInputsMethod.addStmt(constants_1.DetectChangesVars.changed.set(o.literal(false)).toStmt());
	    }
	    directiveAst.inputs.forEach(function (input) {
	        var bindingIndex = view.bindings.length;
	        view.bindings.push(new compile_binding_1.CompileBinding(compileElement, input));
	        detectChangesInInputsMethod.resetDebugInfo(compileElement.nodeIndex, input);
	        var fieldExpr = createBindFieldExpr(bindingIndex);
	        var currValExpr = createCurrValueExpr(bindingIndex);
	        var statements = [directiveInstance.prop(input.directiveName).set(currValExpr).toStmt()];
	        if (calcChangesMap) {
	            statements.push(new o.IfStmt(constants_1.DetectChangesVars.changes.identical(o.NULL_EXPR), [
	                constants_1.DetectChangesVars.changes.set(o.literalMap([], new o.MapType(o.importType(identifiers_1.Identifiers.SimpleChange))))
	                    .toStmt()
	            ]));
	            statements.push(constants_1.DetectChangesVars.changes.key(o.literal(input.directiveName))
	                .set(o.importExpr(identifiers_1.Identifiers.SimpleChange).instantiate([fieldExpr, currValExpr]))
	                .toStmt());
	        }
	        if (isOnPushComp) {
	            statements.push(constants_1.DetectChangesVars.changed.set(o.literal(true)).toStmt());
	        }
	        if (view.genConfig.logBindingUpdate) {
	            statements.push(logBindingUpdateStmt(compileElement.renderNode, input.directiveName, currValExpr));
	        }
	        bind(view, currValExpr, fieldExpr, input.value, view.componentContext, statements, detectChangesInInputsMethod);
	    });
	    if (isOnPushComp) {
	        detectChangesInInputsMethod.addStmt(new o.IfStmt(constants_1.DetectChangesVars.changed, [
	            compileElement.appElement.prop('componentView')
	                .callMethod('markAsCheckOnce', [])
	                .toStmt()
	        ]));
	    }
	}
	exports.bindDirectiveInputs = bindDirectiveInputs;
	function logBindingUpdateStmt(renderNode, propName, value) {
	    return o.THIS_EXPR.prop('renderer')
	        .callMethod('setBindingDebugInfo', [
	        renderNode,
	        o.literal("ng-reflect-" + util_1.camelCaseToDashCase(propName)),
	        value.isBlank().conditional(o.NULL_EXPR, value.callMethod('toString', []))
	    ])
	        .toStmt();
	}


/***/ },
/* 181 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var o = __webpack_require__(166);
	var identifiers_1 = __webpack_require__(156);
	var exceptions_1 = __webpack_require__(12);
	var lang_1 = __webpack_require__(5);
	var IMPLICIT_RECEIVER = o.variable('#implicit');
	var ExpressionWithWrappedValueInfo = (function () {
	    function ExpressionWithWrappedValueInfo(expression, needsValueUnwrapper) {
	        this.expression = expression;
	        this.needsValueUnwrapper = needsValueUnwrapper;
	    }
	    return ExpressionWithWrappedValueInfo;
	}());
	exports.ExpressionWithWrappedValueInfo = ExpressionWithWrappedValueInfo;
	function convertCdExpressionToIr(nameResolver, implicitReceiver, expression, valueUnwrapper) {
	    var visitor = new _AstToIrVisitor(nameResolver, implicitReceiver, valueUnwrapper);
	    var irAst = expression.visit(visitor, _Mode.Expression);
	    return new ExpressionWithWrappedValueInfo(irAst, visitor.needsValueUnwrapper);
	}
	exports.convertCdExpressionToIr = convertCdExpressionToIr;
	function convertCdStatementToIr(nameResolver, implicitReceiver, stmt) {
	    var visitor = new _AstToIrVisitor(nameResolver, implicitReceiver, null);
	    var statements = [];
	    flattenStatements(stmt.visit(visitor, _Mode.Statement), statements);
	    return statements;
	}
	exports.convertCdStatementToIr = convertCdStatementToIr;
	var _Mode;
	(function (_Mode) {
	    _Mode[_Mode["Statement"] = 0] = "Statement";
	    _Mode[_Mode["Expression"] = 1] = "Expression";
	})(_Mode || (_Mode = {}));
	function ensureStatementMode(mode, ast) {
	    if (mode !== _Mode.Statement) {
	        throw new exceptions_1.BaseException("Expected a statement, but saw " + ast);
	    }
	}
	function ensureExpressionMode(mode, ast) {
	    if (mode !== _Mode.Expression) {
	        throw new exceptions_1.BaseException("Expected an expression, but saw " + ast);
	    }
	}
	function convertToStatementIfNeeded(mode, expr) {
	    if (mode === _Mode.Statement) {
	        return expr.toStmt();
	    }
	    else {
	        return expr;
	    }
	}
	var _AstToIrVisitor = (function () {
	    function _AstToIrVisitor(_nameResolver, _implicitReceiver, _valueUnwrapper) {
	        this._nameResolver = _nameResolver;
	        this._implicitReceiver = _implicitReceiver;
	        this._valueUnwrapper = _valueUnwrapper;
	        this.needsValueUnwrapper = false;
	    }
	    _AstToIrVisitor.prototype.visitBinary = function (ast, mode) {
	        var op;
	        switch (ast.operation) {
	            case '+':
	                op = o.BinaryOperator.Plus;
	                break;
	            case '-':
	                op = o.BinaryOperator.Minus;
	                break;
	            case '*':
	                op = o.BinaryOperator.Multiply;
	                break;
	            case '/':
	                op = o.BinaryOperator.Divide;
	                break;
	            case '%':
	                op = o.BinaryOperator.Modulo;
	                break;
	            case '&&':
	                op = o.BinaryOperator.And;
	                break;
	            case '||':
	                op = o.BinaryOperator.Or;
	                break;
	            case '==':
	                op = o.BinaryOperator.Equals;
	                break;
	            case '!=':
	                op = o.BinaryOperator.NotEquals;
	                break;
	            case '===':
	                op = o.BinaryOperator.Identical;
	                break;
	            case '!==':
	                op = o.BinaryOperator.NotIdentical;
	                break;
	            case '<':
	                op = o.BinaryOperator.Lower;
	                break;
	            case '>':
	                op = o.BinaryOperator.Bigger;
	                break;
	            case '<=':
	                op = o.BinaryOperator.LowerEquals;
	                break;
	            case '>=':
	                op = o.BinaryOperator.BiggerEquals;
	                break;
	            default:
	                throw new exceptions_1.BaseException("Unsupported operation " + ast.operation);
	        }
	        return convertToStatementIfNeeded(mode, new o.BinaryOperatorExpr(op, ast.left.visit(this, _Mode.Expression), ast.right.visit(this, _Mode.Expression)));
	    };
	    _AstToIrVisitor.prototype.visitChain = function (ast, mode) {
	        ensureStatementMode(mode, ast);
	        return this.visitAll(ast.expressions, mode);
	    };
	    _AstToIrVisitor.prototype.visitConditional = function (ast, mode) {
	        var value = ast.condition.visit(this, _Mode.Expression);
	        return convertToStatementIfNeeded(mode, value.conditional(ast.trueExp.visit(this, _Mode.Expression), ast.falseExp.visit(this, _Mode.Expression)));
	    };
	    _AstToIrVisitor.prototype.visitPipe = function (ast, mode) {
	        var input = ast.exp.visit(this, _Mode.Expression);
	        var args = this.visitAll(ast.args, _Mode.Expression);
	        var value = this._nameResolver.callPipe(ast.name, input, args);
	        this.needsValueUnwrapper = true;
	        return convertToStatementIfNeeded(mode, this._valueUnwrapper.callMethod('unwrap', [value]));
	    };
	    _AstToIrVisitor.prototype.visitFunctionCall = function (ast, mode) {
	        return convertToStatementIfNeeded(mode, ast.target.visit(this, _Mode.Expression)
	            .callFn(this.visitAll(ast.args, _Mode.Expression)));
	    };
	    _AstToIrVisitor.prototype.visitImplicitReceiver = function (ast, mode) {
	        ensureExpressionMode(mode, ast);
	        return IMPLICIT_RECEIVER;
	    };
	    _AstToIrVisitor.prototype.visitInterpolation = function (ast, mode) {
	        ensureExpressionMode(mode, ast);
	        var args = [o.literal(ast.expressions.length)];
	        for (var i = 0; i < ast.strings.length - 1; i++) {
	            args.push(o.literal(ast.strings[i]));
	            args.push(ast.expressions[i].visit(this, _Mode.Expression));
	        }
	        args.push(o.literal(ast.strings[ast.strings.length - 1]));
	        return o.importExpr(identifiers_1.Identifiers.interpolate).callFn(args);
	    };
	    _AstToIrVisitor.prototype.visitKeyedRead = function (ast, mode) {
	        return convertToStatementIfNeeded(mode, ast.obj.visit(this, _Mode.Expression).key(ast.key.visit(this, _Mode.Expression)));
	    };
	    _AstToIrVisitor.prototype.visitKeyedWrite = function (ast, mode) {
	        var obj = ast.obj.visit(this, _Mode.Expression);
	        var key = ast.key.visit(this, _Mode.Expression);
	        var value = ast.value.visit(this, _Mode.Expression);
	        return convertToStatementIfNeeded(mode, obj.key(key).set(value));
	    };
	    _AstToIrVisitor.prototype.visitLiteralArray = function (ast, mode) {
	        return convertToStatementIfNeeded(mode, this._nameResolver.createLiteralArray(this.visitAll(ast.expressions, mode)));
	    };
	    _AstToIrVisitor.prototype.visitLiteralMap = function (ast, mode) {
	        var parts = [];
	        for (var i = 0; i < ast.keys.length; i++) {
	            parts.push([ast.keys[i], ast.values[i].visit(this, _Mode.Expression)]);
	        }
	        return convertToStatementIfNeeded(mode, this._nameResolver.createLiteralMap(parts));
	    };
	    _AstToIrVisitor.prototype.visitLiteralPrimitive = function (ast, mode) {
	        return convertToStatementIfNeeded(mode, o.literal(ast.value));
	    };
	    _AstToIrVisitor.prototype.visitMethodCall = function (ast, mode) {
	        var args = this.visitAll(ast.args, _Mode.Expression);
	        var result = null;
	        var receiver = ast.receiver.visit(this, _Mode.Expression);
	        if (receiver === IMPLICIT_RECEIVER) {
	            var varExpr = this._nameResolver.getLocal(ast.name);
	            if (lang_1.isPresent(varExpr)) {
	                result = varExpr.callFn(args);
	            }
	            else {
	                receiver = this._implicitReceiver;
	            }
	        }
	        if (lang_1.isBlank(result)) {
	            result = receiver.callMethod(ast.name, args);
	        }
	        return convertToStatementIfNeeded(mode, result);
	    };
	    _AstToIrVisitor.prototype.visitPrefixNot = function (ast, mode) {
	        return convertToStatementIfNeeded(mode, o.not(ast.expression.visit(this, _Mode.Expression)));
	    };
	    _AstToIrVisitor.prototype.visitPropertyRead = function (ast, mode) {
	        var result = null;
	        var receiver = ast.receiver.visit(this, _Mode.Expression);
	        if (receiver === IMPLICIT_RECEIVER) {
	            result = this._nameResolver.getLocal(ast.name);
	            if (lang_1.isBlank(result)) {
	                receiver = this._implicitReceiver;
	            }
	        }
	        if (lang_1.isBlank(result)) {
	            result = receiver.prop(ast.name);
	        }
	        return convertToStatementIfNeeded(mode, result);
	    };
	    _AstToIrVisitor.prototype.visitPropertyWrite = function (ast, mode) {
	        var receiver = ast.receiver.visit(this, _Mode.Expression);
	        if (receiver === IMPLICIT_RECEIVER) {
	            var varExpr = this._nameResolver.getLocal(ast.name);
	            if (lang_1.isPresent(varExpr)) {
	                throw new exceptions_1.BaseException('Cannot assign to a reference or variable!');
	            }
	            receiver = this._implicitReceiver;
	        }
	        return convertToStatementIfNeeded(mode, receiver.prop(ast.name).set(ast.value.visit(this, _Mode.Expression)));
	    };
	    _AstToIrVisitor.prototype.visitSafePropertyRead = function (ast, mode) {
	        var receiver = ast.receiver.visit(this, _Mode.Expression);
	        return convertToStatementIfNeeded(mode, receiver.isBlank().conditional(o.NULL_EXPR, receiver.prop(ast.name)));
	    };
	    _AstToIrVisitor.prototype.visitSafeMethodCall = function (ast, mode) {
	        var receiver = ast.receiver.visit(this, _Mode.Expression);
	        var args = this.visitAll(ast.args, _Mode.Expression);
	        return convertToStatementIfNeeded(mode, receiver.isBlank().conditional(o.NULL_EXPR, receiver.callMethod(ast.name, args)));
	    };
	    _AstToIrVisitor.prototype.visitAll = function (asts, mode) {
	        var _this = this;
	        return asts.map(function (ast) { return ast.visit(_this, mode); });
	    };
	    _AstToIrVisitor.prototype.visitQuote = function (ast, mode) {
	        throw new exceptions_1.BaseException('Quotes are not supported for evaluation!');
	    };
	    return _AstToIrVisitor;
	}());
	function flattenStatements(arg, output) {
	    if (lang_1.isArray(arg)) {
	        arg.forEach(function (entry) { return flattenStatements(entry, output); });
	    }
	    else {
	        output.push(arg);
	    }
	}


/***/ },
/* 182 */
/***/ function(module, exports) {

	"use strict";
	var CompileBinding = (function () {
	    function CompileBinding(node, sourceAst) {
	        this.node = node;
	        this.sourceAst = sourceAst;
	    }
	    return CompileBinding;
	}());
	exports.CompileBinding = CompileBinding;


/***/ },
/* 183 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var constants_1 = __webpack_require__(172);
	var o = __webpack_require__(166);
	var compile_method_1 = __webpack_require__(175);
	var expression_converter_1 = __webpack_require__(181);
	var compile_binding_1 = __webpack_require__(182);
	var CompileEventListener = (function () {
	    function CompileEventListener(compileElement, eventTarget, eventName, listenerIndex) {
	        this.compileElement = compileElement;
	        this.eventTarget = eventTarget;
	        this.eventName = eventName;
	        this._hasComponentHostListener = false;
	        this._actionResultExprs = [];
	        this._method = new compile_method_1.CompileMethod(compileElement.view);
	        this._methodName =
	            "_handle_" + santitizeEventName(eventName) + "_" + compileElement.nodeIndex + "_" + listenerIndex;
	        this._eventParam =
	            new o.FnParam(constants_1.EventHandlerVars.event.name, o.importType(this.compileElement.view.genConfig.renderTypes.renderEvent));
	    }
	    CompileEventListener.getOrCreate = function (compileElement, eventTarget, eventName, targetEventListeners) {
	        var listener = targetEventListeners.find(function (listener) { return listener.eventTarget == eventTarget &&
	            listener.eventName == eventName; });
	        if (lang_1.isBlank(listener)) {
	            listener = new CompileEventListener(compileElement, eventTarget, eventName, targetEventListeners.length);
	            targetEventListeners.push(listener);
	        }
	        return listener;
	    };
	    CompileEventListener.prototype.addAction = function (hostEvent, directive, directiveInstance) {
	        if (lang_1.isPresent(directive) && directive.isComponent) {
	            this._hasComponentHostListener = true;
	        }
	        this._method.resetDebugInfo(this.compileElement.nodeIndex, hostEvent);
	        var context = lang_1.isPresent(directiveInstance) ? directiveInstance :
	            this.compileElement.view.componentContext;
	        var actionStmts = expression_converter_1.convertCdStatementToIr(this.compileElement.view, context, hostEvent.handler);
	        var lastIndex = actionStmts.length - 1;
	        if (lastIndex >= 0) {
	            var lastStatement = actionStmts[lastIndex];
	            var returnExpr = convertStmtIntoExpression(lastStatement);
	            var preventDefaultVar = o.variable("pd_" + this._actionResultExprs.length);
	            this._actionResultExprs.push(preventDefaultVar);
	            if (lang_1.isPresent(returnExpr)) {
	                // Note: We need to cast the result of the method call to dynamic,
	                // as it might be a void method!
	                actionStmts[lastIndex] =
	                    preventDefaultVar.set(returnExpr.cast(o.DYNAMIC_TYPE).notIdentical(o.literal(false)))
	                        .toDeclStmt(null, [o.StmtModifier.Final]);
	            }
	        }
	        this._method.addStmts(actionStmts);
	    };
	    CompileEventListener.prototype.finishMethod = function () {
	        var markPathToRootStart = this._hasComponentHostListener ?
	            this.compileElement.appElement.prop('componentView') :
	            o.THIS_EXPR;
	        var resultExpr = o.literal(true);
	        this._actionResultExprs.forEach(function (expr) { resultExpr = resultExpr.and(expr); });
	        var stmts = [markPathToRootStart.callMethod('markPathToRootAsCheckOnce', []).toStmt()]
	            .concat(this._method.finish())
	            .concat([new o.ReturnStatement(resultExpr)]);
	        // private is fine here as no child view will reference the event handler...
	        this.compileElement.view.eventHandlerMethods.push(new o.ClassMethod(this._methodName, [this._eventParam], stmts, o.BOOL_TYPE, [o.StmtModifier.Private]));
	    };
	    CompileEventListener.prototype.listenToRenderer = function () {
	        var listenExpr;
	        var eventListener = o.THIS_EXPR.callMethod('eventHandler', [o.THIS_EXPR.prop(this._methodName).callMethod(o.BuiltinMethod.bind, [o.THIS_EXPR])]);
	        if (lang_1.isPresent(this.eventTarget)) {
	            listenExpr = constants_1.ViewProperties.renderer.callMethod('listenGlobal', [o.literal(this.eventTarget), o.literal(this.eventName), eventListener]);
	        }
	        else {
	            listenExpr = constants_1.ViewProperties.renderer.callMethod('listen', [this.compileElement.renderNode, o.literal(this.eventName), eventListener]);
	        }
	        var disposable = o.variable("disposable_" + this.compileElement.view.disposables.length);
	        this.compileElement.view.disposables.push(disposable);
	        // private is fine here as no child view will reference the event handler...
	        this.compileElement.view.createMethod.addStmt(disposable.set(listenExpr).toDeclStmt(o.FUNCTION_TYPE, [o.StmtModifier.Private]));
	    };
	    CompileEventListener.prototype.listenToDirective = function (directiveInstance, observablePropName) {
	        var subscription = o.variable("subscription_" + this.compileElement.view.subscriptions.length);
	        this.compileElement.view.subscriptions.push(subscription);
	        var eventListener = o.THIS_EXPR.callMethod('eventHandler', [o.THIS_EXPR.prop(this._methodName).callMethod(o.BuiltinMethod.bind, [o.THIS_EXPR])]);
	        this.compileElement.view.createMethod.addStmt(subscription.set(directiveInstance.prop(observablePropName)
	            .callMethod(o.BuiltinMethod.SubscribeObservable, [eventListener]))
	            .toDeclStmt(null, [o.StmtModifier.Final]));
	    };
	    return CompileEventListener;
	}());
	exports.CompileEventListener = CompileEventListener;
	function collectEventListeners(hostEvents, dirs, compileElement) {
	    var eventListeners = [];
	    hostEvents.forEach(function (hostEvent) {
	        compileElement.view.bindings.push(new compile_binding_1.CompileBinding(compileElement, hostEvent));
	        var listener = CompileEventListener.getOrCreate(compileElement, hostEvent.target, hostEvent.name, eventListeners);
	        listener.addAction(hostEvent, null, null);
	    });
	    collection_1.ListWrapper.forEachWithIndex(dirs, function (directiveAst, i) {
	        var directiveInstance = compileElement.directiveInstances[i];
	        directiveAst.hostEvents.forEach(function (hostEvent) {
	            compileElement.view.bindings.push(new compile_binding_1.CompileBinding(compileElement, hostEvent));
	            var listener = CompileEventListener.getOrCreate(compileElement, hostEvent.target, hostEvent.name, eventListeners);
	            listener.addAction(hostEvent, directiveAst.directive, directiveInstance);
	        });
	    });
	    eventListeners.forEach(function (listener) { return listener.finishMethod(); });
	    return eventListeners;
	}
	exports.collectEventListeners = collectEventListeners;
	function bindDirectiveOutputs(directiveAst, directiveInstance, eventListeners) {
	    collection_1.StringMapWrapper.forEach(directiveAst.directive.outputs, function (eventName, observablePropName) {
	        eventListeners.filter(function (listener) { return listener.eventName == eventName; })
	            .forEach(function (listener) { listener.listenToDirective(directiveInstance, observablePropName); });
	    });
	}
	exports.bindDirectiveOutputs = bindDirectiveOutputs;
	function bindRenderOutputs(eventListeners) {
	    eventListeners.forEach(function (listener) { return listener.listenToRenderer(); });
	}
	exports.bindRenderOutputs = bindRenderOutputs;
	function convertStmtIntoExpression(stmt) {
	    if (stmt instanceof o.ExpressionStatement) {
	        return stmt.expr;
	    }
	    else if (stmt instanceof o.ReturnStatement) {
	        return stmt.value;
	    }
	    return null;
	}
	function santitizeEventName(name) {
	    return lang_1.StringWrapper.replaceAll(name, /[^a-zA-Z_]/g, '_');
	}


/***/ },
/* 184 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var o = __webpack_require__(166);
	var constants_1 = __webpack_require__(172);
	var lifecycle_hooks_1 = __webpack_require__(158);
	var STATE_IS_NEVER_CHECKED = o.THIS_EXPR.prop('cdState').identical(constants_1.ChangeDetectorStateEnum.NeverChecked);
	var NOT_THROW_ON_CHANGES = o.not(constants_1.DetectChangesVars.throwOnChange);
	function bindDirectiveDetectChangesLifecycleCallbacks(directiveAst, directiveInstance, compileElement) {
	    var view = compileElement.view;
	    var detectChangesInInputsMethod = view.detectChangesInInputsMethod;
	    var lifecycleHooks = directiveAst.directive.lifecycleHooks;
	    if (lifecycleHooks.indexOf(lifecycle_hooks_1.LifecycleHooks.OnChanges) !== -1 && directiveAst.inputs.length > 0) {
	        detectChangesInInputsMethod.addStmt(new o.IfStmt(constants_1.DetectChangesVars.changes.notIdentical(o.NULL_EXPR), [directiveInstance.callMethod('ngOnChanges', [constants_1.DetectChangesVars.changes]).toStmt()]));
	    }
	    if (lifecycleHooks.indexOf(lifecycle_hooks_1.LifecycleHooks.OnInit) !== -1) {
	        detectChangesInInputsMethod.addStmt(new o.IfStmt(STATE_IS_NEVER_CHECKED.and(NOT_THROW_ON_CHANGES), [directiveInstance.callMethod('ngOnInit', []).toStmt()]));
	    }
	    if (lifecycleHooks.indexOf(lifecycle_hooks_1.LifecycleHooks.DoCheck) !== -1) {
	        detectChangesInInputsMethod.addStmt(new o.IfStmt(NOT_THROW_ON_CHANGES, [directiveInstance.callMethod('ngDoCheck', []).toStmt()]));
	    }
	}
	exports.bindDirectiveDetectChangesLifecycleCallbacks = bindDirectiveDetectChangesLifecycleCallbacks;
	function bindDirectiveAfterContentLifecycleCallbacks(directiveMeta, directiveInstance, compileElement) {
	    var view = compileElement.view;
	    var lifecycleHooks = directiveMeta.lifecycleHooks;
	    var afterContentLifecycleCallbacksMethod = view.afterContentLifecycleCallbacksMethod;
	    afterContentLifecycleCallbacksMethod.resetDebugInfo(compileElement.nodeIndex, compileElement.sourceAst);
	    if (lifecycleHooks.indexOf(lifecycle_hooks_1.LifecycleHooks.AfterContentInit) !== -1) {
	        afterContentLifecycleCallbacksMethod.addStmt(new o.IfStmt(STATE_IS_NEVER_CHECKED, [directiveInstance.callMethod('ngAfterContentInit', []).toStmt()]));
	    }
	    if (lifecycleHooks.indexOf(lifecycle_hooks_1.LifecycleHooks.AfterContentChecked) !== -1) {
	        afterContentLifecycleCallbacksMethod.addStmt(directiveInstance.callMethod('ngAfterContentChecked', []).toStmt());
	    }
	}
	exports.bindDirectiveAfterContentLifecycleCallbacks = bindDirectiveAfterContentLifecycleCallbacks;
	function bindDirectiveAfterViewLifecycleCallbacks(directiveMeta, directiveInstance, compileElement) {
	    var view = compileElement.view;
	    var lifecycleHooks = directiveMeta.lifecycleHooks;
	    var afterViewLifecycleCallbacksMethod = view.afterViewLifecycleCallbacksMethod;
	    afterViewLifecycleCallbacksMethod.resetDebugInfo(compileElement.nodeIndex, compileElement.sourceAst);
	    if (lifecycleHooks.indexOf(lifecycle_hooks_1.LifecycleHooks.AfterViewInit) !== -1) {
	        afterViewLifecycleCallbacksMethod.addStmt(new o.IfStmt(STATE_IS_NEVER_CHECKED, [directiveInstance.callMethod('ngAfterViewInit', []).toStmt()]));
	    }
	    if (lifecycleHooks.indexOf(lifecycle_hooks_1.LifecycleHooks.AfterViewChecked) !== -1) {
	        afterViewLifecycleCallbacksMethod.addStmt(directiveInstance.callMethod('ngAfterViewChecked', []).toStmt());
	    }
	}
	exports.bindDirectiveAfterViewLifecycleCallbacks = bindDirectiveAfterViewLifecycleCallbacks;
	function bindDirectiveDestroyLifecycleCallbacks(directiveMeta, directiveInstance, compileElement) {
	    var onDestroyMethod = compileElement.view.destroyMethod;
	    onDestroyMethod.resetDebugInfo(compileElement.nodeIndex, compileElement.sourceAst);
	    if (directiveMeta.lifecycleHooks.indexOf(lifecycle_hooks_1.LifecycleHooks.OnDestroy) !== -1) {
	        onDestroyMethod.addStmt(directiveInstance.callMethod('ngOnDestroy', []).toStmt());
	    }
	}
	exports.bindDirectiveDestroyLifecycleCallbacks = bindDirectiveDestroyLifecycleCallbacks;
	function bindPipeDestroyLifecycleCallbacks(pipeMeta, pipeInstance, view) {
	    var onDestroyMethod = view.destroyMethod;
	    if (pipeMeta.lifecycleHooks.indexOf(lifecycle_hooks_1.LifecycleHooks.OnDestroy) !== -1) {
	        onDestroyMethod.addStmt(pipeInstance.callMethod('ngOnDestroy', []).toStmt());
	    }
	}
	exports.bindPipeDestroyLifecycleCallbacks = bindPipeDestroyLifecycleCallbacks;


/***/ },
/* 185 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var compile_metadata_1 = __webpack_require__(157);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var async_1 = __webpack_require__(41);
	var xhr_1 = __webpack_require__(186);
	var url_resolver_1 = __webpack_require__(159);
	var style_url_resolver_1 = __webpack_require__(154);
	var di_1 = __webpack_require__(6);
	var view_1 = __webpack_require__(37);
	var html_ast_1 = __webpack_require__(147);
	var html_parser_1 = __webpack_require__(146);
	var template_preparser_1 = __webpack_require__(153);
	var DirectiveNormalizer = (function () {
	    function DirectiveNormalizer(_xhr, _urlResolver, _htmlParser) {
	        this._xhr = _xhr;
	        this._urlResolver = _urlResolver;
	        this._htmlParser = _htmlParser;
	    }
	    DirectiveNormalizer.prototype.normalizeDirective = function (directive) {
	        if (!directive.isComponent) {
	            // For non components there is nothing to be normalized yet.
	            return async_1.PromiseWrapper.resolve(directive);
	        }
	        return this.normalizeTemplate(directive.type, directive.template)
	            .then(function (normalizedTemplate) { return new compile_metadata_1.CompileDirectiveMetadata({
	            type: directive.type,
	            isComponent: directive.isComponent,
	            selector: directive.selector,
	            exportAs: directive.exportAs,
	            changeDetection: directive.changeDetection,
	            inputs: directive.inputs,
	            outputs: directive.outputs,
	            hostListeners: directive.hostListeners,
	            hostProperties: directive.hostProperties,
	            hostAttributes: directive.hostAttributes,
	            lifecycleHooks: directive.lifecycleHooks,
	            providers: directive.providers,
	            viewProviders: directive.viewProviders,
	            queries: directive.queries,
	            viewQueries: directive.viewQueries,
	            template: normalizedTemplate
	        }); });
	    };
	    DirectiveNormalizer.prototype.normalizeTemplate = function (directiveType, template) {
	        var _this = this;
	        if (lang_1.isPresent(template.template)) {
	            return async_1.PromiseWrapper.resolve(this.normalizeLoadedTemplate(directiveType, template, template.template, template.baseUrl));
	        }
	        else if (lang_1.isPresent(template.templateUrl)) {
	            var sourceAbsUrl = this._urlResolver.resolve(template.baseUrl, template.templateUrl);
	            return this._xhr.get(sourceAbsUrl)
	                .then(function (templateContent) { return _this.normalizeLoadedTemplate(directiveType, template, templateContent, sourceAbsUrl); });
	        }
	        else {
	            throw new exceptions_1.BaseException("No template specified for component " + directiveType.name);
	        }
	    };
	    DirectiveNormalizer.prototype.normalizeLoadedTemplate = function (directiveType, templateMeta, template, templateAbsUrl) {
	        var _this = this;
	        var rootNodesAndErrors = this._htmlParser.parse(template, directiveType.name);
	        if (rootNodesAndErrors.errors.length > 0) {
	            var errorString = rootNodesAndErrors.errors.join('\n');
	            throw new exceptions_1.BaseException("Template parse errors:\n" + errorString);
	        }
	        var visitor = new TemplatePreparseVisitor();
	        html_ast_1.htmlVisitAll(visitor, rootNodesAndErrors.rootNodes);
	        var allStyles = templateMeta.styles.concat(visitor.styles);
	        var allStyleAbsUrls = visitor.styleUrls.filter(style_url_resolver_1.isStyleUrlResolvable)
	            .map(function (url) { return _this._urlResolver.resolve(templateAbsUrl, url); })
	            .concat(templateMeta.styleUrls.filter(style_url_resolver_1.isStyleUrlResolvable)
	            .map(function (url) { return _this._urlResolver.resolve(templateMeta.baseUrl, url); }));
	        var allResolvedStyles = allStyles.map(function (style) {
	            var styleWithImports = style_url_resolver_1.extractStyleUrls(_this._urlResolver, templateAbsUrl, style);
	            styleWithImports.styleUrls.forEach(function (styleUrl) { return allStyleAbsUrls.push(styleUrl); });
	            return styleWithImports.style;
	        });
	        var encapsulation = templateMeta.encapsulation;
	        if (encapsulation === view_1.ViewEncapsulation.Emulated && allResolvedStyles.length === 0 &&
	            allStyleAbsUrls.length === 0) {
	            encapsulation = view_1.ViewEncapsulation.None;
	        }
	        return new compile_metadata_1.CompileTemplateMetadata({
	            encapsulation: encapsulation,
	            template: template,
	            templateUrl: templateAbsUrl,
	            styles: allResolvedStyles,
	            styleUrls: allStyleAbsUrls,
	            ngContentSelectors: visitor.ngContentSelectors
	        });
	    };
	    DirectiveNormalizer = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [xhr_1.XHR, url_resolver_1.UrlResolver, html_parser_1.HtmlParser])
	    ], DirectiveNormalizer);
	    return DirectiveNormalizer;
	}());
	exports.DirectiveNormalizer = DirectiveNormalizer;
	var TemplatePreparseVisitor = (function () {
	    function TemplatePreparseVisitor() {
	        this.ngContentSelectors = [];
	        this.styles = [];
	        this.styleUrls = [];
	        this.ngNonBindableStackCount = 0;
	    }
	    TemplatePreparseVisitor.prototype.visitElement = function (ast, context) {
	        var preparsedElement = template_preparser_1.preparseElement(ast);
	        switch (preparsedElement.type) {
	            case template_preparser_1.PreparsedElementType.NG_CONTENT:
	                if (this.ngNonBindableStackCount === 0) {
	                    this.ngContentSelectors.push(preparsedElement.selectAttr);
	                }
	                break;
	            case template_preparser_1.PreparsedElementType.STYLE:
	                var textContent = '';
	                ast.children.forEach(function (child) {
	                    if (child instanceof html_ast_1.HtmlTextAst) {
	                        textContent += child.value;
	                    }
	                });
	                this.styles.push(textContent);
	                break;
	            case template_preparser_1.PreparsedElementType.STYLESHEET:
	                this.styleUrls.push(preparsedElement.hrefAttr);
	                break;
	            default:
	                // DDC reports this as error. See:
	                // https://github.com/dart-lang/dev_compiler/issues/428
	                break;
	        }
	        if (preparsedElement.nonBindable) {
	            this.ngNonBindableStackCount++;
	        }
	        html_ast_1.htmlVisitAll(this, ast.children);
	        if (preparsedElement.nonBindable) {
	            this.ngNonBindableStackCount--;
	        }
	        return null;
	    };
	    TemplatePreparseVisitor.prototype.visitComment = function (ast, context) { return null; };
	    TemplatePreparseVisitor.prototype.visitAttr = function (ast, context) { return null; };
	    TemplatePreparseVisitor.prototype.visitText = function (ast, context) { return null; };
	    TemplatePreparseVisitor.prototype.visitExpansion = function (ast, context) { return null; };
	    TemplatePreparseVisitor.prototype.visitExpansionCase = function (ast, context) { return null; };
	    return TemplatePreparseVisitor;
	}());


/***/ },
/* 186 */
/***/ function(module, exports) {

	"use strict";
	// TODO: vsavkin rename it into TemplateLoader
	/**
	 * An interface for retrieving documents by URL that the compiler uses
	 * to load templates.
	 */
	var XHR = (function () {
	    function XHR() {
	    }
	    XHR.prototype.get = function (url) { return null; };
	    return XHR;
	}());
	exports.XHR = XHR;


/***/ },
/* 187 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var di_1 = __webpack_require__(6);
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var exceptions_1 = __webpack_require__(12);
	var cpl = __webpack_require__(157);
	var md = __webpack_require__(27);
	var directive_resolver_1 = __webpack_require__(188);
	var pipe_resolver_1 = __webpack_require__(189);
	var view_resolver_1 = __webpack_require__(190);
	var directive_lifecycle_reflector_1 = __webpack_require__(191);
	var lifecycle_hooks_1 = __webpack_require__(158);
	var reflection_1 = __webpack_require__(18);
	var di_2 = __webpack_require__(6);
	var platform_directives_and_pipes_1 = __webpack_require__(86);
	var util_1 = __webpack_require__(155);
	var assertions_1 = __webpack_require__(192);
	var url_resolver_1 = __webpack_require__(159);
	var provider_1 = __webpack_require__(24);
	var metadata_1 = __webpack_require__(7);
	var di_3 = __webpack_require__(4);
	var reflector_reader_1 = __webpack_require__(20);
	var provider_util_1 = __webpack_require__(25);
	var CompileMetadataResolver = (function () {
	    function CompileMetadataResolver(_directiveResolver, _pipeResolver, _viewResolver, _platformDirectives, _platformPipes, _reflector) {
	        this._directiveResolver = _directiveResolver;
	        this._pipeResolver = _pipeResolver;
	        this._viewResolver = _viewResolver;
	        this._platformDirectives = _platformDirectives;
	        this._platformPipes = _platformPipes;
	        this._directiveCache = new Map();
	        this._pipeCache = new Map();
	        this._anonymousTypes = new Map();
	        this._anonymousTypeIndex = 0;
	        if (lang_1.isPresent(_reflector)) {
	            this._reflector = _reflector;
	        }
	        else {
	            this._reflector = reflection_1.reflector;
	        }
	    }
	    CompileMetadataResolver.prototype.sanitizeTokenName = function (token) {
	        var identifier = lang_1.stringify(token);
	        if (identifier.indexOf('(') >= 0) {
	            // case: anonymous functions!
	            var found = this._anonymousTypes.get(token);
	            if (lang_1.isBlank(found)) {
	                this._anonymousTypes.set(token, this._anonymousTypeIndex++);
	                found = this._anonymousTypes.get(token);
	            }
	            identifier = "anonymous_token_" + found + "_";
	        }
	        return util_1.sanitizeIdentifier(identifier);
	    };
	    CompileMetadataResolver.prototype.getDirectiveMetadata = function (directiveType) {
	        var meta = this._directiveCache.get(directiveType);
	        if (lang_1.isBlank(meta)) {
	            var dirMeta = this._directiveResolver.resolve(directiveType);
	            var templateMeta = null;
	            var changeDetectionStrategy = null;
	            var viewProviders = [];
	            if (dirMeta instanceof md.ComponentMetadata) {
	                assertions_1.assertArrayOfStrings('styles', dirMeta.styles);
	                var cmpMeta = dirMeta;
	                var viewMeta = this._viewResolver.resolve(directiveType);
	                assertions_1.assertArrayOfStrings('styles', viewMeta.styles);
	                templateMeta = new cpl.CompileTemplateMetadata({
	                    encapsulation: viewMeta.encapsulation,
	                    template: viewMeta.template,
	                    templateUrl: viewMeta.templateUrl,
	                    styles: viewMeta.styles,
	                    styleUrls: viewMeta.styleUrls,
	                    baseUrl: calcTemplateBaseUrl(this._reflector, directiveType, cmpMeta)
	                });
	                changeDetectionStrategy = cmpMeta.changeDetection;
	                if (lang_1.isPresent(dirMeta.viewProviders)) {
	                    viewProviders = this.getProvidersMetadata(dirMeta.viewProviders);
	                }
	            }
	            var providers = [];
	            if (lang_1.isPresent(dirMeta.providers)) {
	                providers = this.getProvidersMetadata(dirMeta.providers);
	            }
	            var queries = [];
	            var viewQueries = [];
	            if (lang_1.isPresent(dirMeta.queries)) {
	                queries = this.getQueriesMetadata(dirMeta.queries, false);
	                viewQueries = this.getQueriesMetadata(dirMeta.queries, true);
	            }
	            meta = cpl.CompileDirectiveMetadata.create({
	                selector: dirMeta.selector,
	                exportAs: dirMeta.exportAs,
	                isComponent: lang_1.isPresent(templateMeta),
	                type: this.getTypeMetadata(directiveType, staticTypeModuleUrl(directiveType)),
	                template: templateMeta,
	                changeDetection: changeDetectionStrategy,
	                inputs: dirMeta.inputs,
	                outputs: dirMeta.outputs,
	                host: dirMeta.host,
	                lifecycleHooks: lifecycle_hooks_1.LIFECYCLE_HOOKS_VALUES.filter(function (hook) { return directive_lifecycle_reflector_1.hasLifecycleHook(hook, directiveType); }),
	                providers: providers,
	                viewProviders: viewProviders,
	                queries: queries,
	                viewQueries: viewQueries
	            });
	            this._directiveCache.set(directiveType, meta);
	        }
	        return meta;
	    };
	    /**
	     * @param someType a symbol which may or may not be a directive type
	     * @returns {cpl.CompileDirectiveMetadata} if possible, otherwise null.
	     */
	    CompileMetadataResolver.prototype.maybeGetDirectiveMetadata = function (someType) {
	        try {
	            return this.getDirectiveMetadata(someType);
	        }
	        catch (e) {
	            if (e.message.indexOf('No Directive annotation') !== -1) {
	                return null;
	            }
	            throw e;
	        }
	    };
	    CompileMetadataResolver.prototype.getTypeMetadata = function (type, moduleUrl) {
	        return new cpl.CompileTypeMetadata({
	            name: this.sanitizeTokenName(type),
	            moduleUrl: moduleUrl,
	            runtime: type,
	            diDeps: this.getDependenciesMetadata(type, null)
	        });
	    };
	    CompileMetadataResolver.prototype.getFactoryMetadata = function (factory, moduleUrl) {
	        return new cpl.CompileFactoryMetadata({
	            name: this.sanitizeTokenName(factory),
	            moduleUrl: moduleUrl,
	            runtime: factory,
	            diDeps: this.getDependenciesMetadata(factory, null)
	        });
	    };
	    CompileMetadataResolver.prototype.getPipeMetadata = function (pipeType) {
	        var meta = this._pipeCache.get(pipeType);
	        if (lang_1.isBlank(meta)) {
	            var pipeMeta = this._pipeResolver.resolve(pipeType);
	            meta = new cpl.CompilePipeMetadata({
	                type: this.getTypeMetadata(pipeType, staticTypeModuleUrl(pipeType)),
	                name: pipeMeta.name,
	                pure: pipeMeta.pure,
	                lifecycleHooks: lifecycle_hooks_1.LIFECYCLE_HOOKS_VALUES.filter(function (hook) { return directive_lifecycle_reflector_1.hasLifecycleHook(hook, pipeType); }),
	            });
	            this._pipeCache.set(pipeType, meta);
	        }
	        return meta;
	    };
	    CompileMetadataResolver.prototype.getViewDirectivesMetadata = function (component) {
	        var _this = this;
	        var view = this._viewResolver.resolve(component);
	        var directives = flattenDirectives(view, this._platformDirectives);
	        for (var i = 0; i < directives.length; i++) {
	            if (!isValidType(directives[i])) {
	                throw new exceptions_1.BaseException("Unexpected directive value '" + lang_1.stringify(directives[i]) + "' on the View of component '" + lang_1.stringify(component) + "'");
	            }
	        }
	        return directives.map(function (type) { return _this.getDirectiveMetadata(type); });
	    };
	    CompileMetadataResolver.prototype.getViewPipesMetadata = function (component) {
	        var _this = this;
	        var view = this._viewResolver.resolve(component);
	        var pipes = flattenPipes(view, this._platformPipes);
	        for (var i = 0; i < pipes.length; i++) {
	            if (!isValidType(pipes[i])) {
	                throw new exceptions_1.BaseException("Unexpected piped value '" + lang_1.stringify(pipes[i]) + "' on the View of component '" + lang_1.stringify(component) + "'");
	            }
	        }
	        return pipes.map(function (type) { return _this.getPipeMetadata(type); });
	    };
	    CompileMetadataResolver.prototype.getDependenciesMetadata = function (typeOrFunc, dependencies) {
	        var _this = this;
	        var params = lang_1.isPresent(dependencies) ? dependencies : this._reflector.parameters(typeOrFunc);
	        if (lang_1.isBlank(params)) {
	            params = [];
	        }
	        return params.map(function (param) {
	            if (lang_1.isBlank(param)) {
	                return null;
	            }
	            var isAttribute = false;
	            var isHost = false;
	            var isSelf = false;
	            var isSkipSelf = false;
	            var isOptional = false;
	            var query = null;
	            var viewQuery = null;
	            var token = null;
	            if (lang_1.isArray(param)) {
	                param
	                    .forEach(function (paramEntry) {
	                    if (paramEntry instanceof metadata_1.HostMetadata) {
	                        isHost = true;
	                    }
	                    else if (paramEntry instanceof metadata_1.SelfMetadata) {
	                        isSelf = true;
	                    }
	                    else if (paramEntry instanceof metadata_1.SkipSelfMetadata) {
	                        isSkipSelf = true;
	                    }
	                    else if (paramEntry instanceof metadata_1.OptionalMetadata) {
	                        isOptional = true;
	                    }
	                    else if (paramEntry instanceof di_3.AttributeMetadata) {
	                        isAttribute = true;
	                        token = paramEntry.attributeName;
	                    }
	                    else if (paramEntry instanceof di_3.QueryMetadata) {
	                        if (paramEntry.isViewQuery) {
	                            viewQuery = paramEntry;
	                        }
	                        else {
	                            query = paramEntry;
	                        }
	                    }
	                    else if (paramEntry instanceof metadata_1.InjectMetadata) {
	                        token = paramEntry.token;
	                    }
	                    else if (isValidType(paramEntry) && lang_1.isBlank(token)) {
	                        token = paramEntry;
	                    }
	                });
	            }
	            else {
	                token = param;
	            }
	            if (lang_1.isBlank(token)) {
	                return null;
	            }
	            return new cpl.CompileDiDependencyMetadata({
	                isAttribute: isAttribute,
	                isHost: isHost,
	                isSelf: isSelf,
	                isSkipSelf: isSkipSelf,
	                isOptional: isOptional,
	                query: lang_1.isPresent(query) ? _this.getQueryMetadata(query, null) : null,
	                viewQuery: lang_1.isPresent(viewQuery) ? _this.getQueryMetadata(viewQuery, null) : null,
	                token: _this.getTokenMetadata(token)
	            });
	        });
	    };
	    CompileMetadataResolver.prototype.getTokenMetadata = function (token) {
	        token = di_1.resolveForwardRef(token);
	        var compileToken;
	        if (lang_1.isString(token)) {
	            compileToken = new cpl.CompileTokenMetadata({ value: token });
	        }
	        else {
	            compileToken = new cpl.CompileTokenMetadata({
	                identifier: new cpl.CompileIdentifierMetadata({
	                    runtime: token,
	                    name: this.sanitizeTokenName(token),
	                    moduleUrl: staticTypeModuleUrl(token)
	                })
	            });
	        }
	        return compileToken;
	    };
	    CompileMetadataResolver.prototype.getProvidersMetadata = function (providers) {
	        var _this = this;
	        return providers.map(function (provider) {
	            provider = di_1.resolveForwardRef(provider);
	            if (lang_1.isArray(provider)) {
	                return _this.getProvidersMetadata(provider);
	            }
	            else if (provider instanceof provider_1.Provider) {
	                return _this.getProviderMetadata(provider);
	            }
	            else if (provider_util_1.isProviderLiteral(provider)) {
	                return _this.getProviderMetadata(provider_util_1.createProvider(provider));
	            }
	            else {
	                return _this.getTypeMetadata(provider, staticTypeModuleUrl(provider));
	            }
	        });
	    };
	    CompileMetadataResolver.prototype.getProviderMetadata = function (provider) {
	        var compileDeps;
	        if (lang_1.isPresent(provider.useClass)) {
	            compileDeps = this.getDependenciesMetadata(provider.useClass, provider.dependencies);
	        }
	        else if (lang_1.isPresent(provider.useFactory)) {
	            compileDeps = this.getDependenciesMetadata(provider.useFactory, provider.dependencies);
	        }
	        return new cpl.CompileProviderMetadata({
	            token: this.getTokenMetadata(provider.token),
	            useClass: lang_1.isPresent(provider.useClass) ?
	                this.getTypeMetadata(provider.useClass, staticTypeModuleUrl(provider.useClass)) :
	                null,
	            useValue: convertToCompileValue(provider.useValue),
	            useFactory: lang_1.isPresent(provider.useFactory) ?
	                this.getFactoryMetadata(provider.useFactory, staticTypeModuleUrl(provider.useFactory)) :
	                null,
	            useExisting: lang_1.isPresent(provider.useExisting) ? this.getTokenMetadata(provider.useExisting) :
	                null,
	            deps: compileDeps,
	            multi: provider.multi
	        });
	    };
	    CompileMetadataResolver.prototype.getQueriesMetadata = function (queries, isViewQuery) {
	        var _this = this;
	        var compileQueries = [];
	        collection_1.StringMapWrapper.forEach(queries, function (query, propertyName) {
	            if (query.isViewQuery === isViewQuery) {
	                compileQueries.push(_this.getQueryMetadata(query, propertyName));
	            }
	        });
	        return compileQueries;
	    };
	    CompileMetadataResolver.prototype.getQueryMetadata = function (q, propertyName) {
	        var _this = this;
	        var selectors;
	        if (q.isVarBindingQuery) {
	            selectors = q.varBindings.map(function (varName) { return _this.getTokenMetadata(varName); });
	        }
	        else {
	            selectors = [this.getTokenMetadata(q.selector)];
	        }
	        return new cpl.CompileQueryMetadata({
	            selectors: selectors,
	            first: q.first,
	            descendants: q.descendants,
	            propertyName: propertyName,
	            read: lang_1.isPresent(q.read) ? this.getTokenMetadata(q.read) : null
	        });
	    };
	    CompileMetadataResolver = __decorate([
	        di_2.Injectable(),
	        __param(3, di_2.Optional()),
	        __param(3, di_2.Inject(platform_directives_and_pipes_1.PLATFORM_DIRECTIVES)),
	        __param(4, di_2.Optional()),
	        __param(4, di_2.Inject(platform_directives_and_pipes_1.PLATFORM_PIPES)), 
	        __metadata('design:paramtypes', [directive_resolver_1.DirectiveResolver, pipe_resolver_1.PipeResolver, view_resolver_1.ViewResolver, Array, Array, reflector_reader_1.ReflectorReader])
	    ], CompileMetadataResolver);
	    return CompileMetadataResolver;
	}());
	exports.CompileMetadataResolver = CompileMetadataResolver;
	function flattenDirectives(view, platformDirectives) {
	    var directives = [];
	    if (lang_1.isPresent(platformDirectives)) {
	        flattenArray(platformDirectives, directives);
	    }
	    if (lang_1.isPresent(view.directives)) {
	        flattenArray(view.directives, directives);
	    }
	    return directives;
	}
	function flattenPipes(view, platformPipes) {
	    var pipes = [];
	    if (lang_1.isPresent(platformPipes)) {
	        flattenArray(platformPipes, pipes);
	    }
	    if (lang_1.isPresent(view.pipes)) {
	        flattenArray(view.pipes, pipes);
	    }
	    return pipes;
	}
	function flattenArray(tree, out) {
	    for (var i = 0; i < tree.length; i++) {
	        var item = di_1.resolveForwardRef(tree[i]);
	        if (lang_1.isArray(item)) {
	            flattenArray(item, out);
	        }
	        else {
	            out.push(item);
	        }
	    }
	}
	function isStaticType(value) {
	    return lang_1.isStringMap(value) && lang_1.isPresent(value['name']) && lang_1.isPresent(value['moduleId']);
	}
	function isValidType(value) {
	    return isStaticType(value) || (value instanceof lang_1.Type);
	}
	function staticTypeModuleUrl(value) {
	    return isStaticType(value) ? value['moduleId'] : null;
	}
	function calcTemplateBaseUrl(reflector, type, cmpMetadata) {
	    if (isStaticType(type)) {
	        return type['filePath'];
	    }
	    if (lang_1.isPresent(cmpMetadata.moduleId)) {
	        var moduleId = cmpMetadata.moduleId;
	        var scheme = url_resolver_1.getUrlScheme(moduleId);
	        return lang_1.isPresent(scheme) && scheme.length > 0 ? moduleId :
	            "package:" + moduleId + util_1.MODULE_SUFFIX;
	    }
	    return reflector.importUri(type);
	}
	// Only fill CompileIdentifierMetadata.runtime if needed...
	function convertToCompileValue(value) {
	    return util_1.visitValue(value, new _CompileValueConverter(), null);
	}
	var _CompileValueConverter = (function (_super) {
	    __extends(_CompileValueConverter, _super);
	    function _CompileValueConverter() {
	        _super.apply(this, arguments);
	    }
	    _CompileValueConverter.prototype.visitOther = function (value, context) {
	        if (isStaticType(value)) {
	            return new cpl.CompileIdentifierMetadata({ name: value['name'], moduleUrl: staticTypeModuleUrl(value) });
	        }
	        else {
	            return new cpl.CompileIdentifierMetadata({ runtime: value });
	        }
	    };
	    return _CompileValueConverter;
	}(util_1.ValueTransformer));


/***/ },
/* 188 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var di_1 = __webpack_require__(6);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var collection_1 = __webpack_require__(15);
	var metadata_1 = __webpack_require__(3);
	var reflection_1 = __webpack_require__(18);
	var reflector_reader_1 = __webpack_require__(20);
	function _isDirectiveMetadata(type) {
	    return type instanceof metadata_1.DirectiveMetadata;
	}
	/*
	 * Resolve a `Type` for {@link DirectiveMetadata}.
	 *
	 * This interface can be overridden by the application developer to create custom behavior.
	 *
	 * See {@link Compiler}
	 */
	var DirectiveResolver = (function () {
	    function DirectiveResolver(_reflector) {
	        if (lang_1.isPresent(_reflector)) {
	            this._reflector = _reflector;
	        }
	        else {
	            this._reflector = reflection_1.reflector;
	        }
	    }
	    /**
	     * Return {@link DirectiveMetadata} for a given `Type`.
	     */
	    DirectiveResolver.prototype.resolve = function (type) {
	        var typeMetadata = this._reflector.annotations(di_1.resolveForwardRef(type));
	        if (lang_1.isPresent(typeMetadata)) {
	            var metadata = typeMetadata.find(_isDirectiveMetadata);
	            if (lang_1.isPresent(metadata)) {
	                var propertyMetadata = this._reflector.propMetadata(type);
	                return this._mergeWithPropertyMetadata(metadata, propertyMetadata, type);
	            }
	        }
	        throw new exceptions_1.BaseException("No Directive annotation found on " + lang_1.stringify(type));
	    };
	    DirectiveResolver.prototype._mergeWithPropertyMetadata = function (dm, propertyMetadata, directiveType) {
	        var inputs = [];
	        var outputs = [];
	        var host = {};
	        var queries = {};
	        collection_1.StringMapWrapper.forEach(propertyMetadata, function (metadata, propName) {
	            metadata.forEach(function (a) {
	                if (a instanceof metadata_1.InputMetadata) {
	                    if (lang_1.isPresent(a.bindingPropertyName)) {
	                        inputs.push(propName + ": " + a.bindingPropertyName);
	                    }
	                    else {
	                        inputs.push(propName);
	                    }
	                }
	                if (a instanceof metadata_1.OutputMetadata) {
	                    if (lang_1.isPresent(a.bindingPropertyName)) {
	                        outputs.push(propName + ": " + a.bindingPropertyName);
	                    }
	                    else {
	                        outputs.push(propName);
	                    }
	                }
	                if (a instanceof metadata_1.HostBindingMetadata) {
	                    if (lang_1.isPresent(a.hostPropertyName)) {
	                        host[("[" + a.hostPropertyName + "]")] = propName;
	                    }
	                    else {
	                        host[("[" + propName + "]")] = propName;
	                    }
	                }
	                if (a instanceof metadata_1.HostListenerMetadata) {
	                    var args = lang_1.isPresent(a.args) ? a.args.join(', ') : '';
	                    host[("(" + a.eventName + ")")] = propName + "(" + args + ")";
	                }
	                if (a instanceof metadata_1.ContentChildrenMetadata) {
	                    queries[propName] = a;
	                }
	                if (a instanceof metadata_1.ViewChildrenMetadata) {
	                    queries[propName] = a;
	                }
	                if (a instanceof metadata_1.ContentChildMetadata) {
	                    queries[propName] = a;
	                }
	                if (a instanceof metadata_1.ViewChildMetadata) {
	                    queries[propName] = a;
	                }
	            });
	        });
	        return this._merge(dm, inputs, outputs, host, queries, directiveType);
	    };
	    DirectiveResolver.prototype._merge = function (dm, inputs, outputs, host, queries, directiveType) {
	        var mergedInputs = lang_1.isPresent(dm.inputs) ? collection_1.ListWrapper.concat(dm.inputs, inputs) : inputs;
	        var mergedOutputs;
	        if (lang_1.isPresent(dm.outputs)) {
	            dm.outputs.forEach(function (propName) {
	                if (collection_1.ListWrapper.contains(outputs, propName)) {
	                    throw new exceptions_1.BaseException("Output event '" + propName + "' defined multiple times in '" + lang_1.stringify(directiveType) + "'");
	                }
	            });
	            mergedOutputs = collection_1.ListWrapper.concat(dm.outputs, outputs);
	        }
	        else {
	            mergedOutputs = outputs;
	        }
	        var mergedHost = lang_1.isPresent(dm.host) ? collection_1.StringMapWrapper.merge(dm.host, host) : host;
	        var mergedQueries = lang_1.isPresent(dm.queries) ? collection_1.StringMapWrapper.merge(dm.queries, queries) : queries;
	        if (dm instanceof metadata_1.ComponentMetadata) {
	            return new metadata_1.ComponentMetadata({
	                selector: dm.selector,
	                inputs: mergedInputs,
	                outputs: mergedOutputs,
	                host: mergedHost,
	                exportAs: dm.exportAs,
	                moduleId: dm.moduleId,
	                queries: mergedQueries,
	                changeDetection: dm.changeDetection,
	                providers: dm.providers,
	                viewProviders: dm.viewProviders
	            });
	        }
	        else {
	            return new metadata_1.DirectiveMetadata({
	                selector: dm.selector,
	                inputs: mergedInputs,
	                outputs: mergedOutputs,
	                host: mergedHost,
	                exportAs: dm.exportAs,
	                queries: mergedQueries,
	                providers: dm.providers
	            });
	        }
	    };
	    DirectiveResolver = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [reflector_reader_1.ReflectorReader])
	    ], DirectiveResolver);
	    return DirectiveResolver;
	}());
	exports.DirectiveResolver = DirectiveResolver;
	exports.CODEGEN_DIRECTIVE_RESOLVER = new DirectiveResolver(reflection_1.reflector);


/***/ },
/* 189 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var di_1 = __webpack_require__(6);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var metadata_1 = __webpack_require__(3);
	var reflector_reader_1 = __webpack_require__(20);
	var reflection_1 = __webpack_require__(18);
	function _isPipeMetadata(type) {
	    return type instanceof metadata_1.PipeMetadata;
	}
	/**
	 * Resolve a `Type` for {@link PipeMetadata}.
	 *
	 * This interface can be overridden by the application developer to create custom behavior.
	 *
	 * See {@link Compiler}
	 */
	var PipeResolver = (function () {
	    function PipeResolver(_reflector) {
	        if (lang_1.isPresent(_reflector)) {
	            this._reflector = _reflector;
	        }
	        else {
	            this._reflector = reflection_1.reflector;
	        }
	    }
	    /**
	     * Return {@link PipeMetadata} for a given `Type`.
	     */
	    PipeResolver.prototype.resolve = function (type) {
	        var metas = this._reflector.annotations(di_1.resolveForwardRef(type));
	        if (lang_1.isPresent(metas)) {
	            var annotation = metas.find(_isPipeMetadata);
	            if (lang_1.isPresent(annotation)) {
	                return annotation;
	            }
	        }
	        throw new exceptions_1.BaseException("No Pipe decorator found on " + lang_1.stringify(type));
	    };
	    PipeResolver = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [reflector_reader_1.ReflectorReader])
	    ], PipeResolver);
	    return PipeResolver;
	}());
	exports.PipeResolver = PipeResolver;
	exports.CODEGEN_PIPE_RESOLVER = new PipeResolver(reflection_1.reflector);


/***/ },
/* 190 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var di_1 = __webpack_require__(6);
	var view_1 = __webpack_require__(37);
	var directives_1 = __webpack_require__(27);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var collection_1 = __webpack_require__(15);
	var reflector_reader_1 = __webpack_require__(20);
	var reflection_1 = __webpack_require__(18);
	/**
	 * Resolves types to {@link ViewMetadata}.
	 */
	var ViewResolver = (function () {
	    function ViewResolver(_reflector) {
	        /** @internal */
	        this._cache = new collection_1.Map();
	        if (lang_1.isPresent(_reflector)) {
	            this._reflector = _reflector;
	        }
	        else {
	            this._reflector = reflection_1.reflector;
	        }
	    }
	    ViewResolver.prototype.resolve = function (component) {
	        var view = this._cache.get(component);
	        if (lang_1.isBlank(view)) {
	            view = this._resolve(component);
	            this._cache.set(component, view);
	        }
	        return view;
	    };
	    /** @internal */
	    ViewResolver.prototype._resolve = function (component) {
	        var compMeta;
	        var viewMeta;
	        this._reflector.annotations(component).forEach(function (m) {
	            if (m instanceof view_1.ViewMetadata) {
	                viewMeta = m;
	            }
	            if (m instanceof directives_1.ComponentMetadata) {
	                compMeta = m;
	            }
	        });
	        if (lang_1.isPresent(compMeta)) {
	            if (lang_1.isBlank(compMeta.template) && lang_1.isBlank(compMeta.templateUrl) && lang_1.isBlank(viewMeta)) {
	                throw new exceptions_1.BaseException("Component '" + lang_1.stringify(component) + "' must have either 'template' or 'templateUrl' set.");
	            }
	            else if (lang_1.isPresent(compMeta.template) && lang_1.isPresent(viewMeta)) {
	                this._throwMixingViewAndComponent("template", component);
	            }
	            else if (lang_1.isPresent(compMeta.templateUrl) && lang_1.isPresent(viewMeta)) {
	                this._throwMixingViewAndComponent("templateUrl", component);
	            }
	            else if (lang_1.isPresent(compMeta.directives) && lang_1.isPresent(viewMeta)) {
	                this._throwMixingViewAndComponent("directives", component);
	            }
	            else if (lang_1.isPresent(compMeta.pipes) && lang_1.isPresent(viewMeta)) {
	                this._throwMixingViewAndComponent("pipes", component);
	            }
	            else if (lang_1.isPresent(compMeta.encapsulation) && lang_1.isPresent(viewMeta)) {
	                this._throwMixingViewAndComponent("encapsulation", component);
	            }
	            else if (lang_1.isPresent(compMeta.styles) && lang_1.isPresent(viewMeta)) {
	                this._throwMixingViewAndComponent("styles", component);
	            }
	            else if (lang_1.isPresent(compMeta.styleUrls) && lang_1.isPresent(viewMeta)) {
	                this._throwMixingViewAndComponent("styleUrls", component);
	            }
	            else if (lang_1.isPresent(viewMeta)) {
	                return viewMeta;
	            }
	            else {
	                return new view_1.ViewMetadata({
	                    templateUrl: compMeta.templateUrl,
	                    template: compMeta.template,
	                    directives: compMeta.directives,
	                    pipes: compMeta.pipes,
	                    encapsulation: compMeta.encapsulation,
	                    styles: compMeta.styles,
	                    styleUrls: compMeta.styleUrls
	                });
	            }
	        }
	        else {
	            if (lang_1.isBlank(viewMeta)) {
	                throw new exceptions_1.BaseException("Could not compile '" + lang_1.stringify(component) + "' because it is not a component.");
	            }
	            else {
	                return viewMeta;
	            }
	        }
	        return null;
	    };
	    /** @internal */
	    ViewResolver.prototype._throwMixingViewAndComponent = function (propertyName, component) {
	        throw new exceptions_1.BaseException("Component '" + lang_1.stringify(component) + "' cannot have both '" + propertyName + "' and '@View' set at the same time\"");
	    };
	    ViewResolver = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [reflector_reader_1.ReflectorReader])
	    ], ViewResolver);
	    return ViewResolver;
	}());
	exports.ViewResolver = ViewResolver;


/***/ },
/* 191 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var lifecycle_hooks_1 = __webpack_require__(158);
	function hasLifecycleHook(lcInterface, token) {
	    if (!(token instanceof lang_1.Type))
	        return false;
	    var proto = token.prototype;
	    switch (lcInterface) {
	        case lifecycle_hooks_1.LifecycleHooks.AfterContentInit:
	            return !!proto.ngAfterContentInit;
	        case lifecycle_hooks_1.LifecycleHooks.AfterContentChecked:
	            return !!proto.ngAfterContentChecked;
	        case lifecycle_hooks_1.LifecycleHooks.AfterViewInit:
	            return !!proto.ngAfterViewInit;
	        case lifecycle_hooks_1.LifecycleHooks.AfterViewChecked:
	            return !!proto.ngAfterViewChecked;
	        case lifecycle_hooks_1.LifecycleHooks.OnChanges:
	            return !!proto.ngOnChanges;
	        case lifecycle_hooks_1.LifecycleHooks.DoCheck:
	            return !!proto.ngDoCheck;
	        case lifecycle_hooks_1.LifecycleHooks.OnDestroy:
	            return !!proto.ngOnDestroy;
	        case lifecycle_hooks_1.LifecycleHooks.OnInit:
	            return !!proto.ngOnInit;
	        default:
	            return false;
	    }
	}
	exports.hasLifecycleHook = hasLifecycleHook;


/***/ },
/* 192 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	function assertArrayOfStrings(identifier, value) {
	    if (!lang_1.assertionsEnabled() || lang_1.isBlank(value)) {
	        return;
	    }
	    if (!lang_1.isArray(value)) {
	        throw new exceptions_1.BaseException("Expected '" + identifier + "' to be an array of strings.");
	    }
	    for (var i = 0; i < value.length; i += 1) {
	        if (!lang_1.isString(value[i])) {
	            throw new exceptions_1.BaseException("Expected '" + identifier + "' to be an array of strings.");
	        }
	    }
	}
	exports.assertArrayOfStrings = assertArrayOfStrings;


/***/ },
/* 193 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var abstract_emitter_1 = __webpack_require__(194);
	var abstract_js_emitter_1 = __webpack_require__(195);
	var util_1 = __webpack_require__(155);
	function jitStatements(sourceUrl, statements, resultVar) {
	    var converter = new JitEmitterVisitor();
	    var ctx = abstract_emitter_1.EmitterVisitorContext.createRoot([resultVar]);
	    converter.visitAllStatements(statements, ctx);
	    return lang_1.evalExpression(sourceUrl, resultVar, ctx.toSource(), converter.getArgs());
	}
	exports.jitStatements = jitStatements;
	var JitEmitterVisitor = (function (_super) {
	    __extends(JitEmitterVisitor, _super);
	    function JitEmitterVisitor() {
	        _super.apply(this, arguments);
	        this._evalArgNames = [];
	        this._evalArgValues = [];
	    }
	    JitEmitterVisitor.prototype.getArgs = function () {
	        var result = {};
	        for (var i = 0; i < this._evalArgNames.length; i++) {
	            result[this._evalArgNames[i]] = this._evalArgValues[i];
	        }
	        return result;
	    };
	    JitEmitterVisitor.prototype.visitExternalExpr = function (ast, ctx) {
	        var value = ast.value.runtime;
	        var id = this._evalArgValues.indexOf(value);
	        if (id === -1) {
	            id = this._evalArgValues.length;
	            this._evalArgValues.push(value);
	            var name = lang_1.isPresent(ast.value.name) ? util_1.sanitizeIdentifier(ast.value.name) : 'val';
	            this._evalArgNames.push(util_1.sanitizeIdentifier("jit_" + name + id));
	        }
	        ctx.print(this._evalArgNames[id]);
	        return null;
	    };
	    return JitEmitterVisitor;
	}(abstract_js_emitter_1.AbstractJsEmitterVisitor));


/***/ },
/* 194 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var o = __webpack_require__(166);
	var _SINGLE_QUOTE_ESCAPE_STRING_RE = /'|\\|\n|\r|\$/g;
	exports.CATCH_ERROR_VAR = o.variable('error');
	exports.CATCH_STACK_VAR = o.variable('stack');
	var OutputEmitter = (function () {
	    function OutputEmitter() {
	    }
	    return OutputEmitter;
	}());
	exports.OutputEmitter = OutputEmitter;
	var _EmittedLine = (function () {
	    function _EmittedLine(indent) {
	        this.indent = indent;
	        this.parts = [];
	    }
	    return _EmittedLine;
	}());
	var EmitterVisitorContext = (function () {
	    function EmitterVisitorContext(_exportedVars, _indent) {
	        this._exportedVars = _exportedVars;
	        this._indent = _indent;
	        this._classes = [];
	        this._lines = [new _EmittedLine(_indent)];
	    }
	    EmitterVisitorContext.createRoot = function (exportedVars) {
	        return new EmitterVisitorContext(exportedVars, 0);
	    };
	    Object.defineProperty(EmitterVisitorContext.prototype, "_currentLine", {
	        get: function () { return this._lines[this._lines.length - 1]; },
	        enumerable: true,
	        configurable: true
	    });
	    EmitterVisitorContext.prototype.isExportedVar = function (varName) { return this._exportedVars.indexOf(varName) !== -1; };
	    EmitterVisitorContext.prototype.println = function (lastPart) {
	        if (lastPart === void 0) { lastPart = ''; }
	        this.print(lastPart, true);
	    };
	    EmitterVisitorContext.prototype.lineIsEmpty = function () { return this._currentLine.parts.length === 0; };
	    EmitterVisitorContext.prototype.print = function (part, newLine) {
	        if (newLine === void 0) { newLine = false; }
	        if (part.length > 0) {
	            this._currentLine.parts.push(part);
	        }
	        if (newLine) {
	            this._lines.push(new _EmittedLine(this._indent));
	        }
	    };
	    EmitterVisitorContext.prototype.removeEmptyLastLine = function () {
	        if (this.lineIsEmpty()) {
	            this._lines.pop();
	        }
	    };
	    EmitterVisitorContext.prototype.incIndent = function () {
	        this._indent++;
	        this._currentLine.indent = this._indent;
	    };
	    EmitterVisitorContext.prototype.decIndent = function () {
	        this._indent--;
	        this._currentLine.indent = this._indent;
	    };
	    EmitterVisitorContext.prototype.pushClass = function (clazz) { this._classes.push(clazz); };
	    EmitterVisitorContext.prototype.popClass = function () { return this._classes.pop(); };
	    Object.defineProperty(EmitterVisitorContext.prototype, "currentClass", {
	        get: function () {
	            return this._classes.length > 0 ? this._classes[this._classes.length - 1] : null;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    EmitterVisitorContext.prototype.toSource = function () {
	        var lines = this._lines;
	        if (lines[lines.length - 1].parts.length === 0) {
	            lines = lines.slice(0, lines.length - 1);
	        }
	        return lines.map(function (line) {
	            if (line.parts.length > 0) {
	                return _createIndent(line.indent) + line.parts.join('');
	            }
	            else {
	                return '';
	            }
	        })
	            .join('\n');
	    };
	    return EmitterVisitorContext;
	}());
	exports.EmitterVisitorContext = EmitterVisitorContext;
	var AbstractEmitterVisitor = (function () {
	    function AbstractEmitterVisitor(_escapeDollarInStrings) {
	        this._escapeDollarInStrings = _escapeDollarInStrings;
	    }
	    AbstractEmitterVisitor.prototype.visitExpressionStmt = function (stmt, ctx) {
	        stmt.expr.visitExpression(this, ctx);
	        ctx.println(';');
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitReturnStmt = function (stmt, ctx) {
	        ctx.print("return ");
	        stmt.value.visitExpression(this, ctx);
	        ctx.println(';');
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitIfStmt = function (stmt, ctx) {
	        ctx.print("if (");
	        stmt.condition.visitExpression(this, ctx);
	        ctx.print(") {");
	        var hasElseCase = lang_1.isPresent(stmt.falseCase) && stmt.falseCase.length > 0;
	        if (stmt.trueCase.length <= 1 && !hasElseCase) {
	            ctx.print(" ");
	            this.visitAllStatements(stmt.trueCase, ctx);
	            ctx.removeEmptyLastLine();
	            ctx.print(" ");
	        }
	        else {
	            ctx.println();
	            ctx.incIndent();
	            this.visitAllStatements(stmt.trueCase, ctx);
	            ctx.decIndent();
	            if (hasElseCase) {
	                ctx.println("} else {");
	                ctx.incIndent();
	                this.visitAllStatements(stmt.falseCase, ctx);
	                ctx.decIndent();
	            }
	        }
	        ctx.println("}");
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitThrowStmt = function (stmt, ctx) {
	        ctx.print("throw ");
	        stmt.error.visitExpression(this, ctx);
	        ctx.println(";");
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitCommentStmt = function (stmt, ctx) {
	        var lines = stmt.comment.split('\n');
	        lines.forEach(function (line) { ctx.println("// " + line); });
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitWriteVarExpr = function (expr, ctx) {
	        var lineWasEmpty = ctx.lineIsEmpty();
	        if (!lineWasEmpty) {
	            ctx.print('(');
	        }
	        ctx.print(expr.name + " = ");
	        expr.value.visitExpression(this, ctx);
	        if (!lineWasEmpty) {
	            ctx.print(')');
	        }
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitWriteKeyExpr = function (expr, ctx) {
	        var lineWasEmpty = ctx.lineIsEmpty();
	        if (!lineWasEmpty) {
	            ctx.print('(');
	        }
	        expr.receiver.visitExpression(this, ctx);
	        ctx.print("[");
	        expr.index.visitExpression(this, ctx);
	        ctx.print("] = ");
	        expr.value.visitExpression(this, ctx);
	        if (!lineWasEmpty) {
	            ctx.print(')');
	        }
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitWritePropExpr = function (expr, ctx) {
	        var lineWasEmpty = ctx.lineIsEmpty();
	        if (!lineWasEmpty) {
	            ctx.print('(');
	        }
	        expr.receiver.visitExpression(this, ctx);
	        ctx.print("." + expr.name + " = ");
	        expr.value.visitExpression(this, ctx);
	        if (!lineWasEmpty) {
	            ctx.print(')');
	        }
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitInvokeMethodExpr = function (expr, ctx) {
	        expr.receiver.visitExpression(this, ctx);
	        var name = expr.name;
	        if (lang_1.isPresent(expr.builtin)) {
	            name = this.getBuiltinMethodName(expr.builtin);
	            if (lang_1.isBlank(name)) {
	                // some builtins just mean to skip the call.
	                // e.g. `bind` in Dart.
	                return null;
	            }
	        }
	        ctx.print("." + name + "(");
	        this.visitAllExpressions(expr.args, ctx, ",");
	        ctx.print(")");
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitInvokeFunctionExpr = function (expr, ctx) {
	        expr.fn.visitExpression(this, ctx);
	        ctx.print("(");
	        this.visitAllExpressions(expr.args, ctx, ',');
	        ctx.print(")");
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitReadVarExpr = function (ast, ctx) {
	        var varName = ast.name;
	        if (lang_1.isPresent(ast.builtin)) {
	            switch (ast.builtin) {
	                case o.BuiltinVar.Super:
	                    varName = 'super';
	                    break;
	                case o.BuiltinVar.This:
	                    varName = 'this';
	                    break;
	                case o.BuiltinVar.CatchError:
	                    varName = exports.CATCH_ERROR_VAR.name;
	                    break;
	                case o.BuiltinVar.CatchStack:
	                    varName = exports.CATCH_STACK_VAR.name;
	                    break;
	                default:
	                    throw new exceptions_1.BaseException("Unknown builtin variable " + ast.builtin);
	            }
	        }
	        ctx.print(varName);
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitInstantiateExpr = function (ast, ctx) {
	        ctx.print("new ");
	        ast.classExpr.visitExpression(this, ctx);
	        ctx.print("(");
	        this.visitAllExpressions(ast.args, ctx, ',');
	        ctx.print(")");
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitLiteralExpr = function (ast, ctx) {
	        var value = ast.value;
	        if (lang_1.isString(value)) {
	            ctx.print(escapeSingleQuoteString(value, this._escapeDollarInStrings));
	        }
	        else if (lang_1.isBlank(value)) {
	            ctx.print('null');
	        }
	        else {
	            ctx.print("" + value);
	        }
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitConditionalExpr = function (ast, ctx) {
	        ctx.print("(");
	        ast.condition.visitExpression(this, ctx);
	        ctx.print('? ');
	        ast.trueCase.visitExpression(this, ctx);
	        ctx.print(': ');
	        ast.falseCase.visitExpression(this, ctx);
	        ctx.print(")");
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitNotExpr = function (ast, ctx) {
	        ctx.print('!');
	        ast.condition.visitExpression(this, ctx);
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitBinaryOperatorExpr = function (ast, ctx) {
	        var opStr;
	        switch (ast.operator) {
	            case o.BinaryOperator.Equals:
	                opStr = '==';
	                break;
	            case o.BinaryOperator.Identical:
	                opStr = '===';
	                break;
	            case o.BinaryOperator.NotEquals:
	                opStr = '!=';
	                break;
	            case o.BinaryOperator.NotIdentical:
	                opStr = '!==';
	                break;
	            case o.BinaryOperator.And:
	                opStr = '&&';
	                break;
	            case o.BinaryOperator.Or:
	                opStr = '||';
	                break;
	            case o.BinaryOperator.Plus:
	                opStr = '+';
	                break;
	            case o.BinaryOperator.Minus:
	                opStr = '-';
	                break;
	            case o.BinaryOperator.Divide:
	                opStr = '/';
	                break;
	            case o.BinaryOperator.Multiply:
	                opStr = '*';
	                break;
	            case o.BinaryOperator.Modulo:
	                opStr = '%';
	                break;
	            case o.BinaryOperator.Lower:
	                opStr = '<';
	                break;
	            case o.BinaryOperator.LowerEquals:
	                opStr = '<=';
	                break;
	            case o.BinaryOperator.Bigger:
	                opStr = '>';
	                break;
	            case o.BinaryOperator.BiggerEquals:
	                opStr = '>=';
	                break;
	            default:
	                throw new exceptions_1.BaseException("Unknown operator " + ast.operator);
	        }
	        ctx.print("(");
	        ast.lhs.visitExpression(this, ctx);
	        ctx.print(" " + opStr + " ");
	        ast.rhs.visitExpression(this, ctx);
	        ctx.print(")");
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitReadPropExpr = function (ast, ctx) {
	        ast.receiver.visitExpression(this, ctx);
	        ctx.print(".");
	        ctx.print(ast.name);
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitReadKeyExpr = function (ast, ctx) {
	        ast.receiver.visitExpression(this, ctx);
	        ctx.print("[");
	        ast.index.visitExpression(this, ctx);
	        ctx.print("]");
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitLiteralArrayExpr = function (ast, ctx) {
	        var useNewLine = ast.entries.length > 1;
	        ctx.print("[", useNewLine);
	        ctx.incIndent();
	        this.visitAllExpressions(ast.entries, ctx, ',', useNewLine);
	        ctx.decIndent();
	        ctx.print("]", useNewLine);
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitLiteralMapExpr = function (ast, ctx) {
	        var _this = this;
	        var useNewLine = ast.entries.length > 1;
	        ctx.print("{", useNewLine);
	        ctx.incIndent();
	        this.visitAllObjects(function (entry) {
	            ctx.print(escapeSingleQuoteString(entry[0], _this._escapeDollarInStrings) + ": ");
	            entry[1].visitExpression(_this, ctx);
	        }, ast.entries, ctx, ',', useNewLine);
	        ctx.decIndent();
	        ctx.print("}", useNewLine);
	        return null;
	    };
	    AbstractEmitterVisitor.prototype.visitAllExpressions = function (expressions, ctx, separator, newLine) {
	        var _this = this;
	        if (newLine === void 0) { newLine = false; }
	        this.visitAllObjects(function (expr) { return expr.visitExpression(_this, ctx); }, expressions, ctx, separator, newLine);
	    };
	    AbstractEmitterVisitor.prototype.visitAllObjects = function (handler, expressions, ctx, separator, newLine) {
	        if (newLine === void 0) { newLine = false; }
	        for (var i = 0; i < expressions.length; i++) {
	            if (i > 0) {
	                ctx.print(separator, newLine);
	            }
	            handler(expressions[i]);
	        }
	        if (newLine) {
	            ctx.println();
	        }
	    };
	    AbstractEmitterVisitor.prototype.visitAllStatements = function (statements, ctx) {
	        var _this = this;
	        statements.forEach(function (stmt) { return stmt.visitStatement(_this, ctx); });
	    };
	    return AbstractEmitterVisitor;
	}());
	exports.AbstractEmitterVisitor = AbstractEmitterVisitor;
	function escapeSingleQuoteString(input, escapeDollar) {
	    if (lang_1.isBlank(input)) {
	        return null;
	    }
	    var body = lang_1.StringWrapper.replaceAllMapped(input, _SINGLE_QUOTE_ESCAPE_STRING_RE, function (match) {
	        if (match[0] == '$') {
	            return escapeDollar ? '\\$' : '$';
	        }
	        else if (match[0] == '\n') {
	            return '\\n';
	        }
	        else if (match[0] == '\r') {
	            return '\\r';
	        }
	        else {
	            return "\\" + match[0];
	        }
	    });
	    return "'" + body + "'";
	}
	exports.escapeSingleQuoteString = escapeSingleQuoteString;
	function _createIndent(count) {
	    var res = '';
	    for (var i = 0; i < count; i++) {
	        res += '  ';
	    }
	    return res;
	}


/***/ },
/* 195 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var o = __webpack_require__(166);
	var abstract_emitter_1 = __webpack_require__(194);
	var AbstractJsEmitterVisitor = (function (_super) {
	    __extends(AbstractJsEmitterVisitor, _super);
	    function AbstractJsEmitterVisitor() {
	        _super.call(this, false);
	    }
	    AbstractJsEmitterVisitor.prototype.visitDeclareClassStmt = function (stmt, ctx) {
	        var _this = this;
	        ctx.pushClass(stmt);
	        this._visitClassConstructor(stmt, ctx);
	        if (lang_1.isPresent(stmt.parent)) {
	            ctx.print(stmt.name + ".prototype = Object.create(");
	            stmt.parent.visitExpression(this, ctx);
	            ctx.println(".prototype);");
	        }
	        stmt.getters.forEach(function (getter) { return _this._visitClassGetter(stmt, getter, ctx); });
	        stmt.methods.forEach(function (method) { return _this._visitClassMethod(stmt, method, ctx); });
	        ctx.popClass();
	        return null;
	    };
	    AbstractJsEmitterVisitor.prototype._visitClassConstructor = function (stmt, ctx) {
	        ctx.print("function " + stmt.name + "(");
	        if (lang_1.isPresent(stmt.constructorMethod)) {
	            this._visitParams(stmt.constructorMethod.params, ctx);
	        }
	        ctx.println(") {");
	        ctx.incIndent();
	        if (lang_1.isPresent(stmt.constructorMethod)) {
	            if (stmt.constructorMethod.body.length > 0) {
	                ctx.println("var self = this;");
	                this.visitAllStatements(stmt.constructorMethod.body, ctx);
	            }
	        }
	        ctx.decIndent();
	        ctx.println("}");
	    };
	    AbstractJsEmitterVisitor.prototype._visitClassGetter = function (stmt, getter, ctx) {
	        ctx.println("Object.defineProperty(" + stmt.name + ".prototype, '" + getter.name + "', { get: function() {");
	        ctx.incIndent();
	        if (getter.body.length > 0) {
	            ctx.println("var self = this;");
	            this.visitAllStatements(getter.body, ctx);
	        }
	        ctx.decIndent();
	        ctx.println("}});");
	    };
	    AbstractJsEmitterVisitor.prototype._visitClassMethod = function (stmt, method, ctx) {
	        ctx.print(stmt.name + ".prototype." + method.name + " = function(");
	        this._visitParams(method.params, ctx);
	        ctx.println(") {");
	        ctx.incIndent();
	        if (method.body.length > 0) {
	            ctx.println("var self = this;");
	            this.visitAllStatements(method.body, ctx);
	        }
	        ctx.decIndent();
	        ctx.println("};");
	    };
	    AbstractJsEmitterVisitor.prototype.visitReadVarExpr = function (ast, ctx) {
	        if (ast.builtin === o.BuiltinVar.This) {
	            ctx.print('self');
	        }
	        else if (ast.builtin === o.BuiltinVar.Super) {
	            throw new exceptions_1.BaseException("'super' needs to be handled at a parent ast node, not at the variable level!");
	        }
	        else {
	            _super.prototype.visitReadVarExpr.call(this, ast, ctx);
	        }
	        return null;
	    };
	    AbstractJsEmitterVisitor.prototype.visitDeclareVarStmt = function (stmt, ctx) {
	        ctx.print("var " + stmt.name + " = ");
	        stmt.value.visitExpression(this, ctx);
	        ctx.println(";");
	        return null;
	    };
	    AbstractJsEmitterVisitor.prototype.visitCastExpr = function (ast, ctx) {
	        ast.value.visitExpression(this, ctx);
	        return null;
	    };
	    AbstractJsEmitterVisitor.prototype.visitInvokeFunctionExpr = function (expr, ctx) {
	        var fnExpr = expr.fn;
	        if (fnExpr instanceof o.ReadVarExpr && fnExpr.builtin === o.BuiltinVar.Super) {
	            ctx.currentClass.parent.visitExpression(this, ctx);
	            ctx.print(".call(this");
	            if (expr.args.length > 0) {
	                ctx.print(", ");
	                this.visitAllExpressions(expr.args, ctx, ',');
	            }
	            ctx.print(")");
	        }
	        else {
	            _super.prototype.visitInvokeFunctionExpr.call(this, expr, ctx);
	        }
	        return null;
	    };
	    AbstractJsEmitterVisitor.prototype.visitFunctionExpr = function (ast, ctx) {
	        ctx.print("function(");
	        this._visitParams(ast.params, ctx);
	        ctx.println(") {");
	        ctx.incIndent();
	        this.visitAllStatements(ast.statements, ctx);
	        ctx.decIndent();
	        ctx.print("}");
	        return null;
	    };
	    AbstractJsEmitterVisitor.prototype.visitDeclareFunctionStmt = function (stmt, ctx) {
	        ctx.print("function " + stmt.name + "(");
	        this._visitParams(stmt.params, ctx);
	        ctx.println(") {");
	        ctx.incIndent();
	        this.visitAllStatements(stmt.statements, ctx);
	        ctx.decIndent();
	        ctx.println("}");
	        return null;
	    };
	    AbstractJsEmitterVisitor.prototype.visitTryCatchStmt = function (stmt, ctx) {
	        ctx.println("try {");
	        ctx.incIndent();
	        this.visitAllStatements(stmt.bodyStmts, ctx);
	        ctx.decIndent();
	        ctx.println("} catch (" + abstract_emitter_1.CATCH_ERROR_VAR.name + ") {");
	        ctx.incIndent();
	        var catchStmts = [
	            abstract_emitter_1.CATCH_STACK_VAR.set(abstract_emitter_1.CATCH_ERROR_VAR.prop('stack'))
	                .toDeclStmt(null, [o.StmtModifier.Final])
	        ].concat(stmt.catchStmts);
	        this.visitAllStatements(catchStmts, ctx);
	        ctx.decIndent();
	        ctx.println("}");
	        return null;
	    };
	    AbstractJsEmitterVisitor.prototype._visitParams = function (params, ctx) {
	        this.visitAllObjects(function (param) { return ctx.print(param.name); }, params, ctx, ',');
	    };
	    AbstractJsEmitterVisitor.prototype.getBuiltinMethodName = function (method) {
	        var name;
	        switch (method) {
	            case o.BuiltinMethod.ConcatArray:
	                name = 'concat';
	                break;
	            case o.BuiltinMethod.SubscribeObservable:
	                name = 'subscribe';
	                break;
	            case o.BuiltinMethod.bind:
	                name = 'bind';
	                break;
	            default:
	                throw new exceptions_1.BaseException("Unknown builtin method: " + method);
	        }
	        return name;
	    };
	    return AbstractJsEmitterVisitor;
	}(abstract_emitter_1.AbstractEmitterVisitor));
	exports.AbstractJsEmitterVisitor = AbstractJsEmitterVisitor;


/***/ },
/* 196 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var async_1 = __webpack_require__(41);
	var o = __webpack_require__(166);
	var reflection_1 = __webpack_require__(18);
	var exceptions_1 = __webpack_require__(12);
	var collection_1 = __webpack_require__(15);
	var dart_emitter_1 = __webpack_require__(197);
	var ts_emitter_1 = __webpack_require__(199);
	function interpretStatements(statements, resultVar, instanceFactory) {
	    var stmtsWithReturn = statements.concat([new o.ReturnStatement(o.variable(resultVar))]);
	    var ctx = new _ExecutionContext(null, null, null, null, new Map(), new Map(), new Map(), new Map(), instanceFactory);
	    var visitor = new StatementInterpreter();
	    var result = visitor.visitAllStatements(stmtsWithReturn, ctx);
	    return lang_1.isPresent(result) ? result.value : null;
	}
	exports.interpretStatements = interpretStatements;
	var DynamicInstance = (function () {
	    function DynamicInstance() {
	    }
	    Object.defineProperty(DynamicInstance.prototype, "props", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DynamicInstance.prototype, "getters", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DynamicInstance.prototype, "methods", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(DynamicInstance.prototype, "clazz", {
	        get: function () { return exceptions_1.unimplemented(); },
	        enumerable: true,
	        configurable: true
	    });
	    return DynamicInstance;
	}());
	exports.DynamicInstance = DynamicInstance;
	function isDynamicInstance(instance) {
	    if (lang_1.IS_DART) {
	        return instance instanceof DynamicInstance;
	    }
	    else {
	        return lang_1.isPresent(instance) && lang_1.isPresent(instance.props) && lang_1.isPresent(instance.getters) &&
	            lang_1.isPresent(instance.methods);
	    }
	}
	function _executeFunctionStatements(varNames, varValues, statements, ctx, visitor) {
	    var childCtx = ctx.createChildWihtLocalVars();
	    for (var i = 0; i < varNames.length; i++) {
	        childCtx.vars.set(varNames[i], varValues[i]);
	    }
	    var result = visitor.visitAllStatements(statements, childCtx);
	    return lang_1.isPresent(result) ? result.value : null;
	}
	var _ExecutionContext = (function () {
	    function _ExecutionContext(parent, superClass, superInstance, className, vars, props, getters, methods, instanceFactory) {
	        this.parent = parent;
	        this.superClass = superClass;
	        this.superInstance = superInstance;
	        this.className = className;
	        this.vars = vars;
	        this.props = props;
	        this.getters = getters;
	        this.methods = methods;
	        this.instanceFactory = instanceFactory;
	    }
	    _ExecutionContext.prototype.createChildWihtLocalVars = function () {
	        return new _ExecutionContext(this, this.superClass, this.superInstance, this.className, new Map(), this.props, this.getters, this.methods, this.instanceFactory);
	    };
	    return _ExecutionContext;
	}());
	var ReturnValue = (function () {
	    function ReturnValue(value) {
	        this.value = value;
	    }
	    return ReturnValue;
	}());
	var _DynamicClass = (function () {
	    function _DynamicClass(_classStmt, _ctx, _visitor) {
	        this._classStmt = _classStmt;
	        this._ctx = _ctx;
	        this._visitor = _visitor;
	    }
	    _DynamicClass.prototype.instantiate = function (args) {
	        var _this = this;
	        var props = new Map();
	        var getters = new Map();
	        var methods = new Map();
	        var superClass = this._classStmt.parent.visitExpression(this._visitor, this._ctx);
	        var instanceCtx = new _ExecutionContext(this._ctx, superClass, null, this._classStmt.name, this._ctx.vars, props, getters, methods, this._ctx.instanceFactory);
	        this._classStmt.fields.forEach(function (field) { props.set(field.name, null); });
	        this._classStmt.getters.forEach(function (getter) {
	            getters.set(getter.name, function () { return _executeFunctionStatements([], [], getter.body, instanceCtx, _this._visitor); });
	        });
	        this._classStmt.methods.forEach(function (method) {
	            var paramNames = method.params.map(function (param) { return param.name; });
	            methods.set(method.name, _declareFn(paramNames, method.body, instanceCtx, _this._visitor));
	        });
	        var ctorParamNames = this._classStmt.constructorMethod.params.map(function (param) { return param.name; });
	        _executeFunctionStatements(ctorParamNames, args, this._classStmt.constructorMethod.body, instanceCtx, this._visitor);
	        return instanceCtx.superInstance;
	    };
	    _DynamicClass.prototype.debugAst = function () { return this._visitor.debugAst(this._classStmt); };
	    return _DynamicClass;
	}());
	var StatementInterpreter = (function () {
	    function StatementInterpreter() {
	    }
	    StatementInterpreter.prototype.debugAst = function (ast) {
	        return lang_1.IS_DART ? dart_emitter_1.debugOutputAstAsDart(ast) : ts_emitter_1.debugOutputAstAsTypeScript(ast);
	    };
	    StatementInterpreter.prototype.visitDeclareVarStmt = function (stmt, ctx) {
	        ctx.vars.set(stmt.name, stmt.value.visitExpression(this, ctx));
	        return null;
	    };
	    StatementInterpreter.prototype.visitWriteVarExpr = function (expr, ctx) {
	        var value = expr.value.visitExpression(this, ctx);
	        var currCtx = ctx;
	        while (currCtx != null) {
	            if (currCtx.vars.has(expr.name)) {
	                currCtx.vars.set(expr.name, value);
	                return value;
	            }
	            currCtx = currCtx.parent;
	        }
	        throw new exceptions_1.BaseException("Not declared variable " + expr.name);
	    };
	    StatementInterpreter.prototype.visitReadVarExpr = function (ast, ctx) {
	        var varName = ast.name;
	        if (lang_1.isPresent(ast.builtin)) {
	            switch (ast.builtin) {
	                case o.BuiltinVar.Super:
	                case o.BuiltinVar.This:
	                    return ctx.superInstance;
	                case o.BuiltinVar.CatchError:
	                    varName = CATCH_ERROR_VAR;
	                    break;
	                case o.BuiltinVar.CatchStack:
	                    varName = CATCH_STACK_VAR;
	                    break;
	                default:
	                    throw new exceptions_1.BaseException("Unknown builtin variable " + ast.builtin);
	            }
	        }
	        var currCtx = ctx;
	        while (currCtx != null) {
	            if (currCtx.vars.has(varName)) {
	                return currCtx.vars.get(varName);
	            }
	            currCtx = currCtx.parent;
	        }
	        throw new exceptions_1.BaseException("Not declared variable " + varName);
	    };
	    StatementInterpreter.prototype.visitWriteKeyExpr = function (expr, ctx) {
	        var receiver = expr.receiver.visitExpression(this, ctx);
	        var index = expr.index.visitExpression(this, ctx);
	        var value = expr.value.visitExpression(this, ctx);
	        receiver[index] = value;
	        return value;
	    };
	    StatementInterpreter.prototype.visitWritePropExpr = function (expr, ctx) {
	        var receiver = expr.receiver.visitExpression(this, ctx);
	        var value = expr.value.visitExpression(this, ctx);
	        if (isDynamicInstance(receiver)) {
	            var di = receiver;
	            if (di.props.has(expr.name)) {
	                di.props.set(expr.name, value);
	            }
	            else {
	                reflection_1.reflector.setter(expr.name)(receiver, value);
	            }
	        }
	        else {
	            reflection_1.reflector.setter(expr.name)(receiver, value);
	        }
	        return value;
	    };
	    StatementInterpreter.prototype.visitInvokeMethodExpr = function (expr, ctx) {
	        var receiver = expr.receiver.visitExpression(this, ctx);
	        var args = this.visitAllExpressions(expr.args, ctx);
	        var result;
	        if (lang_1.isPresent(expr.builtin)) {
	            switch (expr.builtin) {
	                case o.BuiltinMethod.ConcatArray:
	                    result = collection_1.ListWrapper.concat(receiver, args[0]);
	                    break;
	                case o.BuiltinMethod.SubscribeObservable:
	                    result = async_1.ObservableWrapper.subscribe(receiver, args[0]);
	                    break;
	                case o.BuiltinMethod.bind:
	                    if (lang_1.IS_DART) {
	                        result = receiver;
	                    }
	                    else {
	                        result = receiver.bind(args[0]);
	                    }
	                    break;
	                default:
	                    throw new exceptions_1.BaseException("Unknown builtin method " + expr.builtin);
	            }
	        }
	        else if (isDynamicInstance(receiver)) {
	            var di = receiver;
	            if (di.methods.has(expr.name)) {
	                result = lang_1.FunctionWrapper.apply(di.methods.get(expr.name), args);
	            }
	            else {
	                result = reflection_1.reflector.method(expr.name)(receiver, args);
	            }
	        }
	        else {
	            result = reflection_1.reflector.method(expr.name)(receiver, args);
	        }
	        return result;
	    };
	    StatementInterpreter.prototype.visitInvokeFunctionExpr = function (stmt, ctx) {
	        var args = this.visitAllExpressions(stmt.args, ctx);
	        var fnExpr = stmt.fn;
	        if (fnExpr instanceof o.ReadVarExpr && fnExpr.builtin === o.BuiltinVar.Super) {
	            ctx.superInstance = ctx.instanceFactory.createInstance(ctx.superClass, ctx.className, args, ctx.props, ctx.getters, ctx.methods);
	            ctx.parent.superInstance = ctx.superInstance;
	            return null;
	        }
	        else {
	            var fn = stmt.fn.visitExpression(this, ctx);
	            return lang_1.FunctionWrapper.apply(fn, args);
	        }
	    };
	    StatementInterpreter.prototype.visitReturnStmt = function (stmt, ctx) {
	        return new ReturnValue(stmt.value.visitExpression(this, ctx));
	    };
	    StatementInterpreter.prototype.visitDeclareClassStmt = function (stmt, ctx) {
	        var clazz = new _DynamicClass(stmt, ctx, this);
	        ctx.vars.set(stmt.name, clazz);
	        return null;
	    };
	    StatementInterpreter.prototype.visitExpressionStmt = function (stmt, ctx) {
	        return stmt.expr.visitExpression(this, ctx);
	    };
	    StatementInterpreter.prototype.visitIfStmt = function (stmt, ctx) {
	        var condition = stmt.condition.visitExpression(this, ctx);
	        if (condition) {
	            return this.visitAllStatements(stmt.trueCase, ctx);
	        }
	        else if (lang_1.isPresent(stmt.falseCase)) {
	            return this.visitAllStatements(stmt.falseCase, ctx);
	        }
	        return null;
	    };
	    StatementInterpreter.prototype.visitTryCatchStmt = function (stmt, ctx) {
	        try {
	            return this.visitAllStatements(stmt.bodyStmts, ctx);
	        }
	        catch (e) {
	            var childCtx = ctx.createChildWihtLocalVars();
	            childCtx.vars.set(CATCH_ERROR_VAR, e);
	            childCtx.vars.set(CATCH_STACK_VAR, e.stack);
	            return this.visitAllStatements(stmt.catchStmts, childCtx);
	        }
	    };
	    StatementInterpreter.prototype.visitThrowStmt = function (stmt, ctx) {
	        throw stmt.error.visitExpression(this, ctx);
	    };
	    StatementInterpreter.prototype.visitCommentStmt = function (stmt, context) { return null; };
	    StatementInterpreter.prototype.visitInstantiateExpr = function (ast, ctx) {
	        var args = this.visitAllExpressions(ast.args, ctx);
	        var clazz = ast.classExpr.visitExpression(this, ctx);
	        if (clazz instanceof _DynamicClass) {
	            return clazz.instantiate(args);
	        }
	        else {
	            return lang_1.FunctionWrapper.apply(reflection_1.reflector.factory(clazz), args);
	        }
	    };
	    StatementInterpreter.prototype.visitLiteralExpr = function (ast, ctx) { return ast.value; };
	    StatementInterpreter.prototype.visitExternalExpr = function (ast, ctx) { return ast.value.runtime; };
	    StatementInterpreter.prototype.visitConditionalExpr = function (ast, ctx) {
	        if (ast.condition.visitExpression(this, ctx)) {
	            return ast.trueCase.visitExpression(this, ctx);
	        }
	        else if (lang_1.isPresent(ast.falseCase)) {
	            return ast.falseCase.visitExpression(this, ctx);
	        }
	        return null;
	    };
	    StatementInterpreter.prototype.visitNotExpr = function (ast, ctx) {
	        return !ast.condition.visitExpression(this, ctx);
	    };
	    StatementInterpreter.prototype.visitCastExpr = function (ast, ctx) {
	        return ast.value.visitExpression(this, ctx);
	    };
	    StatementInterpreter.prototype.visitFunctionExpr = function (ast, ctx) {
	        var paramNames = ast.params.map(function (param) { return param.name; });
	        return _declareFn(paramNames, ast.statements, ctx, this);
	    };
	    StatementInterpreter.prototype.visitDeclareFunctionStmt = function (stmt, ctx) {
	        var paramNames = stmt.params.map(function (param) { return param.name; });
	        ctx.vars.set(stmt.name, _declareFn(paramNames, stmt.statements, ctx, this));
	        return null;
	    };
	    StatementInterpreter.prototype.visitBinaryOperatorExpr = function (ast, ctx) {
	        var _this = this;
	        var lhs = function () { return ast.lhs.visitExpression(_this, ctx); };
	        var rhs = function () { return ast.rhs.visitExpression(_this, ctx); };
	        switch (ast.operator) {
	            case o.BinaryOperator.Equals:
	                return lhs() == rhs();
	            case o.BinaryOperator.Identical:
	                return lhs() === rhs();
	            case o.BinaryOperator.NotEquals:
	                return lhs() != rhs();
	            case o.BinaryOperator.NotIdentical:
	                return lhs() !== rhs();
	            case o.BinaryOperator.And:
	                return lhs() && rhs();
	            case o.BinaryOperator.Or:
	                return lhs() || rhs();
	            case o.BinaryOperator.Plus:
	                return lhs() + rhs();
	            case o.BinaryOperator.Minus:
	                return lhs() - rhs();
	            case o.BinaryOperator.Divide:
	                return lhs() / rhs();
	            case o.BinaryOperator.Multiply:
	                return lhs() * rhs();
	            case o.BinaryOperator.Modulo:
	                return lhs() % rhs();
	            case o.BinaryOperator.Lower:
	                return lhs() < rhs();
	            case o.BinaryOperator.LowerEquals:
	                return lhs() <= rhs();
	            case o.BinaryOperator.Bigger:
	                return lhs() > rhs();
	            case o.BinaryOperator.BiggerEquals:
	                return lhs() >= rhs();
	            default:
	                throw new exceptions_1.BaseException("Unknown operator " + ast.operator);
	        }
	    };
	    StatementInterpreter.prototype.visitReadPropExpr = function (ast, ctx) {
	        var result;
	        var receiver = ast.receiver.visitExpression(this, ctx);
	        if (isDynamicInstance(receiver)) {
	            var di = receiver;
	            if (di.props.has(ast.name)) {
	                result = di.props.get(ast.name);
	            }
	            else if (di.getters.has(ast.name)) {
	                result = di.getters.get(ast.name)();
	            }
	            else if (di.methods.has(ast.name)) {
	                result = di.methods.get(ast.name);
	            }
	            else {
	                result = reflection_1.reflector.getter(ast.name)(receiver);
	            }
	        }
	        else {
	            result = reflection_1.reflector.getter(ast.name)(receiver);
	        }
	        return result;
	    };
	    StatementInterpreter.prototype.visitReadKeyExpr = function (ast, ctx) {
	        var receiver = ast.receiver.visitExpression(this, ctx);
	        var prop = ast.index.visitExpression(this, ctx);
	        return receiver[prop];
	    };
	    StatementInterpreter.prototype.visitLiteralArrayExpr = function (ast, ctx) {
	        return this.visitAllExpressions(ast.entries, ctx);
	    };
	    StatementInterpreter.prototype.visitLiteralMapExpr = function (ast, ctx) {
	        var _this = this;
	        var result = {};
	        ast.entries.forEach(function (entry) { return result[entry[0]] =
	            entry[1].visitExpression(_this, ctx); });
	        return result;
	    };
	    StatementInterpreter.prototype.visitAllExpressions = function (expressions, ctx) {
	        var _this = this;
	        return expressions.map(function (expr) { return expr.visitExpression(_this, ctx); });
	    };
	    StatementInterpreter.prototype.visitAllStatements = function (statements, ctx) {
	        for (var i = 0; i < statements.length; i++) {
	            var stmt = statements[i];
	            var val = stmt.visitStatement(this, ctx);
	            if (val instanceof ReturnValue) {
	                return val;
	            }
	        }
	        return null;
	    };
	    return StatementInterpreter;
	}());
	function _declareFn(varNames, statements, ctx, visitor) {
	    switch (varNames.length) {
	        case 0:
	            return function () { return _executeFunctionStatements(varNames, [], statements, ctx, visitor); };
	        case 1:
	            return function (d0) { return _executeFunctionStatements(varNames, [d0], statements, ctx, visitor); };
	        case 2:
	            return function (d0, d1) { return _executeFunctionStatements(varNames, [d0, d1], statements, ctx, visitor); };
	        case 3:
	            return function (d0, d1, d2) {
	                return _executeFunctionStatements(varNames, [d0, d1, d2], statements, ctx, visitor);
	            };
	        case 4:
	            return function (d0, d1, d2, d3) {
	                return _executeFunctionStatements(varNames, [d0, d1, d2, d3], statements, ctx, visitor);
	            };
	        case 5:
	            return function (d0, d1, d2, d3, d4) { return _executeFunctionStatements(varNames, [d0, d1, d2, d3, d4], statements, ctx, visitor); };
	        case 6:
	            return function (d0, d1, d2, d3, d4, d5) { return _executeFunctionStatements(varNames, [d0, d1, d2, d3, d4, d5], statements, ctx, visitor); };
	        case 7:
	            return function (d0, d1, d2, d3, d4, d5, d6) { return _executeFunctionStatements(varNames, [d0, d1, d2, d3, d4, d5, d6], statements, ctx, visitor); };
	        case 8:
	            return function (d0, d1, d2, d3, d4, d5, d6, d7) { return _executeFunctionStatements(varNames, [d0, d1, d2, d3, d4, d5, d6, d7], statements, ctx, visitor); };
	        case 9:
	            return function (d0, d1, d2, d3, d4, d5, d6, d7, d8) { return _executeFunctionStatements(varNames, [d0, d1, d2, d3, d4, d5, d6, d7, d8], statements, ctx, visitor); };
	        case 10:
	            return function (d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) { return _executeFunctionStatements(varNames, [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], statements, ctx, visitor); };
	        default:
	            throw new exceptions_1.BaseException('Declaring functions with more than 10 arguments is not supported right now');
	    }
	}
	var CATCH_ERROR_VAR = 'error';
	var CATCH_STACK_VAR = 'stack';


/***/ },
/* 197 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var o = __webpack_require__(166);
	var abstract_emitter_1 = __webpack_require__(194);
	var path_util_1 = __webpack_require__(198);
	var _debugModuleUrl = 'asset://debug/lib';
	function debugOutputAstAsDart(ast) {
	    var converter = new _DartEmitterVisitor(_debugModuleUrl);
	    var ctx = abstract_emitter_1.EmitterVisitorContext.createRoot([]);
	    var asts;
	    if (lang_1.isArray(ast)) {
	        asts = ast;
	    }
	    else {
	        asts = [ast];
	    }
	    asts.forEach(function (ast) {
	        if (ast instanceof o.Statement) {
	            ast.visitStatement(converter, ctx);
	        }
	        else if (ast instanceof o.Expression) {
	            ast.visitExpression(converter, ctx);
	        }
	        else if (ast instanceof o.Type) {
	            ast.visitType(converter, ctx);
	        }
	        else {
	            throw new exceptions_1.BaseException("Don't know how to print debug info for " + ast);
	        }
	    });
	    return ctx.toSource();
	}
	exports.debugOutputAstAsDart = debugOutputAstAsDart;
	var DartEmitter = (function () {
	    function DartEmitter() {
	    }
	    DartEmitter.prototype.emitStatements = function (moduleUrl, stmts, exportedVars) {
	        var srcParts = [];
	        // Note: We are not creating a library here as Dart does not need it.
	        // Dart analzyer might complain about it though.
	        var converter = new _DartEmitterVisitor(moduleUrl);
	        var ctx = abstract_emitter_1.EmitterVisitorContext.createRoot(exportedVars);
	        converter.visitAllStatements(stmts, ctx);
	        converter.importsWithPrefixes.forEach(function (prefix, importedModuleUrl) {
	            srcParts.push("import '" + path_util_1.getImportModulePath(moduleUrl, importedModuleUrl, path_util_1.ImportEnv.Dart) + "' as " + prefix + ";");
	        });
	        srcParts.push(ctx.toSource());
	        return srcParts.join('\n');
	    };
	    return DartEmitter;
	}());
	exports.DartEmitter = DartEmitter;
	var _DartEmitterVisitor = (function (_super) {
	    __extends(_DartEmitterVisitor, _super);
	    function _DartEmitterVisitor(_moduleUrl) {
	        _super.call(this, true);
	        this._moduleUrl = _moduleUrl;
	        this.importsWithPrefixes = new Map();
	    }
	    _DartEmitterVisitor.prototype.visitExternalExpr = function (ast, ctx) {
	        this._visitIdentifier(ast.value, ast.typeParams, ctx);
	        return null;
	    };
	    _DartEmitterVisitor.prototype.visitDeclareVarStmt = function (stmt, ctx) {
	        if (stmt.hasModifier(o.StmtModifier.Final)) {
	            if (isConstType(stmt.type)) {
	                ctx.print("const ");
	            }
	            else {
	                ctx.print("final ");
	            }
	        }
	        else if (lang_1.isBlank(stmt.type)) {
	            ctx.print("var ");
	        }
	        if (lang_1.isPresent(stmt.type)) {
	            stmt.type.visitType(this, ctx);
	            ctx.print(" ");
	        }
	        ctx.print(stmt.name + " = ");
	        stmt.value.visitExpression(this, ctx);
	        ctx.println(";");
	        return null;
	    };
	    _DartEmitterVisitor.prototype.visitCastExpr = function (ast, ctx) {
	        ctx.print("(");
	        ast.value.visitExpression(this, ctx);
	        ctx.print(" as ");
	        ast.type.visitType(this, ctx);
	        ctx.print(")");
	        return null;
	    };
	    _DartEmitterVisitor.prototype.visitDeclareClassStmt = function (stmt, ctx) {
	        var _this = this;
	        ctx.pushClass(stmt);
	        ctx.print("class " + stmt.name);
	        if (lang_1.isPresent(stmt.parent)) {
	            ctx.print(" extends ");
	            stmt.parent.visitExpression(this, ctx);
	        }
	        ctx.println(" {");
	        ctx.incIndent();
	        stmt.fields.forEach(function (field) { return _this._visitClassField(field, ctx); });
	        if (lang_1.isPresent(stmt.constructorMethod)) {
	            this._visitClassConstructor(stmt, ctx);
	        }
	        stmt.getters.forEach(function (getter) { return _this._visitClassGetter(getter, ctx); });
	        stmt.methods.forEach(function (method) { return _this._visitClassMethod(method, ctx); });
	        ctx.decIndent();
	        ctx.println("}");
	        ctx.popClass();
	        return null;
	    };
	    _DartEmitterVisitor.prototype._visitClassField = function (field, ctx) {
	        if (field.hasModifier(o.StmtModifier.Final)) {
	            ctx.print("final ");
	        }
	        else if (lang_1.isBlank(field.type)) {
	            ctx.print("var ");
	        }
	        if (lang_1.isPresent(field.type)) {
	            field.type.visitType(this, ctx);
	            ctx.print(" ");
	        }
	        ctx.println(field.name + ";");
	    };
	    _DartEmitterVisitor.prototype._visitClassGetter = function (getter, ctx) {
	        if (lang_1.isPresent(getter.type)) {
	            getter.type.visitType(this, ctx);
	            ctx.print(" ");
	        }
	        ctx.println("get " + getter.name + " {");
	        ctx.incIndent();
	        this.visitAllStatements(getter.body, ctx);
	        ctx.decIndent();
	        ctx.println("}");
	    };
	    _DartEmitterVisitor.prototype._visitClassConstructor = function (stmt, ctx) {
	        ctx.print(stmt.name + "(");
	        this._visitParams(stmt.constructorMethod.params, ctx);
	        ctx.print(")");
	        var ctorStmts = stmt.constructorMethod.body;
	        var superCtorExpr = ctorStmts.length > 0 ? getSuperConstructorCallExpr(ctorStmts[0]) : null;
	        if (lang_1.isPresent(superCtorExpr)) {
	            ctx.print(": ");
	            superCtorExpr.visitExpression(this, ctx);
	            ctorStmts = ctorStmts.slice(1);
	        }
	        ctx.println(" {");
	        ctx.incIndent();
	        this.visitAllStatements(ctorStmts, ctx);
	        ctx.decIndent();
	        ctx.println("}");
	    };
	    _DartEmitterVisitor.prototype._visitClassMethod = function (method, ctx) {
	        if (lang_1.isPresent(method.type)) {
	            method.type.visitType(this, ctx);
	        }
	        else {
	            ctx.print("void");
	        }
	        ctx.print(" " + method.name + "(");
	        this._visitParams(method.params, ctx);
	        ctx.println(") {");
	        ctx.incIndent();
	        this.visitAllStatements(method.body, ctx);
	        ctx.decIndent();
	        ctx.println("}");
	    };
	    _DartEmitterVisitor.prototype.visitFunctionExpr = function (ast, ctx) {
	        ctx.print("(");
	        this._visitParams(ast.params, ctx);
	        ctx.println(") {");
	        ctx.incIndent();
	        this.visitAllStatements(ast.statements, ctx);
	        ctx.decIndent();
	        ctx.print("}");
	        return null;
	    };
	    _DartEmitterVisitor.prototype.visitDeclareFunctionStmt = function (stmt, ctx) {
	        if (lang_1.isPresent(stmt.type)) {
	            stmt.type.visitType(this, ctx);
	        }
	        else {
	            ctx.print("void");
	        }
	        ctx.print(" " + stmt.name + "(");
	        this._visitParams(stmt.params, ctx);
	        ctx.println(") {");
	        ctx.incIndent();
	        this.visitAllStatements(stmt.statements, ctx);
	        ctx.decIndent();
	        ctx.println("}");
	        return null;
	    };
	    _DartEmitterVisitor.prototype.getBuiltinMethodName = function (method) {
	        var name;
	        switch (method) {
	            case o.BuiltinMethod.ConcatArray:
	                name = '.addAll';
	                break;
	            case o.BuiltinMethod.SubscribeObservable:
	                name = 'listen';
	                break;
	            case o.BuiltinMethod.bind:
	                name = null;
	                break;
	            default:
	                throw new exceptions_1.BaseException("Unknown builtin method: " + method);
	        }
	        return name;
	    };
	    _DartEmitterVisitor.prototype.visitTryCatchStmt = function (stmt, ctx) {
	        ctx.println("try {");
	        ctx.incIndent();
	        this.visitAllStatements(stmt.bodyStmts, ctx);
	        ctx.decIndent();
	        ctx.println("} catch (" + abstract_emitter_1.CATCH_ERROR_VAR.name + ", " + abstract_emitter_1.CATCH_STACK_VAR.name + ") {");
	        ctx.incIndent();
	        this.visitAllStatements(stmt.catchStmts, ctx);
	        ctx.decIndent();
	        ctx.println("}");
	        return null;
	    };
	    _DartEmitterVisitor.prototype.visitBinaryOperatorExpr = function (ast, ctx) {
	        switch (ast.operator) {
	            case o.BinaryOperator.Identical:
	                ctx.print("identical(");
	                ast.lhs.visitExpression(this, ctx);
	                ctx.print(", ");
	                ast.rhs.visitExpression(this, ctx);
	                ctx.print(")");
	                break;
	            case o.BinaryOperator.NotIdentical:
	                ctx.print("!identical(");
	                ast.lhs.visitExpression(this, ctx);
	                ctx.print(", ");
	                ast.rhs.visitExpression(this, ctx);
	                ctx.print(")");
	                break;
	            default:
	                _super.prototype.visitBinaryOperatorExpr.call(this, ast, ctx);
	        }
	        return null;
	    };
	    _DartEmitterVisitor.prototype.visitLiteralArrayExpr = function (ast, ctx) {
	        if (isConstType(ast.type)) {
	            ctx.print("const ");
	        }
	        return _super.prototype.visitLiteralArrayExpr.call(this, ast, ctx);
	    };
	    _DartEmitterVisitor.prototype.visitLiteralMapExpr = function (ast, ctx) {
	        if (isConstType(ast.type)) {
	            ctx.print("const ");
	        }
	        if (lang_1.isPresent(ast.valueType)) {
	            ctx.print("<String, ");
	            ast.valueType.visitType(this, ctx);
	            ctx.print(">");
	        }
	        return _super.prototype.visitLiteralMapExpr.call(this, ast, ctx);
	    };
	    _DartEmitterVisitor.prototype.visitInstantiateExpr = function (ast, ctx) {
	        ctx.print(isConstType(ast.type) ? "const" : "new");
	        ctx.print(' ');
	        ast.classExpr.visitExpression(this, ctx);
	        ctx.print("(");
	        this.visitAllExpressions(ast.args, ctx, ",");
	        ctx.print(")");
	        return null;
	    };
	    _DartEmitterVisitor.prototype.visitBuiltintType = function (type, ctx) {
	        var typeStr;
	        switch (type.name) {
	            case o.BuiltinTypeName.Bool:
	                typeStr = 'bool';
	                break;
	            case o.BuiltinTypeName.Dynamic:
	                typeStr = 'dynamic';
	                break;
	            case o.BuiltinTypeName.Function:
	                typeStr = 'Function';
	                break;
	            case o.BuiltinTypeName.Number:
	                typeStr = 'num';
	                break;
	            case o.BuiltinTypeName.Int:
	                typeStr = 'int';
	                break;
	            case o.BuiltinTypeName.String:
	                typeStr = 'String';
	                break;
	            default:
	                throw new exceptions_1.BaseException("Unsupported builtin type " + type.name);
	        }
	        ctx.print(typeStr);
	        return null;
	    };
	    _DartEmitterVisitor.prototype.visitExternalType = function (ast, ctx) {
	        this._visitIdentifier(ast.value, ast.typeParams, ctx);
	        return null;
	    };
	    _DartEmitterVisitor.prototype.visitArrayType = function (type, ctx) {
	        ctx.print("List<");
	        if (lang_1.isPresent(type.of)) {
	            type.of.visitType(this, ctx);
	        }
	        else {
	            ctx.print("dynamic");
	        }
	        ctx.print(">");
	        return null;
	    };
	    _DartEmitterVisitor.prototype.visitMapType = function (type, ctx) {
	        ctx.print("Map<String, ");
	        if (lang_1.isPresent(type.valueType)) {
	            type.valueType.visitType(this, ctx);
	        }
	        else {
	            ctx.print("dynamic");
	        }
	        ctx.print(">");
	        return null;
	    };
	    _DartEmitterVisitor.prototype._visitParams = function (params, ctx) {
	        var _this = this;
	        this.visitAllObjects(function (param) {
	            if (lang_1.isPresent(param.type)) {
	                param.type.visitType(_this, ctx);
	                ctx.print(' ');
	            }
	            ctx.print(param.name);
	        }, params, ctx, ',');
	    };
	    _DartEmitterVisitor.prototype._visitIdentifier = function (value, typeParams, ctx) {
	        var _this = this;
	        if (lang_1.isBlank(value.name)) {
	            throw new exceptions_1.BaseException("Internal error: unknown identifier " + value);
	        }
	        if (lang_1.isPresent(value.moduleUrl) && value.moduleUrl != this._moduleUrl) {
	            var prefix = this.importsWithPrefixes.get(value.moduleUrl);
	            if (lang_1.isBlank(prefix)) {
	                prefix = "import" + this.importsWithPrefixes.size;
	                this.importsWithPrefixes.set(value.moduleUrl, prefix);
	            }
	            ctx.print(prefix + ".");
	        }
	        ctx.print(value.name);
	        if (lang_1.isPresent(typeParams) && typeParams.length > 0) {
	            ctx.print("<");
	            this.visitAllObjects(function (type) { return type.visitType(_this, ctx); }, typeParams, ctx, ',');
	            ctx.print(">");
	        }
	    };
	    return _DartEmitterVisitor;
	}(abstract_emitter_1.AbstractEmitterVisitor));
	function getSuperConstructorCallExpr(stmt) {
	    if (stmt instanceof o.ExpressionStatement) {
	        var expr = stmt.expr;
	        if (expr instanceof o.InvokeFunctionExpr) {
	            var fn = expr.fn;
	            if (fn instanceof o.ReadVarExpr) {
	                if (fn.builtin === o.BuiltinVar.Super) {
	                    return expr;
	                }
	            }
	        }
	    }
	    return null;
	}
	function isConstType(type) {
	    return lang_1.isPresent(type) && type.hasModifier(o.TypeModifier.Const);
	}


/***/ },
/* 198 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var exceptions_1 = __webpack_require__(12);
	var lang_1 = __webpack_require__(5);
	// asset:<package-name>/<realm>/<path-to-module>
	var _ASSET_URL_RE = /asset:([^\/]+)\/([^\/]+)\/(.+)/g;
	var _PATH_SEP = '/';
	var _PATH_SEP_RE = /\//g;
	(function (ImportEnv) {
	    ImportEnv[ImportEnv["Dart"] = 0] = "Dart";
	    ImportEnv[ImportEnv["JS"] = 1] = "JS";
	})(exports.ImportEnv || (exports.ImportEnv = {}));
	var ImportEnv = exports.ImportEnv;
	/**
	 * Returns the module path to use for an import.
	 */
	function getImportModulePath(moduleUrlStr, importedUrlStr, importEnv) {
	    var absolutePathPrefix = importEnv === ImportEnv.Dart ? "package:" : '';
	    var moduleUrl = _AssetUrl.parse(moduleUrlStr, false);
	    var importedUrl = _AssetUrl.parse(importedUrlStr, true);
	    if (lang_1.isBlank(importedUrl)) {
	        return importedUrlStr;
	    }
	    // Try to create a relative path first
	    if (moduleUrl.firstLevelDir == importedUrl.firstLevelDir &&
	        moduleUrl.packageName == importedUrl.packageName) {
	        return getRelativePath(moduleUrl.modulePath, importedUrl.modulePath, importEnv);
	    }
	    else if (importedUrl.firstLevelDir == 'lib') {
	        return "" + absolutePathPrefix + importedUrl.packageName + "/" + importedUrl.modulePath;
	    }
	    throw new exceptions_1.BaseException("Can't import url " + importedUrlStr + " from " + moduleUrlStr);
	}
	exports.getImportModulePath = getImportModulePath;
	var _AssetUrl = (function () {
	    function _AssetUrl(packageName, firstLevelDir, modulePath) {
	        this.packageName = packageName;
	        this.firstLevelDir = firstLevelDir;
	        this.modulePath = modulePath;
	    }
	    _AssetUrl.parse = function (url, allowNonMatching) {
	        var match = lang_1.RegExpWrapper.firstMatch(_ASSET_URL_RE, url);
	        if (lang_1.isPresent(match)) {
	            return new _AssetUrl(match[1], match[2], match[3]);
	        }
	        if (allowNonMatching) {
	            return null;
	        }
	        throw new exceptions_1.BaseException("Url " + url + " is not a valid asset: url");
	    };
	    return _AssetUrl;
	}());
	function getRelativePath(modulePath, importedPath, importEnv) {
	    var moduleParts = modulePath.split(_PATH_SEP_RE);
	    var importedParts = importedPath.split(_PATH_SEP_RE);
	    var longestPrefix = getLongestPathSegmentPrefix(moduleParts, importedParts);
	    var resultParts = [];
	    var goParentCount = moduleParts.length - 1 - longestPrefix;
	    for (var i = 0; i < goParentCount; i++) {
	        resultParts.push('..');
	    }
	    if (goParentCount <= 0 && importEnv === ImportEnv.JS) {
	        resultParts.push('.');
	    }
	    for (var i = longestPrefix; i < importedParts.length; i++) {
	        resultParts.push(importedParts[i]);
	    }
	    return resultParts.join(_PATH_SEP);
	}
	exports.getRelativePath = getRelativePath;
	function getLongestPathSegmentPrefix(arr1, arr2) {
	    var prefixSize = 0;
	    var minLen = lang_1.Math.min(arr1.length, arr2.length);
	    while (prefixSize < minLen && arr1[prefixSize] == arr2[prefixSize]) {
	        prefixSize++;
	    }
	    return prefixSize;
	}
	exports.getLongestPathSegmentPrefix = getLongestPathSegmentPrefix;


/***/ },
/* 199 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var o = __webpack_require__(166);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var abstract_emitter_1 = __webpack_require__(194);
	var path_util_1 = __webpack_require__(198);
	var _debugModuleUrl = 'asset://debug/lib';
	function debugOutputAstAsTypeScript(ast) {
	    var converter = new _TsEmitterVisitor(_debugModuleUrl);
	    var ctx = abstract_emitter_1.EmitterVisitorContext.createRoot([]);
	    var asts;
	    if (lang_1.isArray(ast)) {
	        asts = ast;
	    }
	    else {
	        asts = [ast];
	    }
	    asts.forEach(function (ast) {
	        if (ast instanceof o.Statement) {
	            ast.visitStatement(converter, ctx);
	        }
	        else if (ast instanceof o.Expression) {
	            ast.visitExpression(converter, ctx);
	        }
	        else if (ast instanceof o.Type) {
	            ast.visitType(converter, ctx);
	        }
	        else {
	            throw new exceptions_1.BaseException("Don't know how to print debug info for " + ast);
	        }
	    });
	    return ctx.toSource();
	}
	exports.debugOutputAstAsTypeScript = debugOutputAstAsTypeScript;
	var TypeScriptEmitter = (function () {
	    function TypeScriptEmitter() {
	    }
	    TypeScriptEmitter.prototype.emitStatements = function (moduleUrl, stmts, exportedVars) {
	        var converter = new _TsEmitterVisitor(moduleUrl);
	        var ctx = abstract_emitter_1.EmitterVisitorContext.createRoot(exportedVars);
	        converter.visitAllStatements(stmts, ctx);
	        var srcParts = [];
	        converter.importsWithPrefixes.forEach(function (prefix, importedModuleUrl) {
	            // Note: can't write the real word for import as it screws up system.js auto detection...
	            srcParts.push("imp" +
	                ("ort * as " + prefix + " from '" + path_util_1.getImportModulePath(moduleUrl, importedModuleUrl, path_util_1.ImportEnv.JS) + "';"));
	        });
	        srcParts.push(ctx.toSource());
	        return srcParts.join('\n');
	    };
	    return TypeScriptEmitter;
	}());
	exports.TypeScriptEmitter = TypeScriptEmitter;
	var _TsEmitterVisitor = (function (_super) {
	    __extends(_TsEmitterVisitor, _super);
	    function _TsEmitterVisitor(_moduleUrl) {
	        _super.call(this, false);
	        this._moduleUrl = _moduleUrl;
	        this.importsWithPrefixes = new Map();
	    }
	    _TsEmitterVisitor.prototype.visitExternalExpr = function (ast, ctx) {
	        this._visitIdentifier(ast.value, ast.typeParams, ctx);
	        return null;
	    };
	    _TsEmitterVisitor.prototype.visitDeclareVarStmt = function (stmt, ctx) {
	        if (ctx.isExportedVar(stmt.name)) {
	            ctx.print("export ");
	        }
	        if (stmt.hasModifier(o.StmtModifier.Final)) {
	            ctx.print("const");
	        }
	        else {
	            ctx.print("var");
	        }
	        ctx.print(" " + stmt.name);
	        if (lang_1.isPresent(stmt.type)) {
	            ctx.print(":");
	            stmt.type.visitType(this, ctx);
	        }
	        ctx.print(" = ");
	        stmt.value.visitExpression(this, ctx);
	        ctx.println(";");
	        return null;
	    };
	    _TsEmitterVisitor.prototype.visitCastExpr = function (ast, ctx) {
	        ctx.print("(<");
	        ast.type.visitType(this, ctx);
	        ctx.print(">");
	        ast.value.visitExpression(this, ctx);
	        ctx.print(")");
	        return null;
	    };
	    _TsEmitterVisitor.prototype.visitDeclareClassStmt = function (stmt, ctx) {
	        var _this = this;
	        ctx.pushClass(stmt);
	        if (ctx.isExportedVar(stmt.name)) {
	            ctx.print("export ");
	        }
	        ctx.print("class " + stmt.name);
	        if (lang_1.isPresent(stmt.parent)) {
	            ctx.print(" extends ");
	            stmt.parent.visitExpression(this, ctx);
	        }
	        ctx.println(" {");
	        ctx.incIndent();
	        stmt.fields.forEach(function (field) { return _this._visitClassField(field, ctx); });
	        if (lang_1.isPresent(stmt.constructorMethod)) {
	            this._visitClassConstructor(stmt, ctx);
	        }
	        stmt.getters.forEach(function (getter) { return _this._visitClassGetter(getter, ctx); });
	        stmt.methods.forEach(function (method) { return _this._visitClassMethod(method, ctx); });
	        ctx.decIndent();
	        ctx.println("}");
	        ctx.popClass();
	        return null;
	    };
	    _TsEmitterVisitor.prototype._visitClassField = function (field, ctx) {
	        if (field.hasModifier(o.StmtModifier.Private)) {
	            ctx.print("private ");
	        }
	        ctx.print(field.name);
	        if (lang_1.isPresent(field.type)) {
	            ctx.print(":");
	            field.type.visitType(this, ctx);
	        }
	        else {
	            ctx.print(": any");
	        }
	        ctx.println(";");
	    };
	    _TsEmitterVisitor.prototype._visitClassGetter = function (getter, ctx) {
	        if (getter.hasModifier(o.StmtModifier.Private)) {
	            ctx.print("private ");
	        }
	        ctx.print("get " + getter.name + "()");
	        if (lang_1.isPresent(getter.type)) {
	            ctx.print(":");
	            getter.type.visitType(this, ctx);
	        }
	        ctx.println(" {");
	        ctx.incIndent();
	        this.visitAllStatements(getter.body, ctx);
	        ctx.decIndent();
	        ctx.println("}");
	    };
	    _TsEmitterVisitor.prototype._visitClassConstructor = function (stmt, ctx) {
	        ctx.print("constructor(");
	        this._visitParams(stmt.constructorMethod.params, ctx);
	        ctx.println(") {");
	        ctx.incIndent();
	        this.visitAllStatements(stmt.constructorMethod.body, ctx);
	        ctx.decIndent();
	        ctx.println("}");
	    };
	    _TsEmitterVisitor.prototype._visitClassMethod = function (method, ctx) {
	        if (method.hasModifier(o.StmtModifier.Private)) {
	            ctx.print("private ");
	        }
	        ctx.print(method.name + "(");
	        this._visitParams(method.params, ctx);
	        ctx.print("):");
	        if (lang_1.isPresent(method.type)) {
	            method.type.visitType(this, ctx);
	        }
	        else {
	            ctx.print("void");
	        }
	        ctx.println(" {");
	        ctx.incIndent();
	        this.visitAllStatements(method.body, ctx);
	        ctx.decIndent();
	        ctx.println("}");
	    };
	    _TsEmitterVisitor.prototype.visitFunctionExpr = function (ast, ctx) {
	        ctx.print("(");
	        this._visitParams(ast.params, ctx);
	        ctx.print("):");
	        if (lang_1.isPresent(ast.type)) {
	            ast.type.visitType(this, ctx);
	        }
	        else {
	            ctx.print("void");
	        }
	        ctx.println(" => {");
	        ctx.incIndent();
	        this.visitAllStatements(ast.statements, ctx);
	        ctx.decIndent();
	        ctx.print("}");
	        return null;
	    };
	    _TsEmitterVisitor.prototype.visitDeclareFunctionStmt = function (stmt, ctx) {
	        if (ctx.isExportedVar(stmt.name)) {
	            ctx.print("export ");
	        }
	        ctx.print("function " + stmt.name + "(");
	        this._visitParams(stmt.params, ctx);
	        ctx.print("):");
	        if (lang_1.isPresent(stmt.type)) {
	            stmt.type.visitType(this, ctx);
	        }
	        else {
	            ctx.print("void");
	        }
	        ctx.println(" {");
	        ctx.incIndent();
	        this.visitAllStatements(stmt.statements, ctx);
	        ctx.decIndent();
	        ctx.println("}");
	        return null;
	    };
	    _TsEmitterVisitor.prototype.visitTryCatchStmt = function (stmt, ctx) {
	        ctx.println("try {");
	        ctx.incIndent();
	        this.visitAllStatements(stmt.bodyStmts, ctx);
	        ctx.decIndent();
	        ctx.println("} catch (" + abstract_emitter_1.CATCH_ERROR_VAR.name + ") {");
	        ctx.incIndent();
	        var catchStmts = [
	            abstract_emitter_1.CATCH_STACK_VAR.set(abstract_emitter_1.CATCH_ERROR_VAR.prop('stack'))
	                .toDeclStmt(null, [o.StmtModifier.Final])
	        ].concat(stmt.catchStmts);
	        this.visitAllStatements(catchStmts, ctx);
	        ctx.decIndent();
	        ctx.println("}");
	        return null;
	    };
	    _TsEmitterVisitor.prototype.visitBuiltintType = function (type, ctx) {
	        var typeStr;
	        switch (type.name) {
	            case o.BuiltinTypeName.Bool:
	                typeStr = 'boolean';
	                break;
	            case o.BuiltinTypeName.Dynamic:
	                typeStr = 'any';
	                break;
	            case o.BuiltinTypeName.Function:
	                typeStr = 'Function';
	                break;
	            case o.BuiltinTypeName.Number:
	                typeStr = 'number';
	                break;
	            case o.BuiltinTypeName.Int:
	                typeStr = 'number';
	                break;
	            case o.BuiltinTypeName.String:
	                typeStr = 'string';
	                break;
	            default:
	                throw new exceptions_1.BaseException("Unsupported builtin type " + type.name);
	        }
	        ctx.print(typeStr);
	        return null;
	    };
	    _TsEmitterVisitor.prototype.visitExternalType = function (ast, ctx) {
	        this._visitIdentifier(ast.value, ast.typeParams, ctx);
	        return null;
	    };
	    _TsEmitterVisitor.prototype.visitArrayType = function (type, ctx) {
	        if (lang_1.isPresent(type.of)) {
	            type.of.visitType(this, ctx);
	        }
	        else {
	            ctx.print("any");
	        }
	        ctx.print("[]");
	        return null;
	    };
	    _TsEmitterVisitor.prototype.visitMapType = function (type, ctx) {
	        ctx.print("{[key: string]:");
	        if (lang_1.isPresent(type.valueType)) {
	            type.valueType.visitType(this, ctx);
	        }
	        else {
	            ctx.print("any");
	        }
	        ctx.print("}");
	        return null;
	    };
	    _TsEmitterVisitor.prototype.getBuiltinMethodName = function (method) {
	        var name;
	        switch (method) {
	            case o.BuiltinMethod.ConcatArray:
	                name = 'concat';
	                break;
	            case o.BuiltinMethod.SubscribeObservable:
	                name = 'subscribe';
	                break;
	            case o.BuiltinMethod.bind:
	                name = 'bind';
	                break;
	            default:
	                throw new exceptions_1.BaseException("Unknown builtin method: " + method);
	        }
	        return name;
	    };
	    _TsEmitterVisitor.prototype._visitParams = function (params, ctx) {
	        var _this = this;
	        this.visitAllObjects(function (param) {
	            ctx.print(param.name);
	            if (lang_1.isPresent(param.type)) {
	                ctx.print(":");
	                param.type.visitType(_this, ctx);
	            }
	        }, params, ctx, ',');
	    };
	    _TsEmitterVisitor.prototype._visitIdentifier = function (value, typeParams, ctx) {
	        var _this = this;
	        if (lang_1.isBlank(value.name)) {
	            throw new exceptions_1.BaseException("Internal error: unknown identifier " + value);
	        }
	        if (lang_1.isPresent(value.moduleUrl) && value.moduleUrl != this._moduleUrl) {
	            var prefix = this.importsWithPrefixes.get(value.moduleUrl);
	            if (lang_1.isBlank(prefix)) {
	                prefix = "import" + this.importsWithPrefixes.size;
	                this.importsWithPrefixes.set(value.moduleUrl, prefix);
	            }
	            ctx.print(prefix + ".");
	        }
	        ctx.print(value.name);
	        if (lang_1.isPresent(typeParams) && typeParams.length > 0) {
	            ctx.print("<");
	            this.visitAllObjects(function (type) { return type.visitType(_this, ctx); }, typeParams, ctx, ',');
	            ctx.print(">");
	        }
	    };
	    return _TsEmitterVisitor;
	}(abstract_emitter_1.AbstractEmitterVisitor));


/***/ },
/* 200 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var view_1 = __webpack_require__(160);
	var exceptions_1 = __webpack_require__(12);
	var InterpretiveAppViewInstanceFactory = (function () {
	    function InterpretiveAppViewInstanceFactory() {
	    }
	    InterpretiveAppViewInstanceFactory.prototype.createInstance = function (superClass, clazz, args, props, getters, methods) {
	        if (superClass === view_1.AppView) {
	            // We are always using DebugAppView as parent.
	            // However, in prod mode we generate a constructor call that does
	            // not have the argument for the debugNodeInfos.
	            args = args.concat([null]);
	            return new _InterpretiveAppView(args, props, getters, methods);
	        }
	        else if (superClass === view_1.DebugAppView) {
	            return new _InterpretiveAppView(args, props, getters, methods);
	        }
	        throw new exceptions_1.BaseException("Can't instantiate class " + superClass + " in interpretative mode");
	    };
	    return InterpretiveAppViewInstanceFactory;
	}());
	exports.InterpretiveAppViewInstanceFactory = InterpretiveAppViewInstanceFactory;
	var _InterpretiveAppView = (function (_super) {
	    __extends(_InterpretiveAppView, _super);
	    function _InterpretiveAppView(args, props, getters, methods) {
	        _super.call(this, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]);
	        this.props = props;
	        this.getters = getters;
	        this.methods = methods;
	    }
	    _InterpretiveAppView.prototype.createInternal = function (rootSelector) {
	        var m = this.methods.get('createInternal');
	        if (lang_1.isPresent(m)) {
	            return m(rootSelector);
	        }
	        else {
	            return _super.prototype.createInternal.call(this, rootSelector);
	        }
	    };
	    _InterpretiveAppView.prototype.injectorGetInternal = function (token, nodeIndex, notFoundResult) {
	        var m = this.methods.get('injectorGetInternal');
	        if (lang_1.isPresent(m)) {
	            return m(token, nodeIndex, notFoundResult);
	        }
	        else {
	            return _super.prototype.injectorGet.call(this, token, nodeIndex, notFoundResult);
	        }
	    };
	    _InterpretiveAppView.prototype.destroyInternal = function () {
	        var m = this.methods.get('destroyInternal');
	        if (lang_1.isPresent(m)) {
	            return m();
	        }
	        else {
	            return _super.prototype.destroyInternal.call(this);
	        }
	    };
	    _InterpretiveAppView.prototype.dirtyParentQueriesInternal = function () {
	        var m = this.methods.get('dirtyParentQueriesInternal');
	        if (lang_1.isPresent(m)) {
	            return m();
	        }
	        else {
	            return _super.prototype.dirtyParentQueriesInternal.call(this);
	        }
	    };
	    _InterpretiveAppView.prototype.detectChangesInternal = function (throwOnChange) {
	        var m = this.methods.get('detectChangesInternal');
	        if (lang_1.isPresent(m)) {
	            return m(throwOnChange);
	        }
	        else {
	            return _super.prototype.detectChangesInternal.call(this, throwOnChange);
	        }
	    };
	    return _InterpretiveAppView;
	}(view_1.DebugAppView));


/***/ },
/* 201 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var di_1 = __webpack_require__(6);
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var dom_adapter_1 = __webpack_require__(202);
	var html_tags_1 = __webpack_require__(150);
	var element_schema_registry_1 = __webpack_require__(152);
	var NAMESPACE_URIS = 
	/*@ts2dart_const*/
	{ 'xlink': 'http://www.w3.org/1999/xlink', 'svg': 'http://www.w3.org/2000/svg' };
	var DomElementSchemaRegistry = (function (_super) {
	    __extends(DomElementSchemaRegistry, _super);
	    function DomElementSchemaRegistry() {
	        _super.apply(this, arguments);
	        this._protoElements = new Map();
	    }
	    DomElementSchemaRegistry.prototype._getProtoElement = function (tagName) {
	        var element = this._protoElements.get(tagName);
	        if (lang_1.isBlank(element)) {
	            var nsAndName = html_tags_1.splitNsName(tagName);
	            element = lang_1.isPresent(nsAndName[0]) ?
	                dom_adapter_1.DOM.createElementNS(NAMESPACE_URIS[nsAndName[0]], nsAndName[1]) :
	                dom_adapter_1.DOM.createElement(nsAndName[1]);
	            this._protoElements.set(tagName, element);
	        }
	        return element;
	    };
	    DomElementSchemaRegistry.prototype.hasProperty = function (tagName, propName) {
	        if (tagName.indexOf('-') !== -1) {
	            // can't tell now as we don't know which properties a custom element will get
	            // once it is instantiated
	            return true;
	        }
	        else {
	            var elm = this._getProtoElement(tagName);
	            return dom_adapter_1.DOM.hasProperty(elm, propName);
	        }
	    };
	    DomElementSchemaRegistry.prototype.getMappedPropName = function (propName) {
	        var mappedPropName = collection_1.StringMapWrapper.get(dom_adapter_1.DOM.attrToPropMap, propName);
	        return lang_1.isPresent(mappedPropName) ? mappedPropName : propName;
	    };
	    DomElementSchemaRegistry = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], DomElementSchemaRegistry);
	    return DomElementSchemaRegistry;
	}(element_schema_registry_1.ElementSchemaRegistry));
	exports.DomElementSchemaRegistry = DomElementSchemaRegistry;


/***/ },
/* 202 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	exports.DOM = null;
	function setRootDomAdapter(adapter) {
	    if (lang_1.isBlank(exports.DOM)) {
	        exports.DOM = adapter;
	    }
	}
	exports.setRootDomAdapter = setRootDomAdapter;
	/* tslint:disable:requireParameterType */
	/**
	 * Provides DOM operations in an environment-agnostic way.
	 */
	var DomAdapter = (function () {
	    function DomAdapter() {
	    }
	    Object.defineProperty(DomAdapter.prototype, "attrToPropMap", {
	        /**
	         * Maps attribute names to their corresponding property names for cases
	         * where attribute name doesn't match property name.
	         */
	        get: function () { return this._attrToPropMap; },
	        set: function (value) { this._attrToPropMap = value; },
	        enumerable: true,
	        configurable: true
	    });
	    ;
	    ;
	    return DomAdapter;
	}());
	exports.DomAdapter = DomAdapter;


/***/ },
/* 203 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var browser_common_1 = __webpack_require__(204);
	exports.BROWSER_PROVIDERS = browser_common_1.BROWSER_PROVIDERS;
	exports.CACHED_TEMPLATE_PROVIDER = browser_common_1.CACHED_TEMPLATE_PROVIDER;
	exports.ELEMENT_PROBE_PROVIDERS = browser_common_1.ELEMENT_PROBE_PROVIDERS;
	exports.ELEMENT_PROBE_PROVIDERS_PROD_MODE = browser_common_1.ELEMENT_PROBE_PROVIDERS_PROD_MODE;
	exports.inspectNativeElement = browser_common_1.inspectNativeElement;
	exports.BrowserDomAdapter = browser_common_1.BrowserDomAdapter;
	exports.By = browser_common_1.By;
	exports.Title = browser_common_1.Title;
	exports.DOCUMENT = browser_common_1.DOCUMENT;
	exports.enableDebugTools = browser_common_1.enableDebugTools;
	exports.disableDebugTools = browser_common_1.disableDebugTools;
	var lang_1 = __webpack_require__(5);
	var browser_common_2 = __webpack_require__(204);
	var compiler_1 = __webpack_require__(139);
	var core_1 = __webpack_require__(2);
	var reflection_capabilities_1 = __webpack_require__(21);
	var xhr_impl_1 = __webpack_require__(220);
	var compiler_2 = __webpack_require__(139);
	/**
	 * An array of providers that should be passed into `application()` when bootstrapping a component.
	 */
	exports.BROWSER_APP_PROVIDERS = [
	    browser_common_2.BROWSER_APP_COMMON_PROVIDERS,
	    compiler_1.COMPILER_PROVIDERS,
	    /*@ts2dart_Provider*/ { provide: compiler_2.XHR, useClass: xhr_impl_1.XHRImpl },
	];
	function browserPlatform() {
	    if (lang_1.isBlank(core_1.getPlatform())) {
	        core_1.createPlatform(core_1.ReflectiveInjector.resolveAndCreate(browser_common_2.BROWSER_PROVIDERS));
	    }
	    return core_1.assertPlatform(browser_common_2.BROWSER_PLATFORM_MARKER);
	}
	exports.browserPlatform = browserPlatform;
	/**
	 * 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}.
	 */
	function bootstrap(appComponentType, customProviders) {
	    core_1.reflector.reflectionCapabilities = new reflection_capabilities_1.ReflectionCapabilities();
	    var appInjector = core_1.ReflectiveInjector.resolveAndCreate([exports.BROWSER_APP_PROVIDERS, lang_1.isPresent(customProviders) ? customProviders : []], browserPlatform().injector);
	    return core_1.coreLoadAndBootstrap(appInjector, appComponentType);
	}
	exports.bootstrap = bootstrap;


/***/ },
/* 204 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var di_1 = __webpack_require__(6);
	var xhr_1 = __webpack_require__(186);
	var core_1 = __webpack_require__(2);
	var common_1 = __webpack_require__(89);
	var testability_1 = __webpack_require__(65);
	var dom_adapter_1 = __webpack_require__(202);
	var dom_events_1 = __webpack_require__(205);
	var key_events_1 = __webpack_require__(207);
	var dom_tokens_1 = __webpack_require__(208);
	var dom_renderer_1 = __webpack_require__(209);
	var shared_styles_host_1 = __webpack_require__(217);
	var browser_details_1 = __webpack_require__(216);
	var animation_builder_1 = __webpack_require__(210);
	var browser_adapter_1 = __webpack_require__(218);
	var testability_2 = __webpack_require__(221);
	var xhr_cache_1 = __webpack_require__(222);
	var wtf_init_1 = __webpack_require__(223);
	var event_manager_1 = __webpack_require__(206);
	var hammer_gestures_1 = __webpack_require__(224);
	var common_dom_1 = __webpack_require__(226);
	var dom_tokens_2 = __webpack_require__(208);
	exports.DOCUMENT = dom_tokens_2.DOCUMENT;
	var title_1 = __webpack_require__(230);
	exports.Title = title_1.Title;
	var common_dom_2 = __webpack_require__(226);
	exports.ELEMENT_PROBE_PROVIDERS = common_dom_2.ELEMENT_PROBE_PROVIDERS;
	exports.ELEMENT_PROBE_PROVIDERS_PROD_MODE = common_dom_2.ELEMENT_PROBE_PROVIDERS_PROD_MODE;
	exports.inspectNativeElement = common_dom_2.inspectNativeElement;
	exports.By = common_dom_2.By;
	var browser_adapter_2 = __webpack_require__(218);
	exports.BrowserDomAdapter = browser_adapter_2.BrowserDomAdapter;
	var tools_1 = __webpack_require__(231);
	exports.enableDebugTools = tools_1.enableDebugTools;
	exports.disableDebugTools = tools_1.disableDebugTools;
	var hammer_gestures_2 = __webpack_require__(224);
	exports.HAMMER_GESTURE_CONFIG = hammer_gestures_2.HAMMER_GESTURE_CONFIG;
	exports.HammerGestureConfig = hammer_gestures_2.HammerGestureConfig;
	exports.BROWSER_PLATFORM_MARKER = 
	/*@ts2dart_const*/ new di_1.OpaqueToken('BrowserPlatformMarker');
	/**
	 * A set of providers to initialize the Angular platform in a web browser.
	 *
	 * Used automatically by `bootstrap`, or can be passed to {@link platform}.
	 */
	exports.BROWSER_PROVIDERS = [
	    /*@ts2dart_Provider*/ { provide: exports.BROWSER_PLATFORM_MARKER, useValue: true },
	    core_1.PLATFORM_COMMON_PROVIDERS,
	    /*@ts2dart_Provider*/ { provide: core_1.PLATFORM_INITIALIZER, useValue: initDomAdapter, multi: true },
	];
	function _exceptionHandler() {
	    // !IS_DART is required because we must rethrow exceptions in JS,
	    // but must not rethrow exceptions in Dart
	    return new core_1.ExceptionHandler(dom_adapter_1.DOM, !lang_1.IS_DART);
	}
	function _document() {
	    return dom_adapter_1.DOM.defaultDoc();
	}
	/**
	 * A set of providers to initialize an Angular application in a web browser.
	 *
	 * Used automatically by `bootstrap`, or can be passed to {@link PlatformRef.application}.
	 */
	exports.BROWSER_APP_COMMON_PROVIDERS = 
	/*@ts2dart_const*/ [
	    core_1.APPLICATION_COMMON_PROVIDERS,
	    common_1.FORM_PROVIDERS,
	    /* @ts2dart_Provider */ { provide: core_1.PLATFORM_PIPES, useValue: common_1.COMMON_PIPES, multi: true },
	    /* @ts2dart_Provider */ { provide: core_1.PLATFORM_DIRECTIVES, useValue: common_1.COMMON_DIRECTIVES, multi: true },
	    /* @ts2dart_Provider */ { provide: core_1.ExceptionHandler, useFactory: _exceptionHandler, deps: [] },
	    /* @ts2dart_Provider */ { provide: dom_tokens_1.DOCUMENT, useFactory: _document, deps: [] },
	    /* @ts2dart_Provider */ { provide: event_manager_1.EVENT_MANAGER_PLUGINS, useClass: dom_events_1.DomEventsPlugin, multi: true },
	    /* @ts2dart_Provider */ { provide: event_manager_1.EVENT_MANAGER_PLUGINS, useClass: key_events_1.KeyEventsPlugin, multi: true },
	    /* @ts2dart_Provider */ { provide: event_manager_1.EVENT_MANAGER_PLUGINS, useClass: hammer_gestures_1.HammerGesturesPlugin, multi: true },
	    /* @ts2dart_Provider */ { provide: hammer_gestures_1.HAMMER_GESTURE_CONFIG, useClass: hammer_gestures_1.HammerGestureConfig },
	    /* @ts2dart_Provider */ { provide: dom_renderer_1.DomRootRenderer, useClass: dom_renderer_1.DomRootRenderer_ },
	    /* @ts2dart_Provider */ { provide: core_1.RootRenderer, useExisting: dom_renderer_1.DomRootRenderer },
	    /* @ts2dart_Provider */ { provide: shared_styles_host_1.SharedStylesHost, useExisting: shared_styles_host_1.DomSharedStylesHost },
	    shared_styles_host_1.DomSharedStylesHost,
	    testability_1.Testability,
	    browser_details_1.BrowserDetails,
	    animation_builder_1.AnimationBuilder,
	    event_manager_1.EventManager,
	    common_dom_1.ELEMENT_PROBE_PROVIDERS
	];
	exports.CACHED_TEMPLATE_PROVIDER = 
	/*@ts2dart_const*/ [{ provide: xhr_1.XHR, useClass: xhr_cache_1.CachedXHR }];
	function initDomAdapter() {
	    browser_adapter_1.BrowserDomAdapter.makeCurrent();
	    wtf_init_1.wtfInit();
	    testability_2.BrowserGetTestability.init();
	}
	exports.initDomAdapter = initDomAdapter;


/***/ },
/* 205 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var dom_adapter_1 = __webpack_require__(202);
	var core_1 = __webpack_require__(2);
	var event_manager_1 = __webpack_require__(206);
	var DomEventsPlugin = (function (_super) {
	    __extends(DomEventsPlugin, _super);
	    function DomEventsPlugin() {
	        _super.apply(this, arguments);
	    }
	    // This plugin should come last in the list of plugins, because it accepts all
	    // events.
	    DomEventsPlugin.prototype.supports = function (eventName) { return true; };
	    DomEventsPlugin.prototype.addEventListener = function (element, eventName, handler) {
	        var zone = this.manager.getZone();
	        var outsideHandler = function (event) { return zone.runGuarded(function () { return handler(event); }); };
	        return this.manager.getZone().runOutsideAngular(function () { return dom_adapter_1.DOM.onAndCancel(element, eventName, outsideHandler); });
	    };
	    DomEventsPlugin.prototype.addGlobalEventListener = function (target, eventName, handler) {
	        var element = dom_adapter_1.DOM.getGlobalEventTarget(target);
	        var zone = this.manager.getZone();
	        var outsideHandler = function (event) { return zone.runGuarded(function () { return handler(event); }); };
	        return this.manager.getZone().runOutsideAngular(function () { return dom_adapter_1.DOM.onAndCancel(element, eventName, outsideHandler); });
	    };
	    DomEventsPlugin = __decorate([
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], DomEventsPlugin);
	    return DomEventsPlugin;
	}(event_manager_1.EventManagerPlugin));
	exports.DomEventsPlugin = DomEventsPlugin;


/***/ },
/* 206 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var exceptions_1 = __webpack_require__(12);
	var di_1 = __webpack_require__(6);
	var ng_zone_1 = __webpack_require__(62);
	var collection_1 = __webpack_require__(15);
	exports.EVENT_MANAGER_PLUGINS = 
	/*@ts2dart_const*/ new di_1.OpaqueToken("EventManagerPlugins");
	var EventManager = (function () {
	    function EventManager(plugins, _zone) {
	        var _this = this;
	        this._zone = _zone;
	        plugins.forEach(function (p) { return p.manager = _this; });
	        this._plugins = collection_1.ListWrapper.reversed(plugins);
	    }
	    EventManager.prototype.addEventListener = function (element, eventName, handler) {
	        var plugin = this._findPluginFor(eventName);
	        return plugin.addEventListener(element, eventName, handler);
	    };
	    EventManager.prototype.addGlobalEventListener = function (target, eventName, handler) {
	        var plugin = this._findPluginFor(eventName);
	        return plugin.addGlobalEventListener(target, eventName, handler);
	    };
	    EventManager.prototype.getZone = function () { return this._zone; };
	    /** @internal */
	    EventManager.prototype._findPluginFor = function (eventName) {
	        var plugins = this._plugins;
	        for (var i = 0; i < plugins.length; i++) {
	            var plugin = plugins[i];
	            if (plugin.supports(eventName)) {
	                return plugin;
	            }
	        }
	        throw new exceptions_1.BaseException("No event manager plugin found for event " + eventName);
	    };
	    EventManager = __decorate([
	        di_1.Injectable(),
	        __param(0, di_1.Inject(exports.EVENT_MANAGER_PLUGINS)), 
	        __metadata('design:paramtypes', [Array, ng_zone_1.NgZone])
	    ], EventManager);
	    return EventManager;
	}());
	exports.EventManager = EventManager;
	var EventManagerPlugin = (function () {
	    function EventManagerPlugin() {
	    }
	    // That is equivalent to having supporting $event.target
	    EventManagerPlugin.prototype.supports = function (eventName) { return false; };
	    EventManagerPlugin.prototype.addEventListener = function (element, eventName, handler) {
	        throw "not implemented";
	    };
	    EventManagerPlugin.prototype.addGlobalEventListener = function (element, eventName, handler) {
	        throw "not implemented";
	    };
	    return EventManagerPlugin;
	}());
	exports.EventManagerPlugin = EventManagerPlugin;


/***/ },
/* 207 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var dom_adapter_1 = __webpack_require__(202);
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var event_manager_1 = __webpack_require__(206);
	var di_1 = __webpack_require__(6);
	var modifierKeys = ['alt', 'control', 'meta', 'shift'];
	var modifierKeyGetters = {
	    'alt': function (event) { return event.altKey; },
	    'control': function (event) { return event.ctrlKey; },
	    'meta': function (event) { return event.metaKey; },
	    'shift': function (event) { return event.shiftKey; }
	};
	var KeyEventsPlugin = (function (_super) {
	    __extends(KeyEventsPlugin, _super);
	    function KeyEventsPlugin() {
	        _super.call(this);
	    }
	    KeyEventsPlugin.prototype.supports = function (eventName) {
	        return lang_1.isPresent(KeyEventsPlugin.parseEventName(eventName));
	    };
	    KeyEventsPlugin.prototype.addEventListener = function (element, eventName, handler) {
	        var parsedEvent = KeyEventsPlugin.parseEventName(eventName);
	        var outsideHandler = KeyEventsPlugin.eventCallback(element, collection_1.StringMapWrapper.get(parsedEvent, 'fullKey'), handler, this.manager.getZone());
	        return this.manager.getZone().runOutsideAngular(function () {
	            return dom_adapter_1.DOM.onAndCancel(element, collection_1.StringMapWrapper.get(parsedEvent, 'domEventName'), outsideHandler);
	        });
	    };
	    KeyEventsPlugin.parseEventName = function (eventName) {
	        var parts = eventName.toLowerCase().split('.');
	        var domEventName = parts.shift();
	        if ((parts.length === 0) ||
	            !(lang_1.StringWrapper.equals(domEventName, 'keydown') ||
	                lang_1.StringWrapper.equals(domEventName, 'keyup'))) {
	            return null;
	        }
	        var key = KeyEventsPlugin._normalizeKey(parts.pop());
	        var fullKey = '';
	        modifierKeys.forEach(function (modifierName) {
	            if (collection_1.ListWrapper.contains(parts, modifierName)) {
	                collection_1.ListWrapper.remove(parts, modifierName);
	                fullKey += modifierName + '.';
	            }
	        });
	        fullKey += key;
	        if (parts.length != 0 || key.length === 0) {
	            // returning null instead of throwing to let another plugin process the event
	            return null;
	        }
	        var result = collection_1.StringMapWrapper.create();
	        collection_1.StringMapWrapper.set(result, 'domEventName', domEventName);
	        collection_1.StringMapWrapper.set(result, 'fullKey', fullKey);
	        return result;
	    };
	    KeyEventsPlugin.getEventFullKey = function (event) {
	        var fullKey = '';
	        var key = dom_adapter_1.DOM.getEventKey(event);
	        key = key.toLowerCase();
	        if (lang_1.StringWrapper.equals(key, ' ')) {
	            key = 'space'; // for readability
	        }
	        else if (lang_1.StringWrapper.equals(key, '.')) {
	            key = 'dot'; // because '.' is used as a separator in event names
	        }
	        modifierKeys.forEach(function (modifierName) {
	            if (modifierName != key) {
	                var modifierGetter = collection_1.StringMapWrapper.get(modifierKeyGetters, modifierName);
	                if (modifierGetter(event)) {
	                    fullKey += modifierName + '.';
	                }
	            }
	        });
	        fullKey += key;
	        return fullKey;
	    };
	    KeyEventsPlugin.eventCallback = function (element, fullKey, handler, zone) {
	        return function (event) {
	            if (lang_1.StringWrapper.equals(KeyEventsPlugin.getEventFullKey(event), fullKey)) {
	                zone.runGuarded(function () { return handler(event); });
	            }
	        };
	    };
	    /** @internal */
	    KeyEventsPlugin._normalizeKey = function (keyName) {
	        // TODO: switch to a StringMap if the mapping grows too much
	        switch (keyName) {
	            case 'esc':
	                return 'escape';
	            default:
	                return keyName;
	        }
	    };
	    KeyEventsPlugin = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], KeyEventsPlugin);
	    return KeyEventsPlugin;
	}(event_manager_1.EventManagerPlugin));
	exports.KeyEventsPlugin = KeyEventsPlugin;


/***/ },
/* 208 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var di_1 = __webpack_require__(6);
	/**
	 * A DI Token representing the main rendering context. In a browser this is the DOM Document.
	 *
	 * Note: Document might not be available in the Application Context when Application and Rendering
	 * Contexts are not the same (e.g. when running the application into a Web Worker).
	 */
	exports.DOCUMENT = new di_1.OpaqueToken('DocumentToken');


/***/ },
/* 209 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var di_1 = __webpack_require__(6);
	var animation_builder_1 = __webpack_require__(210);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var shared_styles_host_1 = __webpack_require__(217);
	var event_manager_1 = __webpack_require__(206);
	var dom_tokens_1 = __webpack_require__(208);
	var metadata_1 = __webpack_require__(3);
	var dom_adapter_1 = __webpack_require__(202);
	var util_1 = __webpack_require__(215);
	var NAMESPACE_URIS = 
	/*@ts2dart_const*/
	{ 'xlink': 'http://www.w3.org/1999/xlink', 'svg': 'http://www.w3.org/2000/svg' };
	var TEMPLATE_COMMENT_TEXT = 'template bindings={}';
	var TEMPLATE_BINDINGS_EXP = /^template bindings=(.*)$/g;
	var DomRootRenderer = (function () {
	    function DomRootRenderer(document, eventManager, sharedStylesHost, animate) {
	        this.document = document;
	        this.eventManager = eventManager;
	        this.sharedStylesHost = sharedStylesHost;
	        this.animate = animate;
	        this._registeredComponents = new Map();
	    }
	    DomRootRenderer.prototype.renderComponent = function (componentProto) {
	        var renderer = this._registeredComponents.get(componentProto.id);
	        if (lang_1.isBlank(renderer)) {
	            renderer = new DomRenderer(this, componentProto);
	            this._registeredComponents.set(componentProto.id, renderer);
	        }
	        return renderer;
	    };
	    return DomRootRenderer;
	}());
	exports.DomRootRenderer = DomRootRenderer;
	var DomRootRenderer_ = (function (_super) {
	    __extends(DomRootRenderer_, _super);
	    function DomRootRenderer_(_document, _eventManager, sharedStylesHost, animate) {
	        _super.call(this, _document, _eventManager, sharedStylesHost, animate);
	    }
	    DomRootRenderer_ = __decorate([
	        di_1.Injectable(),
	        __param(0, di_1.Inject(dom_tokens_1.DOCUMENT)), 
	        __metadata('design:paramtypes', [Object, event_manager_1.EventManager, shared_styles_host_1.DomSharedStylesHost, animation_builder_1.AnimationBuilder])
	    ], DomRootRenderer_);
	    return DomRootRenderer_;
	}(DomRootRenderer));
	exports.DomRootRenderer_ = DomRootRenderer_;
	var DomRenderer = (function () {
	    function DomRenderer(_rootRenderer, componentProto) {
	        this._rootRenderer = _rootRenderer;
	        this.componentProto = componentProto;
	        this._styles = _flattenStyles(componentProto.id, componentProto.styles, []);
	        if (componentProto.encapsulation !== metadata_1.ViewEncapsulation.Native) {
	            this._rootRenderer.sharedStylesHost.addStyles(this._styles);
	        }
	        if (this.componentProto.encapsulation === metadata_1.ViewEncapsulation.Emulated) {
	            this._contentAttr = _shimContentAttribute(componentProto.id);
	            this._hostAttr = _shimHostAttribute(componentProto.id);
	        }
	        else {
	            this._contentAttr = null;
	            this._hostAttr = null;
	        }
	    }
	    DomRenderer.prototype.selectRootElement = function (selectorOrNode, debugInfo) {
	        var el;
	        if (lang_1.isString(selectorOrNode)) {
	            el = dom_adapter_1.DOM.querySelector(this._rootRenderer.document, selectorOrNode);
	            if (lang_1.isBlank(el)) {
	                throw new exceptions_1.BaseException("The selector \"" + selectorOrNode + "\" did not match any elements");
	            }
	        }
	        else {
	            el = selectorOrNode;
	        }
	        dom_adapter_1.DOM.clearNodes(el);
	        return el;
	    };
	    DomRenderer.prototype.createElement = function (parent, name, debugInfo) {
	        var nsAndName = splitNamespace(name);
	        var el = lang_1.isPresent(nsAndName[0]) ?
	            dom_adapter_1.DOM.createElementNS(NAMESPACE_URIS[nsAndName[0]], nsAndName[1]) :
	            dom_adapter_1.DOM.createElement(nsAndName[1]);
	        if (lang_1.isPresent(this._contentAttr)) {
	            dom_adapter_1.DOM.setAttribute(el, this._contentAttr, '');
	        }
	        if (lang_1.isPresent(parent)) {
	            dom_adapter_1.DOM.appendChild(parent, el);
	        }
	        return el;
	    };
	    DomRenderer.prototype.createViewRoot = function (hostElement) {
	        var nodesParent;
	        if (this.componentProto.encapsulation === metadata_1.ViewEncapsulation.Native) {
	            nodesParent = dom_adapter_1.DOM.createShadowRoot(hostElement);
	            this._rootRenderer.sharedStylesHost.addHost(nodesParent);
	            for (var i = 0; i < this._styles.length; i++) {
	                dom_adapter_1.DOM.appendChild(nodesParent, dom_adapter_1.DOM.createStyleElement(this._styles[i]));
	            }
	        }
	        else {
	            if (lang_1.isPresent(this._hostAttr)) {
	                dom_adapter_1.DOM.setAttribute(hostElement, this._hostAttr, '');
	            }
	            nodesParent = hostElement;
	        }
	        return nodesParent;
	    };
	    DomRenderer.prototype.createTemplateAnchor = function (parentElement, debugInfo) {
	        var comment = dom_adapter_1.DOM.createComment(TEMPLATE_COMMENT_TEXT);
	        if (lang_1.isPresent(parentElement)) {
	            dom_adapter_1.DOM.appendChild(parentElement, comment);
	        }
	        return comment;
	    };
	    DomRenderer.prototype.createText = function (parentElement, value, debugInfo) {
	        var node = dom_adapter_1.DOM.createTextNode(value);
	        if (lang_1.isPresent(parentElement)) {
	            dom_adapter_1.DOM.appendChild(parentElement, node);
	        }
	        return node;
	    };
	    DomRenderer.prototype.projectNodes = function (parentElement, nodes) {
	        if (lang_1.isBlank(parentElement))
	            return;
	        appendNodes(parentElement, nodes);
	    };
	    DomRenderer.prototype.attachViewAfter = function (node, viewRootNodes) {
	        moveNodesAfterSibling(node, viewRootNodes);
	        for (var i = 0; i < viewRootNodes.length; i++)
	            this.animateNodeEnter(viewRootNodes[i]);
	    };
	    DomRenderer.prototype.detachView = function (viewRootNodes) {
	        for (var i = 0; i < viewRootNodes.length; i++) {
	            var node = viewRootNodes[i];
	            dom_adapter_1.DOM.remove(node);
	            this.animateNodeLeave(node);
	        }
	    };
	    DomRenderer.prototype.destroyView = function (hostElement, viewAllNodes) {
	        if (this.componentProto.encapsulation === metadata_1.ViewEncapsulation.Native && lang_1.isPresent(hostElement)) {
	            this._rootRenderer.sharedStylesHost.removeHost(dom_adapter_1.DOM.getShadowRoot(hostElement));
	        }
	    };
	    DomRenderer.prototype.listen = function (renderElement, name, callback) {
	        return this._rootRenderer.eventManager.addEventListener(renderElement, name, decoratePreventDefault(callback));
	    };
	    DomRenderer.prototype.listenGlobal = function (target, name, callback) {
	        return this._rootRenderer.eventManager.addGlobalEventListener(target, name, decoratePreventDefault(callback));
	    };
	    DomRenderer.prototype.setElementProperty = function (renderElement, propertyName, propertyValue) {
	        dom_adapter_1.DOM.setProperty(renderElement, propertyName, propertyValue);
	    };
	    DomRenderer.prototype.setElementAttribute = function (renderElement, attributeName, attributeValue) {
	        var attrNs;
	        var nsAndName = splitNamespace(attributeName);
	        if (lang_1.isPresent(nsAndName[0])) {
	            attributeName = nsAndName[0] + ':' + nsAndName[1];
	            attrNs = NAMESPACE_URIS[nsAndName[0]];
	        }
	        if (lang_1.isPresent(attributeValue)) {
	            if (lang_1.isPresent(attrNs)) {
	                dom_adapter_1.DOM.setAttributeNS(renderElement, attrNs, attributeName, attributeValue);
	            }
	            else {
	                dom_adapter_1.DOM.setAttribute(renderElement, attributeName, attributeValue);
	            }
	        }
	        else {
	            if (lang_1.isPresent(attrNs)) {
	                dom_adapter_1.DOM.removeAttributeNS(renderElement, attrNs, nsAndName[1]);
	            }
	            else {
	                dom_adapter_1.DOM.removeAttribute(renderElement, attributeName);
	            }
	        }
	    };
	    DomRenderer.prototype.setBindingDebugInfo = function (renderElement, propertyName, propertyValue) {
	        var dashCasedPropertyName = util_1.camelCaseToDashCase(propertyName);
	        if (dom_adapter_1.DOM.isCommentNode(renderElement)) {
	            var existingBindings = lang_1.RegExpWrapper.firstMatch(TEMPLATE_BINDINGS_EXP, lang_1.StringWrapper.replaceAll(dom_adapter_1.DOM.getText(renderElement), /\n/g, ''));
	            var parsedBindings = lang_1.Json.parse(existingBindings[1]);
	            parsedBindings[dashCasedPropertyName] = propertyValue;
	            dom_adapter_1.DOM.setText(renderElement, lang_1.StringWrapper.replace(TEMPLATE_COMMENT_TEXT, '{}', lang_1.Json.stringify(parsedBindings)));
	        }
	        else {
	            this.setElementAttribute(renderElement, propertyName, propertyValue);
	        }
	    };
	    DomRenderer.prototype.setElementClass = function (renderElement, className, isAdd) {
	        if (isAdd) {
	            dom_adapter_1.DOM.addClass(renderElement, className);
	        }
	        else {
	            dom_adapter_1.DOM.removeClass(renderElement, className);
	        }
	    };
	    DomRenderer.prototype.setElementStyle = function (renderElement, styleName, styleValue) {
	        if (lang_1.isPresent(styleValue)) {
	            dom_adapter_1.DOM.setStyle(renderElement, styleName, lang_1.stringify(styleValue));
	        }
	        else {
	            dom_adapter_1.DOM.removeStyle(renderElement, styleName);
	        }
	    };
	    DomRenderer.prototype.invokeElementMethod = function (renderElement, methodName, args) {
	        dom_adapter_1.DOM.invoke(renderElement, methodName, args);
	    };
	    DomRenderer.prototype.setText = function (renderNode, text) { dom_adapter_1.DOM.setText(renderNode, text); };
	    /**
	     * Performs animations if necessary
	     * @param node
	     */
	    DomRenderer.prototype.animateNodeEnter = function (node) {
	        if (dom_adapter_1.DOM.isElementNode(node) && dom_adapter_1.DOM.hasClass(node, 'ng-animate')) {
	            dom_adapter_1.DOM.addClass(node, 'ng-enter');
	            this._rootRenderer.animate.css()
	                .addAnimationClass('ng-enter-active')
	                .start(node)
	                .onComplete(function () { dom_adapter_1.DOM.removeClass(node, 'ng-enter'); });
	        }
	    };
	    /**
	     * If animations are necessary, performs animations then removes the element; otherwise, it just
	     * removes the element.
	     * @param node
	     */
	    DomRenderer.prototype.animateNodeLeave = function (node) {
	        if (dom_adapter_1.DOM.isElementNode(node) && dom_adapter_1.DOM.hasClass(node, 'ng-animate')) {
	            dom_adapter_1.DOM.addClass(node, 'ng-leave');
	            this._rootRenderer.animate.css()
	                .addAnimationClass('ng-leave-active')
	                .start(node)
	                .onComplete(function () {
	                dom_adapter_1.DOM.removeClass(node, 'ng-leave');
	                dom_adapter_1.DOM.remove(node);
	            });
	        }
	        else {
	            dom_adapter_1.DOM.remove(node);
	        }
	    };
	    return DomRenderer;
	}());
	exports.DomRenderer = DomRenderer;
	function moveNodesAfterSibling(sibling, nodes) {
	    var parent = dom_adapter_1.DOM.parentElement(sibling);
	    if (nodes.length > 0 && lang_1.isPresent(parent)) {
	        var nextSibling = dom_adapter_1.DOM.nextSibling(sibling);
	        if (lang_1.isPresent(nextSibling)) {
	            for (var i = 0; i < nodes.length; i++) {
	                dom_adapter_1.DOM.insertBefore(nextSibling, nodes[i]);
	            }
	        }
	        else {
	            for (var i = 0; i < nodes.length; i++) {
	                dom_adapter_1.DOM.appendChild(parent, nodes[i]);
	            }
	        }
	    }
	}
	function appendNodes(parent, nodes) {
	    for (var i = 0; i < nodes.length; i++) {
	        dom_adapter_1.DOM.appendChild(parent, nodes[i]);
	    }
	}
	function decoratePreventDefault(eventHandler) {
	    return function (event) {
	        var allowDefaultBehavior = eventHandler(event);
	        if (allowDefaultBehavior === false) {
	            // TODO(tbosch): move preventDefault into event plugins...
	            dom_adapter_1.DOM.preventDefault(event);
	        }
	    };
	}
	var COMPONENT_REGEX = /%COMP%/g;
	exports.COMPONENT_VARIABLE = '%COMP%';
	exports.HOST_ATTR = "_nghost-" + exports.COMPONENT_VARIABLE;
	exports.CONTENT_ATTR = "_ngcontent-" + exports.COMPONENT_VARIABLE;
	function _shimContentAttribute(componentShortId) {
	    return lang_1.StringWrapper.replaceAll(exports.CONTENT_ATTR, COMPONENT_REGEX, componentShortId);
	}
	function _shimHostAttribute(componentShortId) {
	    return lang_1.StringWrapper.replaceAll(exports.HOST_ATTR, COMPONENT_REGEX, componentShortId);
	}
	function _flattenStyles(compId, styles, target) {
	    for (var i = 0; i < styles.length; i++) {
	        var style = styles[i];
	        if (lang_1.isArray(style)) {
	            _flattenStyles(compId, style, target);
	        }
	        else {
	            style = lang_1.StringWrapper.replaceAll(style, COMPONENT_REGEX, compId);
	            target.push(style);
	        }
	    }
	    return target;
	}
	var NS_PREFIX_RE = /^@([^:]+):(.+)/g;
	function splitNamespace(name) {
	    if (name[0] != '@') {
	        return [null, name];
	    }
	    var match = lang_1.RegExpWrapper.firstMatch(NS_PREFIX_RE, name);
	    return [match[1], match[2]];
	}


/***/ },
/* 210 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var di_1 = __webpack_require__(6);
	var css_animation_builder_1 = __webpack_require__(211);
	var browser_details_1 = __webpack_require__(216);
	var AnimationBuilder = (function () {
	    /**
	     * Used for DI
	     * @param browserDetails
	     */
	    function AnimationBuilder(browserDetails) {
	        this.browserDetails = browserDetails;
	    }
	    /**
	     * Creates a new CSS Animation
	     * @returns {CssAnimationBuilder}
	     */
	    AnimationBuilder.prototype.css = function () { return new css_animation_builder_1.CssAnimationBuilder(this.browserDetails); };
	    AnimationBuilder = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [browser_details_1.BrowserDetails])
	    ], AnimationBuilder);
	    return AnimationBuilder;
	}());
	exports.AnimationBuilder = AnimationBuilder;


/***/ },
/* 211 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var css_animation_options_1 = __webpack_require__(212);
	var animation_1 = __webpack_require__(213);
	var CssAnimationBuilder = (function () {
	    /**
	     * Accepts public properties for CssAnimationBuilder
	     */
	    function CssAnimationBuilder(browserDetails) {
	        this.browserDetails = browserDetails;
	        /** @type {CssAnimationOptions} */
	        this.data = new css_animation_options_1.CssAnimationOptions();
	    }
	    /**
	     * Adds a temporary class that will be removed at the end of the animation
	     * @param className
	     */
	    CssAnimationBuilder.prototype.addAnimationClass = function (className) {
	        this.data.animationClasses.push(className);
	        return this;
	    };
	    /**
	     * Adds a class that will remain on the element after the animation has finished
	     * @param className
	     */
	    CssAnimationBuilder.prototype.addClass = function (className) {
	        this.data.classesToAdd.push(className);
	        return this;
	    };
	    /**
	     * Removes a class from the element
	     * @param className
	     */
	    CssAnimationBuilder.prototype.removeClass = function (className) {
	        this.data.classesToRemove.push(className);
	        return this;
	    };
	    /**
	     * Sets the animation duration (and overrides any defined through CSS)
	     * @param duration
	     */
	    CssAnimationBuilder.prototype.setDuration = function (duration) {
	        this.data.duration = duration;
	        return this;
	    };
	    /**
	     * Sets the animation delay (and overrides any defined through CSS)
	     * @param delay
	     */
	    CssAnimationBuilder.prototype.setDelay = function (delay) {
	        this.data.delay = delay;
	        return this;
	    };
	    /**
	     * Sets styles for both the initial state and the destination state
	     * @param from
	     * @param to
	     */
	    CssAnimationBuilder.prototype.setStyles = function (from, to) {
	        return this.setFromStyles(from).setToStyles(to);
	    };
	    /**
	     * Sets the initial styles for the animation
	     * @param from
	     */
	    CssAnimationBuilder.prototype.setFromStyles = function (from) {
	        this.data.fromStyles = from;
	        return this;
	    };
	    /**
	     * Sets the destination styles for the animation
	     * @param to
	     */
	    CssAnimationBuilder.prototype.setToStyles = function (to) {
	        this.data.toStyles = to;
	        return this;
	    };
	    /**
	     * Starts the animation and returns a promise
	     * @param element
	     */
	    CssAnimationBuilder.prototype.start = function (element) {
	        return new animation_1.Animation(element, this.data, this.browserDetails);
	    };
	    return CssAnimationBuilder;
	}());
	exports.CssAnimationBuilder = CssAnimationBuilder;


/***/ },
/* 212 */
/***/ function(module, exports) {

	"use strict";
	var CssAnimationOptions = (function () {
	    function CssAnimationOptions() {
	        /** classes to be added to the element */
	        this.classesToAdd = [];
	        /** classes to be removed from the element */
	        this.classesToRemove = [];
	        /** classes to be added for the duration of the animation */
	        this.animationClasses = [];
	    }
	    return CssAnimationOptions;
	}());
	exports.CssAnimationOptions = CssAnimationOptions;


/***/ },
/* 213 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var math_1 = __webpack_require__(214);
	var util_1 = __webpack_require__(215);
	var collection_1 = __webpack_require__(15);
	var dom_adapter_1 = __webpack_require__(202);
	var Animation = (function () {
	    /**
	     * Stores the start time and starts the animation
	     * @param element
	     * @param data
	     * @param browserDetails
	     */
	    function Animation(element, data, browserDetails) {
	        var _this = this;
	        this.element = element;
	        this.data = data;
	        this.browserDetails = browserDetails;
	        /** functions to be called upon completion */
	        this.callbacks = [];
	        /** functions for removing event listeners */
	        this.eventClearFunctions = [];
	        /** flag used to track whether or not the animation has finished */
	        this.completed = false;
	        this._stringPrefix = '';
	        this.startTime = lang_1.DateWrapper.toMillis(lang_1.DateWrapper.now());
	        this._stringPrefix = dom_adapter_1.DOM.getAnimationPrefix();
	        this.setup();
	        this.wait(function (timestamp) { return _this.start(); });
	    }
	    Object.defineProperty(Animation.prototype, "totalTime", {
	        /** total amount of time that the animation should take including delay */
	        get: function () {
	            var delay = this.computedDelay != null ? this.computedDelay : 0;
	            var duration = this.computedDuration != null ? this.computedDuration : 0;
	            return delay + duration;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Animation.prototype.wait = function (callback) {
	        // Firefox requires 2 frames for some reason
	        this.browserDetails.raf(callback, 2);
	    };
	    /**
	     * Sets up the initial styles before the animation is started
	     */
	    Animation.prototype.setup = function () {
	        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
	     */
	    Animation.prototype.start = function () {
	        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_adapter_1.DOM.getComputedStyle(this.element);
	        this.computedDelay =
	            math_1.Math.max(this.parseDurationString(computedStyles.getPropertyValue(this._stringPrefix + 'transition-delay')), this.parseDurationString(this.element.style.getPropertyValue(this._stringPrefix + 'transition-delay')));
	        this.computedDuration = math_1.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
	     */
	    Animation.prototype.applyStyles = function (styles) {
	        var _this = this;
	        collection_1.StringMapWrapper.forEach(styles, function (value, key) {
	            var dashCaseKey = util_1.camelCaseToDashCase(key);
	            if (lang_1.isPresent(dom_adapter_1.DOM.getStyle(_this.element, dashCaseKey))) {
	                dom_adapter_1.DOM.setStyle(_this.element, dashCaseKey, value.toString());
	            }
	            else {
	                dom_adapter_1.DOM.setStyle(_this.element, _this._stringPrefix + dashCaseKey, value.toString());
	            }
	        });
	    };
	    /**
	     * Adds the provided classes to the element
	     * @param classes
	     */
	    Animation.prototype.addClasses = function (classes) {
	        for (var i = 0, len = classes.length; i < len; i++)
	            dom_adapter_1.DOM.addClass(this.element, classes[i]);
	    };
	    /**
	     * Removes the provided classes from the element
	     * @param classes
	     */
	    Animation.prototype.removeClasses = function (classes) {
	        for (var i = 0, len = classes.length; i < len; i++)
	            dom_adapter_1.DOM.removeClass(this.element, classes[i]);
	    };
	    /**
	     * Adds events to track when animations have finished
	     */
	    Animation.prototype.addEvents = function () {
	        var _this = this;
	        if (this.totalTime > 0) {
	            this.eventClearFunctions.push(dom_adapter_1.DOM.onAndCancel(this.element, dom_adapter_1.DOM.getTransitionEnd(), function (event) { return _this.handleAnimationEvent(event); }));
	        }
	        else {
	            this.handleAnimationCompleted();
	        }
	    };
	    Animation.prototype.handleAnimationEvent = function (event) {
	        var elapsedTime = math_1.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
	     */
	    Animation.prototype.handleAnimationCompleted = function () {
	        this.removeClasses(this.data.animationClasses);
	        this.callbacks.forEach(function (callback) { return callback(); });
	        this.callbacks = [];
	        this.eventClearFunctions.forEach(function (fn) { return fn(); });
	        this.eventClearFunctions = [];
	        this.completed = true;
	    };
	    /**
	     * Adds animation callbacks to be called upon completion
	     * @param callback
	     * @returns {Animation}
	     */
	    Animation.prototype.onComplete = function (callback) {
	        if (this.completed) {
	            callback();
	        }
	        else {
	            this.callbacks.push(callback);
	        }
	        return this;
	    };
	    /**
	     * Converts the duration string to the number of milliseconds
	     * @param duration
	     * @returns {number}
	     */
	    Animation.prototype.parseDurationString = function (duration) {
	        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') {
	            var value = lang_1.NumberWrapper.parseInt(this.stripLetters(duration), 10);
	            if (value > maxValue)
	                maxValue = value;
	        }
	        else if (duration.substring(duration.length - 1) == 's') {
	            var ms = lang_1.NumberWrapper.parseFloat(this.stripLetters(duration)) * 1000;
	            var value = math_1.Math.floor(ms);
	            if (value > maxValue)
	                maxValue = value;
	        }
	        return maxValue;
	    };
	    /**
	     * Strips the letters from the duration string
	     * @param str
	     * @returns {string}
	     */
	    Animation.prototype.stripLetters = function (str) {
	        return lang_1.StringWrapper.replaceAll(str, lang_1.RegExpWrapper.create('[^0-9]+$', ''), '');
	    };
	    return Animation;
	}());
	exports.Animation = Animation;


/***/ },
/* 214 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	exports.Math = lang_1.global.Math;
	exports.NaN = typeof exports.NaN;


/***/ },
/* 215 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var CAMEL_CASE_REGEXP = /([A-Z])/g;
	var DASH_CASE_REGEXP = /-([a-z])/g;
	function camelCaseToDashCase(input) {
	    return lang_1.StringWrapper.replaceAllMapped(input, CAMEL_CASE_REGEXP, function (m) { return '-' + m[1].toLowerCase(); });
	}
	exports.camelCaseToDashCase = camelCaseToDashCase;
	function dashCaseToCamelCase(input) {
	    return lang_1.StringWrapper.replaceAllMapped(input, DASH_CASE_REGEXP, function (m) { return m[1].toUpperCase(); });
	}
	exports.dashCaseToCamelCase = dashCaseToCamelCase;


/***/ },
/* 216 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var di_1 = __webpack_require__(6);
	var math_1 = __webpack_require__(214);
	var dom_adapter_1 = __webpack_require__(202);
	var BrowserDetails = (function () {
	    function BrowserDetails() {
	        this.elapsedTimeIncludesDelay = false;
	        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.
	     */
	    BrowserDetails.prototype.doesElapsedTimeIncludesDelay = function () {
	        var _this = this;
	        var div = dom_adapter_1.DOM.createElement('div');
	        dom_adapter_1.DOM.setAttribute(div, 'style', "position: absolute; top: -9999px; left: -9999px; width: 1px;\n      height: 1px; transition: all 1ms linear 1ms;");
	        // Firefox requires that we wait for 2 frames for some reason
	        this.raf(function (timestamp) {
	            dom_adapter_1.DOM.on(div, 'transitionend', function (event) {
	                var elapsed = math_1.Math.round(event.elapsedTime * 1000);
	                _this.elapsedTimeIncludesDelay = elapsed == 2;
	                dom_adapter_1.DOM.remove(div);
	            });
	            dom_adapter_1.DOM.setStyle(div, 'width', '2px');
	        }, 2);
	    };
	    BrowserDetails.prototype.raf = function (callback, frames) {
	        if (frames === void 0) { frames = 1; }
	        var queue = new RafQueue(callback, frames);
	        return function () { return queue.cancel(); };
	    };
	    BrowserDetails = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], BrowserDetails);
	    return BrowserDetails;
	}());
	exports.BrowserDetails = BrowserDetails;
	var RafQueue = (function () {
	    function RafQueue(callback, frames) {
	        this.callback = callback;
	        this.frames = frames;
	        this._raf();
	    }
	    RafQueue.prototype._raf = function () {
	        var _this = this;
	        this.currentFrameId =
	            dom_adapter_1.DOM.requestAnimationFrame(function (timestamp) { return _this._nextFrame(timestamp); });
	    };
	    RafQueue.prototype._nextFrame = function (timestamp) {
	        this.frames--;
	        if (this.frames > 0) {
	            this._raf();
	        }
	        else {
	            this.callback(timestamp);
	        }
	    };
	    RafQueue.prototype.cancel = function () {
	        dom_adapter_1.DOM.cancelAnimationFrame(this.currentFrameId);
	        this.currentFrameId = null;
	    };
	    return RafQueue;
	}());


/***/ },
/* 217 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var dom_adapter_1 = __webpack_require__(202);
	var di_1 = __webpack_require__(6);
	var collection_1 = __webpack_require__(15);
	var dom_tokens_1 = __webpack_require__(208);
	var SharedStylesHost = (function () {
	    function SharedStylesHost() {
	        /** @internal */
	        this._styles = [];
	        /** @internal */
	        this._stylesSet = new Set();
	    }
	    SharedStylesHost.prototype.addStyles = function (styles) {
	        var _this = this;
	        var additions = [];
	        styles.forEach(function (style) {
	            if (!collection_1.SetWrapper.has(_this._stylesSet, style)) {
	                _this._stylesSet.add(style);
	                _this._styles.push(style);
	                additions.push(style);
	            }
	        });
	        this.onStylesAdded(additions);
	    };
	    SharedStylesHost.prototype.onStylesAdded = function (additions) { };
	    SharedStylesHost.prototype.getAllStyles = function () { return this._styles; };
	    SharedStylesHost = __decorate([
	        di_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], SharedStylesHost);
	    return SharedStylesHost;
	}());
	exports.SharedStylesHost = SharedStylesHost;
	var DomSharedStylesHost = (function (_super) {
	    __extends(DomSharedStylesHost, _super);
	    function DomSharedStylesHost(doc) {
	        _super.call(this);
	        this._hostNodes = new Set();
	        this._hostNodes.add(doc.head);
	    }
	    /** @internal */
	    DomSharedStylesHost.prototype._addStylesToHost = function (styles, host) {
	        for (var i = 0; i < styles.length; i++) {
	            var style = styles[i];
	            dom_adapter_1.DOM.appendChild(host, dom_adapter_1.DOM.createStyleElement(style));
	        }
	    };
	    DomSharedStylesHost.prototype.addHost = function (hostNode) {
	        this._addStylesToHost(this._styles, hostNode);
	        this._hostNodes.add(hostNode);
	    };
	    DomSharedStylesHost.prototype.removeHost = function (hostNode) { collection_1.SetWrapper.delete(this._hostNodes, hostNode); };
	    DomSharedStylesHost.prototype.onStylesAdded = function (additions) {
	        var _this = this;
	        this._hostNodes.forEach(function (hostNode) { _this._addStylesToHost(additions, hostNode); });
	    };
	    DomSharedStylesHost = __decorate([
	        di_1.Injectable(),
	        __param(0, di_1.Inject(dom_tokens_1.DOCUMENT)), 
	        __metadata('design:paramtypes', [Object])
	    ], DomSharedStylesHost);
	    return DomSharedStylesHost;
	}(SharedStylesHost));
	exports.DomSharedStylesHost = DomSharedStylesHost;


/***/ },
/* 218 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	var dom_adapter_1 = __webpack_require__(202);
	var generic_browser_adapter_1 = __webpack_require__(219);
	var _attrToPropMap = {
	    'class': 'className',
	    'innerHtml': 'innerHTML',
	    'readonly': 'readOnly',
	    'tabindex': 'tabIndex'
	};
	var DOM_KEY_LOCATION_NUMPAD = 3;
	// Map to convert some key or keyIdentifier values to what will be returned by getEventKey
	var _keyMap = {
	    // The following values are here for cross-browser compatibility and to match the W3C standard
	    // cf http://www.w3.org/TR/DOM-Level-3-Events-key/
	    '\b': 'Backspace',
	    '\t': 'Tab',
	    '\x7F': 'Delete',
	    '\x1B': 'Escape',
	    'Del': 'Delete',
	    'Esc': 'Escape',
	    'Left': 'ArrowLeft',
	    'Right': 'ArrowRight',
	    'Up': 'ArrowUp',
	    'Down': 'ArrowDown',
	    'Menu': 'ContextMenu',
	    'Scroll': 'ScrollLock',
	    'Win': 'OS'
	};
	// There is a bug in Chrome for numeric keypad keys:
	// https://code.google.com/p/chromium/issues/detail?id=155654
	// 1, 2, 3 ... are reported as A, B, C ...
	var _chromeNumKeyPadMap = {
	    'A': '1',
	    'B': '2',
	    'C': '3',
	    'D': '4',
	    'E': '5',
	    'F': '6',
	    'G': '7',
	    'H': '8',
	    'I': '9',
	    'J': '*',
	    'K': '+',
	    'M': '-',
	    'N': '.',
	    'O': '/',
	    '\x60': '0',
	    '\x90': 'NumLock'
	};
	/**
	 * A `DomAdapter` powered by full browser DOM APIs.
	 */
	/* tslint:disable:requireParameterType */
	var BrowserDomAdapter = (function (_super) {
	    __extends(BrowserDomAdapter, _super);
	    function BrowserDomAdapter() {
	        _super.apply(this, arguments);
	    }
	    BrowserDomAdapter.prototype.parse = function (templateHtml) { throw new Error("parse not implemented"); };
	    BrowserDomAdapter.makeCurrent = function () { dom_adapter_1.setRootDomAdapter(new BrowserDomAdapter()); };
	    BrowserDomAdapter.prototype.hasProperty = function (element, name) { return name in element; };
	    BrowserDomAdapter.prototype.setProperty = function (el, name, value) { el[name] = value; };
	    BrowserDomAdapter.prototype.getProperty = function (el, name) { return el[name]; };
	    BrowserDomAdapter.prototype.invoke = function (el, methodName, args) {
	        el[methodName].apply(el, args);
	    };
	    // TODO(tbosch): move this into a separate environment class once we have it
	    BrowserDomAdapter.prototype.logError = function (error) {
	        if (window.console.error) {
	            window.console.error(error);
	        }
	        else {
	            window.console.log(error);
	        }
	    };
	    BrowserDomAdapter.prototype.log = function (error) { window.console.log(error); };
	    BrowserDomAdapter.prototype.logGroup = function (error) {
	        if (window.console.group) {
	            window.console.group(error);
	            this.logError(error);
	        }
	        else {
	            window.console.log(error);
	        }
	    };
	    BrowserDomAdapter.prototype.logGroupEnd = function () {
	        if (window.console.groupEnd) {
	            window.console.groupEnd();
	        }
	    };
	    Object.defineProperty(BrowserDomAdapter.prototype, "attrToPropMap", {
	        get: function () { return _attrToPropMap; },
	        enumerable: true,
	        configurable: true
	    });
	    BrowserDomAdapter.prototype.query = function (selector) { return document.querySelector(selector); };
	    BrowserDomAdapter.prototype.querySelector = function (el, selector) { return el.querySelector(selector); };
	    BrowserDomAdapter.prototype.querySelectorAll = function (el, selector) { return el.querySelectorAll(selector); };
	    BrowserDomAdapter.prototype.on = function (el, evt, listener) { el.addEventListener(evt, listener, false); };
	    BrowserDomAdapter.prototype.onAndCancel = function (el, evt, listener) {
	        el.addEventListener(evt, listener, false);
	        // Needed to follow Dart's subscription semantic, until fix of
	        // https://code.google.com/p/dart/issues/detail?id=17406
	        return function () { el.removeEventListener(evt, listener, false); };
	    };
	    BrowserDomAdapter.prototype.dispatchEvent = function (el, evt) { el.dispatchEvent(evt); };
	    BrowserDomAdapter.prototype.createMouseEvent = function (eventType) {
	        var evt = document.createEvent('MouseEvent');
	        evt.initEvent(eventType, true, true);
	        return evt;
	    };
	    BrowserDomAdapter.prototype.createEvent = function (eventType) {
	        var evt = document.createEvent('Event');
	        evt.initEvent(eventType, true, true);
	        return evt;
	    };
	    BrowserDomAdapter.prototype.preventDefault = function (evt) {
	        evt.preventDefault();
	        evt.returnValue = false;
	    };
	    BrowserDomAdapter.prototype.isPrevented = function (evt) {
	        return evt.defaultPrevented || lang_1.isPresent(evt.returnValue) && !evt.returnValue;
	    };
	    BrowserDomAdapter.prototype.getInnerHTML = function (el) { return el.innerHTML; };
	    BrowserDomAdapter.prototype.getOuterHTML = function (el) { return el.outerHTML; };
	    BrowserDomAdapter.prototype.nodeName = function (node) { return node.nodeName; };
	    BrowserDomAdapter.prototype.nodeValue = function (node) { return node.nodeValue; };
	    BrowserDomAdapter.prototype.type = function (node) { return node.type; };
	    BrowserDomAdapter.prototype.content = function (node) {
	        if (this.hasProperty(node, "content")) {
	            return node.content;
	        }
	        else {
	            return node;
	        }
	    };
	    BrowserDomAdapter.prototype.firstChild = function (el) { return el.firstChild; };
	    BrowserDomAdapter.prototype.nextSibling = function (el) { return el.nextSibling; };
	    BrowserDomAdapter.prototype.parentElement = function (el) { return el.parentNode; };
	    BrowserDomAdapter.prototype.childNodes = function (el) { return el.childNodes; };
	    BrowserDomAdapter.prototype.childNodesAsList = function (el) {
	        var childNodes = el.childNodes;
	        var res = collection_1.ListWrapper.createFixedSize(childNodes.length);
	        for (var i = 0; i < childNodes.length; i++) {
	            res[i] = childNodes[i];
	        }
	        return res;
	    };
	    BrowserDomAdapter.prototype.clearNodes = function (el) {
	        while (el.firstChild) {
	            el.removeChild(el.firstChild);
	        }
	    };
	    BrowserDomAdapter.prototype.appendChild = function (el, node) { el.appendChild(node); };
	    BrowserDomAdapter.prototype.removeChild = function (el, node) { el.removeChild(node); };
	    BrowserDomAdapter.prototype.replaceChild = function (el, newChild, oldChild) { el.replaceChild(newChild, oldChild); };
	    BrowserDomAdapter.prototype.remove = function (node) {
	        if (node.parentNode) {
	            node.parentNode.removeChild(node);
	        }
	        return node;
	    };
	    BrowserDomAdapter.prototype.insertBefore = function (el, node) { el.parentNode.insertBefore(node, el); };
	    BrowserDomAdapter.prototype.insertAllBefore = function (el, nodes) { nodes.forEach(function (n) { return el.parentNode.insertBefore(n, el); }); };
	    BrowserDomAdapter.prototype.insertAfter = function (el, node) { el.parentNode.insertBefore(node, el.nextSibling); };
	    BrowserDomAdapter.prototype.setInnerHTML = function (el, value) { el.innerHTML = value; };
	    BrowserDomAdapter.prototype.getText = function (el) { return el.textContent; };
	    // TODO(vicb): removed Element type because it does not support StyleElement
	    BrowserDomAdapter.prototype.setText = function (el, value) { el.textContent = value; };
	    BrowserDomAdapter.prototype.getValue = function (el) { return el.value; };
	    BrowserDomAdapter.prototype.setValue = function (el, value) { el.value = value; };
	    BrowserDomAdapter.prototype.getChecked = function (el) { return el.checked; };
	    BrowserDomAdapter.prototype.setChecked = function (el, value) { el.checked = value; };
	    BrowserDomAdapter.prototype.createComment = function (text) { return document.createComment(text); };
	    BrowserDomAdapter.prototype.createTemplate = function (html) {
	        var t = document.createElement('template');
	        t.innerHTML = html;
	        return t;
	    };
	    BrowserDomAdapter.prototype.createElement = function (tagName, doc) {
	        if (doc === void 0) { doc = document; }
	        return doc.createElement(tagName);
	    };
	    BrowserDomAdapter.prototype.createElementNS = function (ns, tagName, doc) {
	        if (doc === void 0) { doc = document; }
	        return doc.createElementNS(ns, tagName);
	    };
	    BrowserDomAdapter.prototype.createTextNode = function (text, doc) {
	        if (doc === void 0) { doc = document; }
	        return doc.createTextNode(text);
	    };
	    BrowserDomAdapter.prototype.createScriptTag = function (attrName, attrValue, doc) {
	        if (doc === void 0) { doc = document; }
	        var el = doc.createElement('SCRIPT');
	        el.setAttribute(attrName, attrValue);
	        return el;
	    };
	    BrowserDomAdapter.prototype.createStyleElement = function (css, doc) {
	        if (doc === void 0) { doc = document; }
	        var style = doc.createElement('style');
	        this.appendChild(style, this.createTextNode(css));
	        return style;
	    };
	    BrowserDomAdapter.prototype.createShadowRoot = function (el) { return el.createShadowRoot(); };
	    BrowserDomAdapter.prototype.getShadowRoot = function (el) { return el.shadowRoot; };
	    BrowserDomAdapter.prototype.getHost = function (el) { return el.host; };
	    BrowserDomAdapter.prototype.clone = function (node) { return node.cloneNode(true); };
	    BrowserDomAdapter.prototype.getElementsByClassName = function (element, name) {
	        return element.getElementsByClassName(name);
	    };
	    BrowserDomAdapter.prototype.getElementsByTagName = function (element, name) {
	        return element.getElementsByTagName(name);
	    };
	    BrowserDomAdapter.prototype.classList = function (element) { return Array.prototype.slice.call(element.classList, 0); };
	    BrowserDomAdapter.prototype.addClass = function (element, className) { element.classList.add(className); };
	    BrowserDomAdapter.prototype.removeClass = function (element, className) { element.classList.remove(className); };
	    BrowserDomAdapter.prototype.hasClass = function (element, className) { return element.classList.contains(className); };
	    BrowserDomAdapter.prototype.setStyle = function (element, styleName, styleValue) {
	        element.style[styleName] = styleValue;
	    };
	    BrowserDomAdapter.prototype.removeStyle = function (element, stylename) { element.style[stylename] = null; };
	    BrowserDomAdapter.prototype.getStyle = function (element, stylename) { return element.style[stylename]; };
	    BrowserDomAdapter.prototype.hasStyle = function (element, styleName, styleValue) {
	        if (styleValue === void 0) { styleValue = null; }
	        var value = this.getStyle(element, styleName) || '';
	        return styleValue ? value == styleValue : value.length > 0;
	    };
	    BrowserDomAdapter.prototype.tagName = function (element) { return element.tagName; };
	    BrowserDomAdapter.prototype.attributeMap = function (element) {
	        var res = new Map();
	        var elAttrs = element.attributes;
	        for (var i = 0; i < elAttrs.length; i++) {
	            var attrib = elAttrs[i];
	            res.set(attrib.name, attrib.value);
	        }
	        return res;
	    };
	    BrowserDomAdapter.prototype.hasAttribute = function (element, attribute) { return element.hasAttribute(attribute); };
	    BrowserDomAdapter.prototype.hasAttributeNS = function (element, ns, attribute) {
	        return element.hasAttributeNS(ns, attribute);
	    };
	    BrowserDomAdapter.prototype.getAttribute = function (element, attribute) { return element.getAttribute(attribute); };
	    BrowserDomAdapter.prototype.getAttributeNS = function (element, ns, name) {
	        return element.getAttributeNS(ns, name);
	    };
	    BrowserDomAdapter.prototype.setAttribute = function (element, name, value) { element.setAttribute(name, value); };
	    BrowserDomAdapter.prototype.setAttributeNS = function (element, ns, name, value) {
	        element.setAttributeNS(ns, name, value);
	    };
	    BrowserDomAdapter.prototype.removeAttribute = function (element, attribute) { element.removeAttribute(attribute); };
	    BrowserDomAdapter.prototype.removeAttributeNS = function (element, ns, name) { element.removeAttributeNS(ns, name); };
	    BrowserDomAdapter.prototype.templateAwareRoot = function (el) { return this.isTemplateElement(el) ? this.content(el) : el; };
	    BrowserDomAdapter.prototype.createHtmlDocument = function () {
	        return document.implementation.createHTMLDocument('fakeTitle');
	    };
	    BrowserDomAdapter.prototype.defaultDoc = function () { return document; };
	    BrowserDomAdapter.prototype.getBoundingClientRect = function (el) {
	        try {
	            return el.getBoundingClientRect();
	        }
	        catch (e) {
	            return { top: 0, bottom: 0, left: 0, right: 0, width: 0, height: 0 };
	        }
	    };
	    BrowserDomAdapter.prototype.getTitle = function () { return document.title; };
	    BrowserDomAdapter.prototype.setTitle = function (newTitle) { document.title = newTitle || ''; };
	    BrowserDomAdapter.prototype.elementMatches = function (n, selector) {
	        var matches = false;
	        if (n instanceof HTMLElement) {
	            if (n.matches) {
	                matches = n.matches(selector);
	            }
	            else if (n.msMatchesSelector) {
	                matches = n.msMatchesSelector(selector);
	            }
	            else if (n.webkitMatchesSelector) {
	                matches = n.webkitMatchesSelector(selector);
	            }
	        }
	        return matches;
	    };
	    BrowserDomAdapter.prototype.isTemplateElement = function (el) {
	        return el instanceof HTMLElement && el.nodeName == "TEMPLATE";
	    };
	    BrowserDomAdapter.prototype.isTextNode = function (node) { return node.nodeType === Node.TEXT_NODE; };
	    BrowserDomAdapter.prototype.isCommentNode = function (node) { return node.nodeType === Node.COMMENT_NODE; };
	    BrowserDomAdapter.prototype.isElementNode = function (node) { return node.nodeType === Node.ELEMENT_NODE; };
	    BrowserDomAdapter.prototype.hasShadowRoot = function (node) { return node instanceof HTMLElement && lang_1.isPresent(node.shadowRoot); };
	    BrowserDomAdapter.prototype.isShadowRoot = function (node) { return node instanceof DocumentFragment; };
	    BrowserDomAdapter.prototype.importIntoDoc = function (node) {
	        var toImport = node;
	        if (this.isTemplateElement(node)) {
	            toImport = this.content(node);
	        }
	        return document.importNode(toImport, true);
	    };
	    BrowserDomAdapter.prototype.adoptNode = function (node) { return document.adoptNode(node); };
	    BrowserDomAdapter.prototype.getHref = function (el) { return el.href; };
	    BrowserDomAdapter.prototype.getEventKey = function (event) {
	        var key = event.key;
	        if (lang_1.isBlank(key)) {
	            key = event.keyIdentifier;
	            // keyIdentifier is defined in the old draft of DOM Level 3 Events implemented by Chrome and
	            // Safari
	            // cf
	            // http://www.w3.org/TR/2007/WD-DOM-Level-3-Events-20071221/events.html#Events-KeyboardEvents-Interfaces
	            if (lang_1.isBlank(key)) {
	                return 'Unidentified';
	            }
	            if (key.startsWith('U+')) {
	                key = String.fromCharCode(parseInt(key.substring(2), 16));
	                if (event.location === DOM_KEY_LOCATION_NUMPAD && _chromeNumKeyPadMap.hasOwnProperty(key)) {
	                    // There is a bug in Chrome for numeric keypad keys:
	                    // https://code.google.com/p/chromium/issues/detail?id=155654
	                    // 1, 2, 3 ... are reported as A, B, C ...
	                    key = _chromeNumKeyPadMap[key];
	                }
	            }
	        }
	        if (_keyMap.hasOwnProperty(key)) {
	            key = _keyMap[key];
	        }
	        return key;
	    };
	    BrowserDomAdapter.prototype.getGlobalEventTarget = function (target) {
	        if (target == "window") {
	            return window;
	        }
	        else if (target == "document") {
	            return document;
	        }
	        else if (target == "body") {
	            return document.body;
	        }
	    };
	    BrowserDomAdapter.prototype.getHistory = function () { return window.history; };
	    BrowserDomAdapter.prototype.getLocation = function () { return window.location; };
	    BrowserDomAdapter.prototype.getBaseHref = function () {
	        var href = getBaseElementHref();
	        if (lang_1.isBlank(href)) {
	            return null;
	        }
	        return relativePath(href);
	    };
	    BrowserDomAdapter.prototype.resetBaseElement = function () { baseElement = null; };
	    BrowserDomAdapter.prototype.getUserAgent = function () { return window.navigator.userAgent; };
	    BrowserDomAdapter.prototype.setData = function (element, name, value) {
	        this.setAttribute(element, 'data-' + name, value);
	    };
	    BrowserDomAdapter.prototype.getData = function (element, name) { return this.getAttribute(element, 'data-' + name); };
	    BrowserDomAdapter.prototype.getComputedStyle = function (element) { return getComputedStyle(element); };
	    // TODO(tbosch): move this into a separate environment class once we have it
	    BrowserDomAdapter.prototype.setGlobalVar = function (path, value) { lang_1.setValueOnPath(lang_1.global, path, value); };
	    BrowserDomAdapter.prototype.requestAnimationFrame = function (callback) { return window.requestAnimationFrame(callback); };
	    BrowserDomAdapter.prototype.cancelAnimationFrame = function (id) { window.cancelAnimationFrame(id); };
	    BrowserDomAdapter.prototype.performanceNow = function () {
	        // performance.now() is not available in all browsers, see
	        // http://caniuse.com/#search=performance.now
	        if (lang_1.isPresent(window.performance) && lang_1.isPresent(window.performance.now)) {
	            return window.performance.now();
	        }
	        else {
	            return lang_1.DateWrapper.toMillis(lang_1.DateWrapper.now());
	        }
	    };
	    return BrowserDomAdapter;
	}(generic_browser_adapter_1.GenericBrowserDomAdapter));
	exports.BrowserDomAdapter = BrowserDomAdapter;
	var baseElement = null;
	function getBaseElementHref() {
	    if (lang_1.isBlank(baseElement)) {
	        baseElement = document.querySelector('base');
	        if (lang_1.isBlank(baseElement)) {
	            return null;
	        }
	    }
	    return baseElement.getAttribute('href');
	}
	// based on urlUtils.js in AngularJS 1
	var urlParsingNode = null;
	function relativePath(url) {
	    if (lang_1.isBlank(urlParsingNode)) {
	        urlParsingNode = document.createElement("a");
	    }
	    urlParsingNode.setAttribute('href', url);
	    return (urlParsingNode.pathname.charAt(0) === '/') ? urlParsingNode.pathname :
	        '/' + urlParsingNode.pathname;
	}


/***/ },
/* 219 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	var dom_adapter_1 = __webpack_require__(202);
	var xhr_impl_1 = __webpack_require__(220);
	/**
	 * Provides DOM operations in any browser environment.
	 */
	var GenericBrowserDomAdapter = (function (_super) {
	    __extends(GenericBrowserDomAdapter, _super);
	    function GenericBrowserDomAdapter() {
	        var _this = this;
	        _super.call(this);
	        this._animationPrefix = null;
	        this._transitionEnd = null;
	        try {
	            var element = this.createElement('div', this.defaultDoc());
	            if (lang_1.isPresent(this.getStyle(element, 'animationName'))) {
	                this._animationPrefix = '';
	            }
	            else {
	                var domPrefixes = ['Webkit', 'Moz', 'O', 'ms'];
	                for (var i = 0; i < domPrefixes.length; i++) {
	                    if (lang_1.isPresent(this.getStyle(element, domPrefixes[i] + 'AnimationName'))) {
	                        this._animationPrefix = '-' + domPrefixes[i].toLowerCase() + '-';
	                        break;
	                    }
	                }
	            }
	            var transEndEventNames = {
	                WebkitTransition: 'webkitTransitionEnd',
	                MozTransition: 'transitionend',
	                OTransition: 'oTransitionEnd otransitionend',
	                transition: 'transitionend'
	            };
	            collection_1.StringMapWrapper.forEach(transEndEventNames, function (value, key) {
	                if (lang_1.isPresent(_this.getStyle(element, key))) {
	                    _this._transitionEnd = value;
	                }
	            });
	        }
	        catch (e) {
	            this._animationPrefix = null;
	            this._transitionEnd = null;
	        }
	    }
	    GenericBrowserDomAdapter.prototype.getXHR = function () { return xhr_impl_1.XHRImpl; };
	    GenericBrowserDomAdapter.prototype.getDistributedNodes = function (el) { return el.getDistributedNodes(); };
	    GenericBrowserDomAdapter.prototype.resolveAndSetHref = function (el, baseUrl, href) {
	        el.href = href == null ? baseUrl : baseUrl + '/../' + href;
	    };
	    GenericBrowserDomAdapter.prototype.supportsDOMEvents = function () { return true; };
	    GenericBrowserDomAdapter.prototype.supportsNativeShadowDOM = function () {
	        return lang_1.isFunction(this.defaultDoc().body.createShadowRoot);
	    };
	    GenericBrowserDomAdapter.prototype.getAnimationPrefix = function () {
	        return lang_1.isPresent(this._animationPrefix) ? this._animationPrefix : "";
	    };
	    GenericBrowserDomAdapter.prototype.getTransitionEnd = function () { return lang_1.isPresent(this._transitionEnd) ? this._transitionEnd : ""; };
	    GenericBrowserDomAdapter.prototype.supportsAnimation = function () {
	        return lang_1.isPresent(this._animationPrefix) && lang_1.isPresent(this._transitionEnd);
	    };
	    return GenericBrowserDomAdapter;
	}(dom_adapter_1.DomAdapter));
	exports.GenericBrowserDomAdapter = GenericBrowserDomAdapter;


/***/ },
/* 220 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var promise_1 = __webpack_require__(42);
	var lang_1 = __webpack_require__(5);
	var xhr_1 = __webpack_require__(186);
	var XHRImpl = (function (_super) {
	    __extends(XHRImpl, _super);
	    function XHRImpl() {
	        _super.apply(this, arguments);
	    }
	    XHRImpl.prototype.get = function (url) {
	        var completer = promise_1.PromiseWrapper.completer();
	        var xhr = new XMLHttpRequest();
	        xhr.open('GET', url, true);
	        xhr.responseType = 'text';
	        xhr.onload = function () {
	            // responseText is the old-school way of retrieving response (supported by IE8 & 9)
	            // response/responseType properties were introduced in XHR Level2 spec (supported by IE10)
	            var response = lang_1.isPresent(xhr.response) ? xhr.response : xhr.responseText;
	            // normalize IE9 bug (http://bugs.jquery.com/ticket/1450)
	            var status = xhr.status === 1223 ? 204 : xhr.status;
	            // fix status code when it is 0 (0 status is undocumented).
	            // Occurs when accessing file resources or on Android 4.1 stock browser
	            // while retrieving files from application cache.
	            if (status === 0) {
	                status = response ? 200 : 0;
	            }
	            if (200 <= status && status <= 300) {
	                completer.resolve(response);
	            }
	            else {
	                completer.reject("Failed to load " + url, null);
	            }
	        };
	        xhr.onerror = function () { completer.reject("Failed to load " + url, null); };
	        xhr.send();
	        return completer.promise;
	    };
	    return XHRImpl;
	}(xhr_1.XHR));
	exports.XHRImpl = XHRImpl;


/***/ },
/* 221 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	var dom_adapter_1 = __webpack_require__(202);
	var core_1 = __webpack_require__(2);
	var PublicTestability = (function () {
	    function PublicTestability(testability) {
	        this._testability = testability;
	    }
	    PublicTestability.prototype.isStable = function () { return this._testability.isStable(); };
	    PublicTestability.prototype.whenStable = function (callback) { this._testability.whenStable(callback); };
	    PublicTestability.prototype.findBindings = function (using, provider, exactMatch) {
	        return this.findProviders(using, provider, exactMatch);
	    };
	    PublicTestability.prototype.findProviders = function (using, provider, exactMatch) {
	        return this._testability.findBindings(using, provider, exactMatch);
	    };
	    return PublicTestability;
	}());
	var BrowserGetTestability = (function () {
	    function BrowserGetTestability() {
	    }
	    BrowserGetTestability.init = function () { core_1.setTestabilityGetter(new BrowserGetTestability()); };
	    BrowserGetTestability.prototype.addToWindow = function (registry) {
	        lang_1.global.getAngularTestability = function (elem, findInAncestors) {
	            if (findInAncestors === void 0) { findInAncestors = true; }
	            var testability = registry.findTestabilityInTree(elem, findInAncestors);
	            if (testability == null) {
	                throw new Error('Could not find testability for element.');
	            }
	            return new PublicTestability(testability);
	        };
	        lang_1.global.getAllAngularTestabilities = function () {
	            var testabilities = registry.getAllTestabilities();
	            return testabilities.map(function (testability) { return new PublicTestability(testability); });
	        };
	        lang_1.global.getAllAngularRootElements = function () { return registry.getAllRootElements(); };
	        var whenAllStable = function (callback) {
	            var testabilities = lang_1.global.getAllAngularTestabilities();
	            var count = testabilities.length;
	            var didWork = false;
	            var decrement = function (didWork_) {
	                didWork = didWork || didWork_;
	                count--;
	                if (count == 0) {
	                    callback(didWork);
	                }
	            };
	            testabilities.forEach(function (testability) { testability.whenStable(decrement); });
	        };
	        if (!lang_1.global.frameworkStabilizers) {
	            lang_1.global.frameworkStabilizers = collection_1.ListWrapper.createGrowableSize(0);
	        }
	        lang_1.global.frameworkStabilizers.push(whenAllStable);
	    };
	    BrowserGetTestability.prototype.findTestabilityInTree = function (registry, elem, findInAncestors) {
	        if (elem == null) {
	            return null;
	        }
	        var t = registry.getTestability(elem);
	        if (lang_1.isPresent(t)) {
	            return t;
	        }
	        else if (!findInAncestors) {
	            return null;
	        }
	        if (dom_adapter_1.DOM.isShadowRoot(elem)) {
	            return this.findTestabilityInTree(registry, dom_adapter_1.DOM.getHost(elem), true);
	        }
	        return this.findTestabilityInTree(registry, dom_adapter_1.DOM.parentElement(elem), true);
	    };
	    return BrowserGetTestability;
	}());
	exports.BrowserGetTestability = BrowserGetTestability;


/***/ },
/* 222 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var xhr_1 = __webpack_require__(186);
	var exceptions_1 = __webpack_require__(12);
	var lang_1 = __webpack_require__(5);
	var promise_1 = __webpack_require__(42);
	/**
	 * An implementation of XHR that uses a template cache to avoid doing an actual
	 * XHR.
	 *
	 * The template cache needs to be built and loaded into window.$templateCache
	 * via a separate mechanism.
	 */
	var CachedXHR = (function (_super) {
	    __extends(CachedXHR, _super);
	    function CachedXHR() {
	        _super.call(this);
	        this._cache = lang_1.global.$templateCache;
	        if (this._cache == null) {
	            throw new exceptions_1.BaseException('CachedXHR: Template cache was not found in $templateCache.');
	        }
	    }
	    CachedXHR.prototype.get = function (url) {
	        if (this._cache.hasOwnProperty(url)) {
	            return promise_1.PromiseWrapper.resolve(this._cache[url]);
	        }
	        else {
	            return promise_1.PromiseWrapper.reject('CachedXHR: Did not find cached template for ' + url, null);
	        }
	    };
	    return CachedXHR;
	}(xhr_1.XHR));
	exports.CachedXHR = CachedXHR;


/***/ },
/* 223 */
/***/ function(module, exports) {

	"use strict";
	/**
	 * This is here because DART requires it. It is noop in JS.
	 */
	function wtfInit() { }
	exports.wtfInit = wtfInit;


/***/ },
/* 224 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var hammer_common_1 = __webpack_require__(225);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var core_1 = __webpack_require__(2);
	exports.HAMMER_GESTURE_CONFIG = 
	/*@ts2dart_const*/ new core_1.OpaqueToken("HammerGestureConfig");
	var HammerGestureConfig = (function () {
	    function HammerGestureConfig() {
	        this.events = [];
	        this.overrides = {};
	    }
	    HammerGestureConfig.prototype.buildHammer = function (element) {
	        var mc = new Hammer(element);
	        mc.get('pinch').set({ enable: true });
	        mc.get('rotate').set({ enable: true });
	        for (var eventName in this.overrides) {
	            mc.get(eventName).set(this.overrides[eventName]);
	        }
	        return mc;
	    };
	    HammerGestureConfig = __decorate([
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], HammerGestureConfig);
	    return HammerGestureConfig;
	}());
	exports.HammerGestureConfig = HammerGestureConfig;
	var HammerGesturesPlugin = (function (_super) {
	    __extends(HammerGesturesPlugin, _super);
	    function HammerGesturesPlugin(_config) {
	        _super.call(this);
	        this._config = _config;
	    }
	    HammerGesturesPlugin.prototype.supports = function (eventName) {
	        if (!_super.prototype.supports.call(this, eventName) && !this.isCustomEvent(eventName))
	            return false;
	        if (!lang_1.isPresent(window['Hammer'])) {
	            throw new exceptions_1.BaseException("Hammer.js is not loaded, can not bind " + eventName + " event");
	        }
	        return true;
	    };
	    HammerGesturesPlugin.prototype.addEventListener = function (element, eventName, handler) {
	        var _this = this;
	        var zone = this.manager.getZone();
	        eventName = eventName.toLowerCase();
	        return zone.runOutsideAngular(function () {
	            // Creating the manager bind events, must be done outside of angular
	            var mc = _this._config.buildHammer(element);
	            var callback = function (eventObj) { zone.runGuarded(function () { handler(eventObj); }); };
	            mc.on(eventName, callback);
	            return function () { mc.off(eventName, callback); };
	        });
	    };
	    HammerGesturesPlugin.prototype.isCustomEvent = function (eventName) { return this._config.events.indexOf(eventName) > -1; };
	    HammerGesturesPlugin = __decorate([
	        core_1.Injectable(),
	        __param(0, core_1.Inject(exports.HAMMER_GESTURE_CONFIG)), 
	        __metadata('design:paramtypes', [HammerGestureConfig])
	    ], HammerGesturesPlugin);
	    return HammerGesturesPlugin;
	}(hammer_common_1.HammerGesturesPluginCommon));
	exports.HammerGesturesPlugin = HammerGesturesPlugin;


/***/ },
/* 225 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var event_manager_1 = __webpack_require__(206);
	var collection_1 = __webpack_require__(15);
	var _eventNames = {
	    // pan
	    'pan': true,
	    'panstart': true,
	    'panmove': true,
	    'panend': true,
	    'pancancel': true,
	    'panleft': true,
	    'panright': true,
	    'panup': true,
	    'pandown': true,
	    // pinch
	    'pinch': true,
	    'pinchstart': true,
	    'pinchmove': true,
	    'pinchend': true,
	    'pinchcancel': true,
	    'pinchin': true,
	    'pinchout': true,
	    // press
	    'press': true,
	    'pressup': true,
	    // rotate
	    'rotate': true,
	    'rotatestart': true,
	    'rotatemove': true,
	    'rotateend': true,
	    'rotatecancel': true,
	    // swipe
	    'swipe': true,
	    'swipeleft': true,
	    'swiperight': true,
	    'swipeup': true,
	    'swipedown': true,
	    // tap
	    'tap': true,
	};
	var HammerGesturesPluginCommon = (function (_super) {
	    __extends(HammerGesturesPluginCommon, _super);
	    function HammerGesturesPluginCommon() {
	        _super.call(this);
	    }
	    HammerGesturesPluginCommon.prototype.supports = function (eventName) {
	        eventName = eventName.toLowerCase();
	        return collection_1.StringMapWrapper.contains(_eventNames, eventName);
	    };
	    return HammerGesturesPluginCommon;
	}(event_manager_1.EventManagerPlugin));
	exports.HammerGesturesPluginCommon = HammerGesturesPluginCommon;


/***/ },
/* 226 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	function __export(m) {
	    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
	}
	/**
	 * This is a set of DOM related classes and objects that can be used both in the browser and on the
	 * server.
	 */
	var dom_adapter_1 = __webpack_require__(202);
	exports.DOM = dom_adapter_1.DOM;
	exports.setRootDomAdapter = dom_adapter_1.setRootDomAdapter;
	exports.DomAdapter = dom_adapter_1.DomAdapter;
	var dom_renderer_1 = __webpack_require__(209);
	exports.DomRenderer = dom_renderer_1.DomRenderer;
	var dom_tokens_1 = __webpack_require__(208);
	exports.DOCUMENT = dom_tokens_1.DOCUMENT;
	var shared_styles_host_1 = __webpack_require__(217);
	exports.SharedStylesHost = shared_styles_host_1.SharedStylesHost;
	exports.DomSharedStylesHost = shared_styles_host_1.DomSharedStylesHost;
	var dom_events_1 = __webpack_require__(205);
	exports.DomEventsPlugin = dom_events_1.DomEventsPlugin;
	var event_manager_1 = __webpack_require__(206);
	exports.EVENT_MANAGER_PLUGINS = event_manager_1.EVENT_MANAGER_PLUGINS;
	exports.EventManager = event_manager_1.EventManager;
	exports.EventManagerPlugin = event_manager_1.EventManagerPlugin;
	__export(__webpack_require__(227));
	__export(__webpack_require__(228));


/***/ },
/* 227 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var dom_adapter_1 = __webpack_require__(202);
	/**
	 * Predicates for use with {@link DebugElement}'s query functions.
	 */
	var By = (function () {
	    function By() {
	    }
	    /**
	     * Match all elements.
	     *
	     * ## Example
	     *
	     * {@example platform/dom/debug/ts/by/by.ts region='by_all'}
	     */
	    By.all = function () { return function (debugElement) { return true; }; };
	    /**
	     * Match elements by the given CSS selector.
	     *
	     * ## Example
	     *
	     * {@example platform/dom/debug/ts/by/by.ts region='by_css'}
	     */
	    By.css = function (selector) {
	        return function (debugElement) {
	            return lang_1.isPresent(debugElement.nativeElement) ?
	                dom_adapter_1.DOM.elementMatches(debugElement.nativeElement, selector) :
	                false;
	        };
	    };
	    /**
	     * Match elements that have the given directive present.
	     *
	     * ## Example
	     *
	     * {@example platform/dom/debug/ts/by/by.ts region='by_directive'}
	     */
	    By.directive = function (type) {
	        return function (debugElement) { return debugElement.providerTokens.indexOf(type) !== -1; };
	    };
	    return By;
	}());
	exports.By = By;


/***/ },
/* 228 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var dom_adapter_1 = __webpack_require__(202);
	var debug_node_1 = __webpack_require__(85);
	var dom_renderer_1 = __webpack_require__(209);
	var core_1 = __webpack_require__(2);
	var debug_renderer_1 = __webpack_require__(229);
	var CORE_TOKENS = { 'ApplicationRef': core_1.ApplicationRef, 'NgZone': core_1.NgZone };
	var INSPECT_GLOBAL_NAME = 'ng.probe';
	var CORE_TOKENS_GLOBAL_NAME = 'ng.coreTokens';
	/**
	 * Returns a {@link DebugElement} for the given native DOM element, or
	 * null if the given native element does not have an Angular view associated
	 * with it.
	 */
	function inspectNativeElement(element) {
	    return debug_node_1.getDebugNode(element);
	}
	exports.inspectNativeElement = inspectNativeElement;
	function _createConditionalRootRenderer(rootRenderer) {
	    if (lang_1.assertionsEnabled()) {
	        return _createRootRenderer(rootRenderer);
	    }
	    return rootRenderer;
	}
	function _createRootRenderer(rootRenderer) {
	    dom_adapter_1.DOM.setGlobalVar(INSPECT_GLOBAL_NAME, inspectNativeElement);
	    dom_adapter_1.DOM.setGlobalVar(CORE_TOKENS_GLOBAL_NAME, CORE_TOKENS);
	    return new debug_renderer_1.DebugDomRootRenderer(rootRenderer);
	}
	/**
	 * Providers which support debugging Angular applications (e.g. via `ng.probe`).
	 */
	exports.ELEMENT_PROBE_PROVIDERS = [
	    /*@ts2dart_Provider*/ {
	        provide: core_1.RootRenderer,
	        useFactory: _createConditionalRootRenderer,
	        deps: [dom_renderer_1.DomRootRenderer]
	    }
	];
	exports.ELEMENT_PROBE_PROVIDERS_PROD_MODE = [
	    /*@ts2dart_Provider*/ {
	        provide: core_1.RootRenderer,
	        useFactory: _createRootRenderer,
	        deps: [dom_renderer_1.DomRootRenderer]
	    }
	];


/***/ },
/* 229 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var debug_node_1 = __webpack_require__(85);
	var DebugDomRootRenderer = (function () {
	    function DebugDomRootRenderer(_delegate) {
	        this._delegate = _delegate;
	    }
	    DebugDomRootRenderer.prototype.renderComponent = function (componentProto) {
	        return new DebugDomRenderer(this._delegate.renderComponent(componentProto));
	    };
	    return DebugDomRootRenderer;
	}());
	exports.DebugDomRootRenderer = DebugDomRootRenderer;
	var DebugDomRenderer = (function () {
	    function DebugDomRenderer(_delegate) {
	        this._delegate = _delegate;
	    }
	    DebugDomRenderer.prototype.selectRootElement = function (selectorOrNode, debugInfo) {
	        var nativeEl = this._delegate.selectRootElement(selectorOrNode, debugInfo);
	        var debugEl = new debug_node_1.DebugElement(nativeEl, null, debugInfo);
	        debug_node_1.indexDebugNode(debugEl);
	        return nativeEl;
	    };
	    DebugDomRenderer.prototype.createElement = function (parentElement, name, debugInfo) {
	        var nativeEl = this._delegate.createElement(parentElement, name, debugInfo);
	        var debugEl = new debug_node_1.DebugElement(nativeEl, debug_node_1.getDebugNode(parentElement), debugInfo);
	        debugEl.name = name;
	        debug_node_1.indexDebugNode(debugEl);
	        return nativeEl;
	    };
	    DebugDomRenderer.prototype.createViewRoot = function (hostElement) { return this._delegate.createViewRoot(hostElement); };
	    DebugDomRenderer.prototype.createTemplateAnchor = function (parentElement, debugInfo) {
	        var comment = this._delegate.createTemplateAnchor(parentElement, debugInfo);
	        var debugEl = new debug_node_1.DebugNode(comment, debug_node_1.getDebugNode(parentElement), debugInfo);
	        debug_node_1.indexDebugNode(debugEl);
	        return comment;
	    };
	    DebugDomRenderer.prototype.createText = function (parentElement, value, debugInfo) {
	        var text = this._delegate.createText(parentElement, value, debugInfo);
	        var debugEl = new debug_node_1.DebugNode(text, debug_node_1.getDebugNode(parentElement), debugInfo);
	        debug_node_1.indexDebugNode(debugEl);
	        return text;
	    };
	    DebugDomRenderer.prototype.projectNodes = function (parentElement, nodes) {
	        var debugParent = debug_node_1.getDebugNode(parentElement);
	        if (lang_1.isPresent(debugParent) && debugParent instanceof debug_node_1.DebugElement) {
	            var debugElement_1 = debugParent;
	            nodes.forEach(function (node) { debugElement_1.addChild(debug_node_1.getDebugNode(node)); });
	        }
	        this._delegate.projectNodes(parentElement, nodes);
	    };
	    DebugDomRenderer.prototype.attachViewAfter = function (node, viewRootNodes) {
	        var debugNode = debug_node_1.getDebugNode(node);
	        if (lang_1.isPresent(debugNode)) {
	            var debugParent = debugNode.parent;
	            if (viewRootNodes.length > 0 && lang_1.isPresent(debugParent)) {
	                var debugViewRootNodes = [];
	                viewRootNodes.forEach(function (rootNode) { return debugViewRootNodes.push(debug_node_1.getDebugNode(rootNode)); });
	                debugParent.insertChildrenAfter(debugNode, debugViewRootNodes);
	            }
	        }
	        this._delegate.attachViewAfter(node, viewRootNodes);
	    };
	    DebugDomRenderer.prototype.detachView = function (viewRootNodes) {
	        viewRootNodes.forEach(function (node) {
	            var debugNode = debug_node_1.getDebugNode(node);
	            if (lang_1.isPresent(debugNode) && lang_1.isPresent(debugNode.parent)) {
	                debugNode.parent.removeChild(debugNode);
	            }
	        });
	        this._delegate.detachView(viewRootNodes);
	    };
	    DebugDomRenderer.prototype.destroyView = function (hostElement, viewAllNodes) {
	        viewAllNodes.forEach(function (node) { debug_node_1.removeDebugNodeFromIndex(debug_node_1.getDebugNode(node)); });
	        this._delegate.destroyView(hostElement, viewAllNodes);
	    };
	    DebugDomRenderer.prototype.listen = function (renderElement, name, callback) {
	        var debugEl = debug_node_1.getDebugNode(renderElement);
	        if (lang_1.isPresent(debugEl)) {
	            debugEl.listeners.push(new debug_node_1.EventListener(name, callback));
	        }
	        return this._delegate.listen(renderElement, name, callback);
	    };
	    DebugDomRenderer.prototype.listenGlobal = function (target, name, callback) {
	        return this._delegate.listenGlobal(target, name, callback);
	    };
	    DebugDomRenderer.prototype.setElementProperty = function (renderElement, propertyName, propertyValue) {
	        var debugEl = debug_node_1.getDebugNode(renderElement);
	        if (lang_1.isPresent(debugEl) && debugEl instanceof debug_node_1.DebugElement) {
	            debugEl.properties[propertyName] = propertyValue;
	        }
	        this._delegate.setElementProperty(renderElement, propertyName, propertyValue);
	    };
	    DebugDomRenderer.prototype.setElementAttribute = function (renderElement, attributeName, attributeValue) {
	        var debugEl = debug_node_1.getDebugNode(renderElement);
	        if (lang_1.isPresent(debugEl) && debugEl instanceof debug_node_1.DebugElement) {
	            debugEl.attributes[attributeName] = attributeValue;
	        }
	        this._delegate.setElementAttribute(renderElement, attributeName, attributeValue);
	    };
	    DebugDomRenderer.prototype.setBindingDebugInfo = function (renderElement, propertyName, propertyValue) {
	        this._delegate.setBindingDebugInfo(renderElement, propertyName, propertyValue);
	    };
	    DebugDomRenderer.prototype.setElementClass = function (renderElement, className, isAdd) {
	        this._delegate.setElementClass(renderElement, className, isAdd);
	    };
	    DebugDomRenderer.prototype.setElementStyle = function (renderElement, styleName, styleValue) {
	        this._delegate.setElementStyle(renderElement, styleName, styleValue);
	    };
	    DebugDomRenderer.prototype.invokeElementMethod = function (renderElement, methodName, args) {
	        this._delegate.invokeElementMethod(renderElement, methodName, args);
	    };
	    DebugDomRenderer.prototype.setText = function (renderNode, text) { this._delegate.setText(renderNode, text); };
	    return DebugDomRenderer;
	}());
	exports.DebugDomRenderer = DebugDomRenderer;


/***/ },
/* 230 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var dom_adapter_1 = __webpack_require__(202);
	/**
	 * A service that can be used to get and set the title of a current HTML document.
	 *
	 * Since an Angular 2 application can't be bootstrapped on the entire HTML document (`<html>` tag)
	 * it is not possible to bind to the `text` property of the `HTMLTitleElement` elements
	 * (representing the `<title>` tag). Instead, this service can be used to set and get the current
	 * title value.
	 */
	var Title = (function () {
	    function Title() {
	    }
	    /**
	     * Get the title of the current HTML document.
	     * @returns {string}
	     */
	    Title.prototype.getTitle = function () { return dom_adapter_1.DOM.getTitle(); };
	    /**
	     * Set the title of the current HTML document.
	     * @param newTitle
	     */
	    Title.prototype.setTitle = function (newTitle) { dom_adapter_1.DOM.setTitle(newTitle); };
	    return Title;
	}());
	exports.Title = Title;


/***/ },
/* 231 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var common_tools_1 = __webpack_require__(232);
	var context = lang_1.global;
	/**
	 * Enabled Angular 2 debug tools that are accessible via your browser's
	 * developer console.
	 *
	 * Usage:
	 *
	 * 1. Open developer console (e.g. in Chrome Ctrl + Shift + j)
	 * 1. Type `ng.` (usually the console will show auto-complete suggestion)
	 * 1. Try the change detection profiler `ng.profiler.timeChangeDetection()`
	 *    then hit Enter.
	 */
	function enableDebugTools(ref) {
	    context.ng = new common_tools_1.AngularTools(ref);
	}
	exports.enableDebugTools = enableDebugTools;
	/**
	 * Disables Angular 2 tools.
	 */
	function disableDebugTools() {
	    delete context.ng;
	}
	exports.disableDebugTools = disableDebugTools;


/***/ },
/* 232 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var application_ref_1 = __webpack_require__(61);
	var lang_1 = __webpack_require__(5);
	var browser_1 = __webpack_require__(233);
	var dom_adapter_1 = __webpack_require__(202);
	var ChangeDetectionPerfRecord = (function () {
	    function ChangeDetectionPerfRecord(msPerTick, numTicks) {
	        this.msPerTick = msPerTick;
	        this.numTicks = numTicks;
	    }
	    return ChangeDetectionPerfRecord;
	}());
	exports.ChangeDetectionPerfRecord = ChangeDetectionPerfRecord;
	/**
	 * Entry point for all Angular debug tools. This object corresponds to the `ng`
	 * global variable accessible in the dev console.
	 */
	var AngularTools = (function () {
	    function AngularTools(ref) {
	        this.profiler = new AngularProfiler(ref);
	    }
	    return AngularTools;
	}());
	exports.AngularTools = AngularTools;
	/**
	 * Entry point for all Angular profiling-related debug tools. This object
	 * corresponds to the `ng.profiler` in the dev console.
	 */
	var AngularProfiler = (function () {
	    function AngularProfiler(ref) {
	        this.appRef = ref.injector.get(application_ref_1.ApplicationRef);
	    }
	    /**
	     * Exercises change detection in a loop and then prints the average amount of
	     * time in milliseconds how long a single round of change detection takes for
	     * the current state of the UI. It runs a minimum of 5 rounds for a minimum
	     * of 500 milliseconds.
	     *
	     * Optionally, a user may pass a `config` parameter containing a map of
	     * options. Supported options are:
	     *
	     * `record` (boolean) - causes the profiler to record a CPU profile while
	     * it exercises the change detector. Example:
	     *
	     * ```
	     * ng.profiler.timeChangeDetection({record: true})
	     * ```
	     */
	    AngularProfiler.prototype.timeChangeDetection = function (config) {
	        var record = lang_1.isPresent(config) && config['record'];
	        var profileName = 'Change Detection';
	        // Profiler is not available in Android browsers, nor in IE 9 without dev tools opened
	        var isProfilerAvailable = lang_1.isPresent(browser_1.window.console.profile);
	        if (record && isProfilerAvailable) {
	            browser_1.window.console.profile(profileName);
	        }
	        var start = dom_adapter_1.DOM.performanceNow();
	        var numTicks = 0;
	        while (numTicks < 5 || (dom_adapter_1.DOM.performanceNow() - start) < 500) {
	            this.appRef.tick();
	            numTicks++;
	        }
	        var end = dom_adapter_1.DOM.performanceNow();
	        if (record && isProfilerAvailable) {
	            // need to cast to <any> because type checker thinks there's no argument
	            // while in fact there is:
	            //
	            // https://developer.mozilla.org/en-US/docs/Web/API/Console/profileEnd
	            browser_1.window.console.profileEnd(profileName);
	        }
	        var msPerTick = (end - start) / numTicks;
	        browser_1.window.console.log("ran " + numTicks + " change detection cycles");
	        browser_1.window.console.log(lang_1.NumberWrapper.toFixed(msPerTick, 2) + " ms per check");
	        return new ChangeDetectionPerfRecord(msPerTick, numTicks);
	    };
	    return AngularProfiler;
	}());
	exports.AngularProfiler = AngularProfiler;


/***/ },
/* 233 */
/***/ function(module, exports) {

	"use strict";
	/**
	 * JS version of browser APIs. This library can only run in the browser.
	 */
	var win = window;
	exports.window = win;
	exports.document = window.document;
	exports.location = window.location;
	exports.gc = window['gc'] ? function () { return window['gc'](); } : function () { return null; };
	exports.performance = window['performance'] ? window['performance'] : null;
	exports.Event = window['Event'];
	exports.MouseEvent = window['MouseEvent'];
	exports.KeyboardEvent = window['KeyboardEvent'];
	exports.EventTarget = window['EventTarget'];
	exports.History = window['History'];
	exports.Location = window['Location'];
	exports.EventListener = window['EventListener'];


/***/ },
/* 234 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	/**
	 * @module
	 * @description
	 * The http module provides services to perform http requests. To get started, see the {@link Http}
	 * class.
	 */
	var core_1 = __webpack_require__(2);
	var http_1 = __webpack_require__(235);
	var xhr_backend_1 = __webpack_require__(243);
	var jsonp_backend_1 = __webpack_require__(247);
	var browser_xhr_1 = __webpack_require__(246);
	var browser_jsonp_1 = __webpack_require__(248);
	var base_request_options_1 = __webpack_require__(241);
	var base_response_options_1 = __webpack_require__(245);
	var static_request_1 = __webpack_require__(237);
	exports.Request = static_request_1.Request;
	var static_response_1 = __webpack_require__(244);
	exports.Response = static_response_1.Response;
	var interfaces_1 = __webpack_require__(236);
	exports.Connection = interfaces_1.Connection;
	exports.ConnectionBackend = interfaces_1.ConnectionBackend;
	var browser_xhr_2 = __webpack_require__(246);
	exports.BrowserXhr = browser_xhr_2.BrowserXhr;
	var base_request_options_2 = __webpack_require__(241);
	exports.BaseRequestOptions = base_request_options_2.BaseRequestOptions;
	exports.RequestOptions = base_request_options_2.RequestOptions;
	var base_response_options_2 = __webpack_require__(245);
	exports.BaseResponseOptions = base_response_options_2.BaseResponseOptions;
	exports.ResponseOptions = base_response_options_2.ResponseOptions;
	var xhr_backend_2 = __webpack_require__(243);
	exports.XHRBackend = xhr_backend_2.XHRBackend;
	exports.XHRConnection = xhr_backend_2.XHRConnection;
	var jsonp_backend_2 = __webpack_require__(247);
	exports.JSONPBackend = jsonp_backend_2.JSONPBackend;
	exports.JSONPConnection = jsonp_backend_2.JSONPConnection;
	var http_2 = __webpack_require__(235);
	exports.Http = http_2.Http;
	exports.Jsonp = http_2.Jsonp;
	var headers_1 = __webpack_require__(238);
	exports.Headers = headers_1.Headers;
	var enums_1 = __webpack_require__(240);
	exports.ResponseType = enums_1.ResponseType;
	exports.ReadyState = enums_1.ReadyState;
	exports.RequestMethod = enums_1.RequestMethod;
	var url_search_params_1 = __webpack_require__(242);
	exports.URLSearchParams = url_search_params_1.URLSearchParams;
	/**
	 * 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="let 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);
	 *   }
	 * });
	 * ```
	 */
	exports.HTTP_PROVIDERS = [
	    // TODO(pascal): use factory type annotations once supported in DI
	    // issue: https://github.com/angular/angular/issues/3183
	    core_1.provide(http_1.Http, {
	        useFactory: function (xhrBackend, requestOptions) {
	            return new http_1.Http(xhrBackend, requestOptions);
	        },
	        deps: [xhr_backend_1.XHRBackend, base_request_options_1.RequestOptions]
	    }),
	    browser_xhr_1.BrowserXhr,
	    core_1.provide(base_request_options_1.RequestOptions, { useClass: base_request_options_1.BaseRequestOptions }),
	    core_1.provide(base_response_options_1.ResponseOptions, { useClass: base_response_options_1.BaseResponseOptions }),
	    xhr_backend_1.XHRBackend
	];
	/**
	 * See {@link HTTP_PROVIDERS} instead.
	 *
	 * @deprecated
	 */
	exports.HTTP_BINDINGS = exports.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="let 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);
	 *   }
	 * });
	 * ```
	 */
	exports.JSONP_PROVIDERS = [
	    // TODO(pascal): use factory type annotations once supported in DI
	    // issue: https://github.com/angular/angular/issues/3183
	    core_1.provide(http_1.Jsonp, {
	        useFactory: function (jsonpBackend, requestOptions) {
	            return new http_1.Jsonp(jsonpBackend, requestOptions);
	        },
	        deps: [jsonp_backend_1.JSONPBackend, base_request_options_1.RequestOptions]
	    }),
	    browser_jsonp_1.BrowserJsonp,
	    core_1.provide(base_request_options_1.RequestOptions, { useClass: base_request_options_1.BaseRequestOptions }),
	    core_1.provide(base_response_options_1.ResponseOptions, { useClass: base_response_options_1.BaseResponseOptions }),
	    core_1.provide(jsonp_backend_1.JSONPBackend, { useClass: jsonp_backend_1.JSONPBackend_ })
	];
	/**
	 * See {@link JSONP_PROVIDERS} instead.
	 *
	 * @deprecated
	 */
	exports.JSON_BINDINGS = exports.JSONP_PROVIDERS;


/***/ },
/* 235 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var core_1 = __webpack_require__(2);
	var interfaces_1 = __webpack_require__(236);
	var static_request_1 = __webpack_require__(237);
	var base_request_options_1 = __webpack_require__(241);
	var enums_1 = __webpack_require__(240);
	function httpRequest(backend, request) {
	    return backend.createConnection(request).response;
	}
	function mergeOptions(defaultOpts, providedOpts, method, url) {
	    var newOptions = defaultOpts;
	    if (lang_1.isPresent(providedOpts)) {
	        // Hack so Dart can used named parameters
	        return newOptions.merge(new base_request_options_1.RequestOptions({
	            method: providedOpts.method || method,
	            url: providedOpts.url || url,
	            search: providedOpts.search,
	            headers: providedOpts.headers,
	            body: providedOpts.body
	        }));
	    }
	    if (lang_1.isPresent(method)) {
	        return newOptions.merge(new base_request_options_1.RequestOptions({ method: method, url: url }));
	    }
	    else {
	        return newOptions.merge(new base_request_options_1.RequestOptions({ url: url }));
	    }
	}
	/**
	 * Performs http requests using `XMLHttpRequest` as the default backend.
	 *
	 * `Http` is available as an injectable class, with methods to perform http requests. Calling
	 * `request` returns an `Observable` which will emit a single {@link Response} when a
	 * response is received.
	 *
	 * ### Example
	 *
	 * ```typescript
	 * import {Http, HTTP_PROVIDERS} from 'angular2/http';
	 * @Component({
	 *   selector: 'http-app',
	 *   viewProviders: [HTTP_PROVIDERS],
	 *   templateUrl: 'people.html'
	 * })
	 * class PeopleComponent {
	 *   constructor(http: Http) {
	 *     http.get('people.json')
	 *       // Call map on the response observable to get the parsed people object
	 *       .map(res => res.json())
	 *       // Subscribe to the observable to get the parsed people object and attach it to the
	 *       // component
	 *       .subscribe(people => this.people = people);
	 *   }
	 * }
	 * ```
	 *
	 *
	 * ### Example
	 *
	 * ```
	 * http.get('people.json').observer({next: (value) => this.people = value});
	 * ```
	 *
	 * The default construct used to perform requests, `XMLHttpRequest`, is abstracted as a "Backend" (
	 * {@link XHRBackend} in this case), which could be mocked with dependency injection by replacing
	 * the {@link XHRBackend} provider, as in the following example:
	 *
	 * ### Example
	 *
	 * ```typescript
	 * import {BaseRequestOptions, Http} from 'angular2/http';
	 * import {MockBackend} from 'angular2/http/testing';
	 * var injector = Injector.resolveAndCreate([
	 *   BaseRequestOptions,
	 *   MockBackend,
	 *   provide(Http, {useFactory:
	 *       function(backend, defaultOptions) {
	 *         return new Http(backend, defaultOptions);
	 *       },
	 *       deps: [MockBackend, BaseRequestOptions]})
	 * ]);
	 * var http = injector.get(Http);
	 * http.get('request-from-mock-backend.json').subscribe((res:Response) => doSomething(res));
	 * ```
	 *
	 **/
	var Http = (function () {
	    function Http(_backend, _defaultOptions) {
	        this._backend = _backend;
	        this._defaultOptions = _defaultOptions;
	    }
	    /**
	     * Performs any type of http request. First argument is required, and can either be a url or
	     * a {@link Request} instance. If the first argument is a url, an optional {@link RequestOptions}
	     * object can be provided as the 2nd argument. The options object will be merged with the values
	     * of {@link BaseRequestOptions} before performing the request.
	     */
	    Http.prototype.request = function (url, options) {
	        var responseObservable;
	        if (lang_1.isString(url)) {
	            responseObservable = httpRequest(this._backend, new static_request_1.Request(mergeOptions(this._defaultOptions, options, enums_1.RequestMethod.Get, url)));
	        }
	        else if (url instanceof static_request_1.Request) {
	            responseObservable = httpRequest(this._backend, url);
	        }
	        else {
	            throw exceptions_1.makeTypeError('First argument must be a url string or Request instance.');
	        }
	        return responseObservable;
	    };
	    /**
	     * Performs a request with `get` http method.
	     */
	    Http.prototype.get = function (url, options) {
	        return httpRequest(this._backend, new static_request_1.Request(mergeOptions(this._defaultOptions, options, enums_1.RequestMethod.Get, url)));
	    };
	    /**
	     * Performs a request with `post` http method.
	     */
	    Http.prototype.post = function (url, body, options) {
	        return httpRequest(this._backend, new static_request_1.Request(mergeOptions(this._defaultOptions.merge(new base_request_options_1.RequestOptions({ body: body })), options, enums_1.RequestMethod.Post, url)));
	    };
	    /**
	     * Performs a request with `put` http method.
	     */
	    Http.prototype.put = function (url, body, options) {
	        return httpRequest(this._backend, new static_request_1.Request(mergeOptions(this._defaultOptions.merge(new base_request_options_1.RequestOptions({ body: body })), options, enums_1.RequestMethod.Put, url)));
	    };
	    /**
	     * Performs a request with `delete` http method.
	     */
	    Http.prototype.delete = function (url, options) {
	        return httpRequest(this._backend, new static_request_1.Request(mergeOptions(this._defaultOptions, options, enums_1.RequestMethod.Delete, url)));
	    };
	    /**
	     * Performs a request with `patch` http method.
	     */
	    Http.prototype.patch = function (url, body, options) {
	        return httpRequest(this._backend, new static_request_1.Request(mergeOptions(this._defaultOptions.merge(new base_request_options_1.RequestOptions({ body: body })), options, enums_1.RequestMethod.Patch, url)));
	    };
	    /**
	     * Performs a request with `head` http method.
	     */
	    Http.prototype.head = function (url, options) {
	        return httpRequest(this._backend, new static_request_1.Request(mergeOptions(this._defaultOptions, options, enums_1.RequestMethod.Head, url)));
	    };
	    Http = __decorate([
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [interfaces_1.ConnectionBackend, base_request_options_1.RequestOptions])
	    ], Http);
	    return Http;
	}());
	exports.Http = Http;
	var Jsonp = (function (_super) {
	    __extends(Jsonp, _super);
	    function Jsonp(backend, defaultOptions) {
	        _super.call(this, backend, defaultOptions);
	    }
	    /**
	     * Performs any type of http request. First argument is required, and can either be a url or
	     * a {@link Request} instance. If the first argument is a url, an optional {@link RequestOptions}
	     * object can be provided as the 2nd argument. The options object will be merged with the values
	     * of {@link BaseRequestOptions} before performing the request.
	     */
	    Jsonp.prototype.request = function (url, options) {
	        var responseObservable;
	        if (lang_1.isString(url)) {
	            url =
	                new static_request_1.Request(mergeOptions(this._defaultOptions, options, enums_1.RequestMethod.Get, url));
	        }
	        if (url instanceof static_request_1.Request) {
	            if (url.method !== enums_1.RequestMethod.Get) {
	                exceptions_1.makeTypeError('JSONP requests must use GET request method.');
	            }
	            responseObservable = httpRequest(this._backend, url);
	        }
	        else {
	            throw exceptions_1.makeTypeError('First argument must be a url string or Request instance.');
	        }
	        return responseObservable;
	    };
	    Jsonp = __decorate([
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [interfaces_1.ConnectionBackend, base_request_options_1.RequestOptions])
	    ], Jsonp);
	    return Jsonp;
	}(Http));
	exports.Jsonp = Jsonp;


/***/ },
/* 236 */
/***/ function(module, exports) {

	"use strict";
	/**
	 * Abstract class from which real backends are derived.
	 *
	 * The primary purpose of a `ConnectionBackend` is to create new connections to fulfill a given
	 * {@link Request}.
	 */
	var ConnectionBackend = (function () {
	    function ConnectionBackend() {
	    }
	    return ConnectionBackend;
	}());
	exports.ConnectionBackend = ConnectionBackend;
	/**
	 * Abstract class from which real connections are derived.
	 */
	var Connection = (function () {
	    function Connection() {
	    }
	    return Connection;
	}());
	exports.Connection = Connection;


/***/ },
/* 237 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var headers_1 = __webpack_require__(238);
	var http_utils_1 = __webpack_require__(239);
	var lang_1 = __webpack_require__(5);
	// TODO(jeffbcross): properly implement body accessors
	/**
	 * Creates `Request` instances from provided values.
	 *
	 * The Request's interface is inspired by the Request constructor defined in the [Fetch
	 * Spec](https://fetch.spec.whatwg.org/#request-class),
	 * but is considered a static value whose body can be accessed many times. There are other
	 * differences in the implementation, but this is the most significant.
	 *
	 * `Request` instances are typically created by higher-level classes, like {@link Http} and
	 * {@link Jsonp}, but it may occasionally be useful to explicitly create `Request` instances.
	 * One such example is when creating services that wrap higher-level services, like {@link Http},
	 * where it may be useful to generate a `Request` with arbitrary headers and search params.
	 *
	 * ```typescript
	 * import {Injectable, Injector} from 'angular2/core';
	 * import {HTTP_PROVIDERS, Http, Request, RequestMethod} from 'angular2/http';
	 *
	 * @Injectable()
	 * class AutoAuthenticator {
	 *   constructor(public http:Http) {}
	 *   request(url:string) {
	 *     return this.http.request(new Request({
	 *       method: RequestMethod.Get,
	 *       url: url,
	 *       search: 'password=123'
	 *     }));
	 *   }
	 * }
	 *
	 * var injector = Injector.resolveAndCreate([HTTP_PROVIDERS, AutoAuthenticator]);
	 * var authenticator = injector.get(AutoAuthenticator);
	 * authenticator.request('people.json').subscribe(res => {
	 *   //URL should have included '?password=123'
	 *   console.log('people', res.json());
	 * });
	 * ```
	 */
	var Request = (function () {
	    function Request(requestOptions) {
	        // TODO: assert that url is present
	        var url = requestOptions.url;
	        this.url = requestOptions.url;
	        if (lang_1.isPresent(requestOptions.search)) {
	            var search = requestOptions.search.toString();
	            if (search.length > 0) {
	                var prefix = '?';
	                if (lang_1.StringWrapper.contains(this.url, '?')) {
	                    prefix = (this.url[this.url.length - 1] == '&') ? '' : '&';
	                }
	                // TODO: just delete search-query-looking string in url?
	                this.url = url + prefix + search;
	            }
	        }
	        this._body = requestOptions.body;
	        this.method = http_utils_1.normalizeMethodName(requestOptions.method);
	        // TODO(jeffbcross): implement behavior
	        // Defaults to 'omit', consistent with browser
	        // TODO(jeffbcross): implement behavior
	        this.headers = new headers_1.Headers(requestOptions.headers);
	    }
	    /**
	     * Returns the request's body as string, assuming that body exists. If body is undefined, return
	     * empty
	     * string.
	     */
	    Request.prototype.text = function () { return lang_1.isPresent(this._body) ? this._body.toString() : ''; };
	    return Request;
	}());
	exports.Request = Request;


/***/ },
/* 238 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var collection_1 = __webpack_require__(15);
	/**
	 * Polyfill for [Headers](https://developer.mozilla.org/en-US/docs/Web/API/Headers/Headers), as
	 * specified in the [Fetch Spec](https://fetch.spec.whatwg.org/#headers-class).
	 *
	 * The only known difference between this `Headers` implementation and the spec is the
	 * lack of an `entries` method.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/MTdwT6?p=preview))
	 *
	 * ```
	 * import {Headers} from 'angular2/http';
	 *
	 * var firstHeaders = new Headers();
	 * firstHeaders.append('Content-Type', 'image/jpeg');
	 * console.log(firstHeaders.get('Content-Type')) //'image/jpeg'
	 *
	 * // Create headers from Plain Old JavaScript Object
	 * var secondHeaders = new Headers({
	 *   'X-My-Custom-Header': 'Angular'
	 * });
	 * console.log(secondHeaders.get('X-My-Custom-Header')); //'Angular'
	 *
	 * var thirdHeaders = new Headers(secondHeaders);
	 * console.log(thirdHeaders.get('X-My-Custom-Header')); //'Angular'
	 * ```
	 */
	var Headers = (function () {
	    function Headers(headers) {
	        var _this = this;
	        if (headers instanceof Headers) {
	            this._headersMap = headers._headersMap;
	            return;
	        }
	        this._headersMap = new collection_1.Map();
	        if (lang_1.isBlank(headers)) {
	            return;
	        }
	        // headers instanceof StringMap
	        collection_1.StringMapWrapper.forEach(headers, function (v, k) {
	            _this._headersMap.set(k, collection_1.isListLikeIterable(v) ? v : [v]);
	        });
	    }
	    /**
	     * Returns a new Headers instance from the given DOMString of Response Headers
	     */
	    Headers.fromResponseHeaderString = function (headersString) {
	        return headersString.trim()
	            .split('\n')
	            .map(function (val) { return val.split(':'); })
	            .map(function (_a) {
	            var key = _a[0], parts = _a.slice(1);
	            return ([key.trim(), parts.join(':').trim()]);
	        })
	            .reduce(function (headers, _a) {
	            var key = _a[0], value = _a[1];
	            return !headers.set(key, value) && headers;
	        }, new Headers());
	    };
	    /**
	     * Appends a header to existing list of header values for a given header name.
	     */
	    Headers.prototype.append = function (name, value) {
	        var mapName = this._headersMap.get(name);
	        var list = collection_1.isListLikeIterable(mapName) ? mapName : [];
	        list.push(value);
	        this._headersMap.set(name, list);
	    };
	    /**
	     * Deletes all header values for the given name.
	     */
	    Headers.prototype.delete = function (name) { this._headersMap.delete(name); };
	    Headers.prototype.forEach = function (fn) {
	        this._headersMap.forEach(fn);
	    };
	    /**
	     * Returns first header that matches given name.
	     */
	    Headers.prototype.get = function (header) { return collection_1.ListWrapper.first(this._headersMap.get(header)); };
	    /**
	     * Check for existence of header by given name.
	     */
	    Headers.prototype.has = function (header) { return this._headersMap.has(header); };
	    /**
	     * Provides names of set headers
	     */
	    Headers.prototype.keys = function () { return collection_1.MapWrapper.keys(this._headersMap); };
	    /**
	     * Sets or overrides header value for given name.
	     */
	    Headers.prototype.set = function (header, value) {
	        var list = [];
	        if (collection_1.isListLikeIterable(value)) {
	            var pushValue = value.join(',');
	            list.push(pushValue);
	        }
	        else {
	            list.push(value);
	        }
	        this._headersMap.set(header, list);
	    };
	    /**
	     * Returns values of all headers.
	     */
	    Headers.prototype.values = function () { return collection_1.MapWrapper.values(this._headersMap); };
	    /**
	     * Returns string of all headers.
	     */
	    Headers.prototype.toJSON = function () {
	        var serializableHeaders = {};
	        this._headersMap.forEach(function (values, name) {
	            var list = [];
	            collection_1.iterateListLike(values, function (val) { return list = collection_1.ListWrapper.concat(list, val.split(',')); });
	            serializableHeaders[name] = list;
	        });
	        return serializableHeaders;
	    };
	    /**
	     * Returns list of header values for a given name.
	     */
	    Headers.prototype.getAll = function (header) {
	        var headers = this._headersMap.get(header);
	        return collection_1.isListLikeIterable(headers) ? headers : [];
	    };
	    /**
	     * This method is not implemented.
	     */
	    Headers.prototype.entries = function () { throw new exceptions_1.BaseException('"entries" method is not implemented on Headers class'); };
	    return Headers;
	}());
	exports.Headers = Headers;


/***/ },
/* 239 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var enums_1 = __webpack_require__(240);
	var exceptions_1 = __webpack_require__(12);
	function normalizeMethodName(method) {
	    if (lang_1.isString(method)) {
	        var originalMethod = method;
	        method = method
	            .replace(/(\w)(\w*)/g, function (g0, g1, g2) {
	            return g1.toUpperCase() + g2.toLowerCase();
	        });
	        method = enums_1.RequestMethod[method];
	        if (typeof method !== 'number')
	            throw exceptions_1.makeTypeError("Invalid request method. The method \"" + originalMethod + "\" is not supported.");
	    }
	    return method;
	}
	exports.normalizeMethodName = normalizeMethodName;
	exports.isSuccess = function (status) { return (status >= 200 && status < 300); };
	function getResponseURL(xhr) {
	    if ('responseURL' in xhr) {
	        return xhr.responseURL;
	    }
	    if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {
	        return xhr.getResponseHeader('X-Request-URL');
	    }
	    return;
	}
	exports.getResponseURL = getResponseURL;
	var lang_2 = __webpack_require__(5);
	exports.isJsObject = lang_2.isJsObject;


/***/ },
/* 240 */
/***/ function(module, exports) {

	"use strict";
	/**
	 * Supported http methods.
	 */
	(function (RequestMethod) {
	    RequestMethod[RequestMethod["Get"] = 0] = "Get";
	    RequestMethod[RequestMethod["Post"] = 1] = "Post";
	    RequestMethod[RequestMethod["Put"] = 2] = "Put";
	    RequestMethod[RequestMethod["Delete"] = 3] = "Delete";
	    RequestMethod[RequestMethod["Options"] = 4] = "Options";
	    RequestMethod[RequestMethod["Head"] = 5] = "Head";
	    RequestMethod[RequestMethod["Patch"] = 6] = "Patch";
	})(exports.RequestMethod || (exports.RequestMethod = {}));
	var RequestMethod = exports.RequestMethod;
	/**
	 * All possible states in which a connection can be, based on
	 * [States](http://www.w3.org/TR/XMLHttpRequest/#states) from the `XMLHttpRequest` spec, but with an
	 * additional "CANCELLED" state.
	 */
	(function (ReadyState) {
	    ReadyState[ReadyState["Unsent"] = 0] = "Unsent";
	    ReadyState[ReadyState["Open"] = 1] = "Open";
	    ReadyState[ReadyState["HeadersReceived"] = 2] = "HeadersReceived";
	    ReadyState[ReadyState["Loading"] = 3] = "Loading";
	    ReadyState[ReadyState["Done"] = 4] = "Done";
	    ReadyState[ReadyState["Cancelled"] = 5] = "Cancelled";
	})(exports.ReadyState || (exports.ReadyState = {}));
	var ReadyState = exports.ReadyState;
	/**
	 * Acceptable response types to be associated with a {@link Response}, based on
	 * [ResponseType](https://fetch.spec.whatwg.org/#responsetype) from the Fetch spec.
	 */
	(function (ResponseType) {
	    ResponseType[ResponseType["Basic"] = 0] = "Basic";
	    ResponseType[ResponseType["Cors"] = 1] = "Cors";
	    ResponseType[ResponseType["Default"] = 2] = "Default";
	    ResponseType[ResponseType["Error"] = 3] = "Error";
	    ResponseType[ResponseType["Opaque"] = 4] = "Opaque";
	})(exports.ResponseType || (exports.ResponseType = {}));
	var ResponseType = exports.ResponseType;


/***/ },
/* 241 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var lang_1 = __webpack_require__(5);
	var headers_1 = __webpack_require__(238);
	var enums_1 = __webpack_require__(240);
	var core_1 = __webpack_require__(2);
	var url_search_params_1 = __webpack_require__(242);
	var http_utils_1 = __webpack_require__(239);
	/**
	 * Creates a request options object to be optionally provided when instantiating a
	 * {@link Request}.
	 *
	 * This class is based on the `RequestInit` description in the [Fetch
	 * Spec](https://fetch.spec.whatwg.org/#requestinit).
	 *
	 * All values are null by default. Typical defaults can be found in the {@link BaseRequestOptions}
	 * class, which sub-classes `RequestOptions`.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/7Wvi3lfLq41aQPKlxB4O?p=preview))
	 *
	 * ```typescript
	 * import {RequestOptions, Request, RequestMethod} from 'angular2/http';
	 *
	 * var options = new RequestOptions({
	 *   method: RequestMethod.Post,
	 *   url: 'https://google.com'
	 * });
	 * var req = new Request(options);
	 * console.log('req.method:', RequestMethod[req.method]); // Post
	 * console.log('options.url:', options.url); // https://google.com
	 * ```
	 */
	var RequestOptions = (function () {
	    function RequestOptions(_a) {
	        var _b = _a === void 0 ? {} : _a, method = _b.method, headers = _b.headers, body = _b.body, url = _b.url, search = _b.search;
	        this.method = lang_1.isPresent(method) ? http_utils_1.normalizeMethodName(method) : null;
	        this.headers = lang_1.isPresent(headers) ? headers : null;
	        this.body = lang_1.isPresent(body) ? body : null;
	        this.url = lang_1.isPresent(url) ? url : null;
	        this.search = lang_1.isPresent(search) ? (lang_1.isString(search) ? new url_search_params_1.URLSearchParams((search)) :
	            (search)) :
	            null;
	    }
	    /**
	     * Creates a copy of the `RequestOptions` instance, using the optional input as values to override
	     * existing values. This method will not change the values of the instance on which it is being
	     * called.
	     *
	     * Note that `headers` and `search` will override existing values completely if present in
	     * the `options` object. If these values should be merged, it should be done prior to calling
	     * `merge` on the `RequestOptions` instance.
	     *
	     * ### Example ([live demo](http://plnkr.co/edit/6w8XA8YTkDRcPYpdB9dk?p=preview))
	     *
	     * ```typescript
	     * import {RequestOptions, Request, RequestMethod} from 'angular2/http';
	     *
	     * var options = new RequestOptions({
	     *   method: RequestMethod.Post
	     * });
	     * var req = new Request(options.merge({
	     *   url: 'https://google.com'
	     * }));
	     * console.log('req.method:', RequestMethod[req.method]); // Post
	     * console.log('options.url:', options.url); // null
	     * console.log('req.url:', req.url); // https://google.com
	     * ```
	     */
	    RequestOptions.prototype.merge = function (options) {
	        return new RequestOptions({
	            method: lang_1.isPresent(options) && lang_1.isPresent(options.method) ? options.method : this.method,
	            headers: lang_1.isPresent(options) && lang_1.isPresent(options.headers) ? options.headers : this.headers,
	            body: lang_1.isPresent(options) && lang_1.isPresent(options.body) ? options.body : this.body,
	            url: lang_1.isPresent(options) && lang_1.isPresent(options.url) ? options.url : this.url,
	            search: lang_1.isPresent(options) && lang_1.isPresent(options.search) ?
	                (lang_1.isString(options.search) ? new url_search_params_1.URLSearchParams((options.search)) :
	                    (options.search).clone()) :
	                this.search
	        });
	    };
	    return RequestOptions;
	}());
	exports.RequestOptions = RequestOptions;
	/**
	 * Subclass of {@link RequestOptions}, with default values.
	 *
	 * Default values:
	 *  * method: {@link RequestMethod RequestMethod.Get}
	 *  * headers: empty {@link Headers} object
	 *
	 * This class could be extended and bound to the {@link RequestOptions} class
	 * when configuring an {@link Injector}, in order to override the default options
	 * used by {@link Http} to create and send {@link Request Requests}.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/LEKVSx?p=preview))
	 *
	 * ```typescript
	 * import {provide} from 'angular2/core';
	 * import {bootstrap} from 'angular2/platform/browser';
	 * import {HTTP_PROVIDERS, Http, BaseRequestOptions, RequestOptions} from 'angular2/http';
	 * import {App} from './myapp';
	 *
	 * class MyOptions extends BaseRequestOptions {
	 *   search: string = 'coreTeam=true';
	 * }
	 *
	 * bootstrap(App, [HTTP_PROVIDERS, provide(RequestOptions, {useClass: MyOptions})]);
	 * ```
	 *
	 * The options could also be extended when manually creating a {@link Request}
	 * object.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/oyBoEvNtDhOSfi9YxaVb?p=preview))
	 *
	 * ```
	 * import {BaseRequestOptions, Request, RequestMethod} from 'angular2/http';
	 *
	 * var options = new BaseRequestOptions();
	 * var req = new Request(options.merge({
	 *   method: RequestMethod.Post,
	 *   url: 'https://google.com'
	 * }));
	 * console.log('req.method:', RequestMethod[req.method]); // Post
	 * console.log('options.url:', options.url); // null
	 * console.log('req.url:', req.url); // https://google.com
	 * ```
	 */
	var BaseRequestOptions = (function (_super) {
	    __extends(BaseRequestOptions, _super);
	    function BaseRequestOptions() {
	        _super.call(this, { method: enums_1.RequestMethod.Get, headers: new headers_1.Headers() });
	    }
	    BaseRequestOptions = __decorate([
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], BaseRequestOptions);
	    return BaseRequestOptions;
	}(RequestOptions));
	exports.BaseRequestOptions = BaseRequestOptions;


/***/ },
/* 242 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	function paramParser(rawParams) {
	    if (rawParams === void 0) { rawParams = ''; }
	    var map = new collection_1.Map();
	    if (rawParams.length > 0) {
	        var params = rawParams.split('&');
	        params.forEach(function (param) {
	            var split = param.split('=');
	            var key = split[0];
	            var val = split[1];
	            var list = lang_1.isPresent(map.get(key)) ? map.get(key) : [];
	            list.push(val);
	            map.set(key, list);
	        });
	    }
	    return map;
	}
	/**
	 * Map-like representation of url search parameters, based on
	 * [URLSearchParams](https://url.spec.whatwg.org/#urlsearchparams) in the url living standard,
	 * with several extensions for merging URLSearchParams objects:
	 *   - setAll()
	 *   - appendAll()
	 *   - replaceAll()
	 */
	var URLSearchParams = (function () {
	    function URLSearchParams(rawParams) {
	        if (rawParams === void 0) { rawParams = ''; }
	        this.rawParams = rawParams;
	        this.paramsMap = paramParser(rawParams);
	    }
	    URLSearchParams.prototype.clone = function () {
	        var clone = new URLSearchParams();
	        clone.appendAll(this);
	        return clone;
	    };
	    URLSearchParams.prototype.has = function (param) { return this.paramsMap.has(param); };
	    URLSearchParams.prototype.get = function (param) {
	        var storedParam = this.paramsMap.get(param);
	        if (collection_1.isListLikeIterable(storedParam)) {
	            return collection_1.ListWrapper.first(storedParam);
	        }
	        else {
	            return null;
	        }
	    };
	    URLSearchParams.prototype.getAll = function (param) {
	        var mapParam = this.paramsMap.get(param);
	        return lang_1.isPresent(mapParam) ? mapParam : [];
	    };
	    URLSearchParams.prototype.set = function (param, val) {
	        var mapParam = this.paramsMap.get(param);
	        var list = lang_1.isPresent(mapParam) ? mapParam : [];
	        collection_1.ListWrapper.clear(list);
	        list.push(val);
	        this.paramsMap.set(param, list);
	    };
	    // A merge operation
	    // For each name-values pair in `searchParams`, perform `set(name, values[0])`
	    //
	    // E.g: "a=[1,2,3], c=[8]" + "a=[4,5,6], b=[7]" = "a=[4], c=[8], b=[7]"
	    //
	    // TODO(@caitp): document this better
	    URLSearchParams.prototype.setAll = function (searchParams) {
	        var _this = this;
	        searchParams.paramsMap.forEach(function (value, param) {
	            var mapParam = _this.paramsMap.get(param);
	            var list = lang_1.isPresent(mapParam) ? mapParam : [];
	            collection_1.ListWrapper.clear(list);
	            list.push(value[0]);
	            _this.paramsMap.set(param, list);
	        });
	    };
	    URLSearchParams.prototype.append = function (param, val) {
	        var mapParam = this.paramsMap.get(param);
	        var list = lang_1.isPresent(mapParam) ? mapParam : [];
	        list.push(val);
	        this.paramsMap.set(param, list);
	    };
	    // A merge operation
	    // For each name-values pair in `searchParams`, perform `append(name, value)`
	    // for each value in `values`.
	    //
	    // E.g: "a=[1,2], c=[8]" + "a=[3,4], b=[7]" = "a=[1,2,3,4], c=[8], b=[7]"
	    //
	    // TODO(@caitp): document this better
	    URLSearchParams.prototype.appendAll = function (searchParams) {
	        var _this = this;
	        searchParams.paramsMap.forEach(function (value, param) {
	            var mapParam = _this.paramsMap.get(param);
	            var list = lang_1.isPresent(mapParam) ? mapParam : [];
	            for (var i = 0; i < value.length; ++i) {
	                list.push(value[i]);
	            }
	            _this.paramsMap.set(param, list);
	        });
	    };
	    // A merge operation
	    // For each name-values pair in `searchParams`, perform `delete(name)`,
	    // followed by `set(name, values)`
	    //
	    // E.g: "a=[1,2,3], c=[8]" + "a=[4,5,6], b=[7]" = "a=[4,5,6], c=[8], b=[7]"
	    //
	    // TODO(@caitp): document this better
	    URLSearchParams.prototype.replaceAll = function (searchParams) {
	        var _this = this;
	        searchParams.paramsMap.forEach(function (value, param) {
	            var mapParam = _this.paramsMap.get(param);
	            var list = lang_1.isPresent(mapParam) ? mapParam : [];
	            collection_1.ListWrapper.clear(list);
	            for (var i = 0; i < value.length; ++i) {
	                list.push(value[i]);
	            }
	            _this.paramsMap.set(param, list);
	        });
	    };
	    URLSearchParams.prototype.toString = function () {
	        var paramsList = [];
	        this.paramsMap.forEach(function (values, k) { values.forEach(function (v) { return paramsList.push(k + '=' + v); }); });
	        return paramsList.join('&');
	    };
	    URLSearchParams.prototype.delete = function (param) { this.paramsMap.delete(param); };
	    return URLSearchParams;
	}());
	exports.URLSearchParams = URLSearchParams;


/***/ },
/* 243 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var enums_1 = __webpack_require__(240);
	var static_response_1 = __webpack_require__(244);
	var headers_1 = __webpack_require__(238);
	var base_response_options_1 = __webpack_require__(245);
	var core_1 = __webpack_require__(2);
	var browser_xhr_1 = __webpack_require__(246);
	var lang_1 = __webpack_require__(5);
	var Observable_1 = __webpack_require__(43);
	var http_utils_1 = __webpack_require__(239);
	/**
	* Creates connections using `XMLHttpRequest`. Given a fully-qualified
	* request, an `XHRConnection` will immediately create an `XMLHttpRequest` object and send the
	* request.
	*
	* This class would typically not be created or interacted with directly inside applications, though
	* the {@link MockConnection} may be interacted with in tests.
	*/
	var XHRConnection = (function () {
	    function XHRConnection(req, browserXHR, baseResponseOptions) {
	        var _this = this;
	        this.request = req;
	        this.response = new Observable_1.Observable(function (responseObserver) {
	            var _xhr = browserXHR.build();
	            _xhr.open(enums_1.RequestMethod[req.method].toUpperCase(), req.url);
	            // load event handler
	            var onLoad = function () {
	                // responseText is the old-school way of retrieving response (supported by IE8 & 9)
	                // response/responseType properties were introduced in XHR Level2 spec (supported by
	                // IE10)
	                var body = lang_1.isPresent(_xhr.response) ? _xhr.response : _xhr.responseText;
	                var headers = headers_1.Headers.fromResponseHeaderString(_xhr.getAllResponseHeaders());
	                var url = http_utils_1.getResponseURL(_xhr);
	                // normalize IE9 bug (http://bugs.jquery.com/ticket/1450)
	                var status = _xhr.status === 1223 ? 204 : _xhr.status;
	                // fix status code when it is 0 (0 status is undocumented).
	                // Occurs when accessing file resources or on Android 4.1 stock browser
	                // while retrieving files from application cache.
	                if (status === 0) {
	                    status = body ? 200 : 0;
	                }
	                var responseOptions = new base_response_options_1.ResponseOptions({ body: body, status: status, headers: headers, url: url });
	                if (lang_1.isPresent(baseResponseOptions)) {
	                    responseOptions = baseResponseOptions.merge(responseOptions);
	                }
	                var response = new static_response_1.Response(responseOptions);
	                if (http_utils_1.isSuccess(status)) {
	                    responseObserver.next(response);
	                    // TODO(gdi2290): defer complete if array buffer until done
	                    responseObserver.complete();
	                    return;
	                }
	                responseObserver.error(response);
	            };
	            // error event handler
	            var onError = function (err) {
	                var responseOptions = new base_response_options_1.ResponseOptions({ body: err, type: enums_1.ResponseType.Error });
	                if (lang_1.isPresent(baseResponseOptions)) {
	                    responseOptions = baseResponseOptions.merge(responseOptions);
	                }
	                responseObserver.error(new static_response_1.Response(responseOptions));
	            };
	            if (lang_1.isPresent(req.headers)) {
	                req.headers.forEach(function (values, name) { return _xhr.setRequestHeader(name, values.join(',')); });
	            }
	            _xhr.addEventListener('load', onLoad);
	            _xhr.addEventListener('error', onError);
	            _xhr.send(_this.request.text());
	            return function () {
	                _xhr.removeEventListener('load', onLoad);
	                _xhr.removeEventListener('error', onError);
	                _xhr.abort();
	            };
	        });
	    }
	    return XHRConnection;
	}());
	exports.XHRConnection = XHRConnection;
	/**
	 * Creates {@link XHRConnection} instances.
	 *
	 * This class would typically not be used by end users, but could be
	 * overridden if a different backend implementation should be used,
	 * such as in a node backend.
	 *
	 * ### Example
	 *
	 * ```
	 * import {Http, MyNodeBackend, HTTP_PROVIDERS, BaseRequestOptions} from 'angular2/http';
	 * @Component({
	 *   viewProviders: [
	 *     HTTP_PROVIDERS,
	 *     provide(Http, {useFactory: (backend, options) => {
	 *       return new Http(backend, options);
	 *     }, deps: [MyNodeBackend, BaseRequestOptions]})]
	 * })
	 * class MyComponent {
	 *   constructor(http:Http) {
	 *     http.request('people.json').subscribe(res => this.people = res.json());
	 *   }
	 * }
	 * ```
	 *
	 **/
	var XHRBackend = (function () {
	    function XHRBackend(_browserXHR, _baseResponseOptions) {
	        this._browserXHR = _browserXHR;
	        this._baseResponseOptions = _baseResponseOptions;
	    }
	    XHRBackend.prototype.createConnection = function (request) {
	        return new XHRConnection(request, this._browserXHR, this._baseResponseOptions);
	    };
	    XHRBackend = __decorate([
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [browser_xhr_1.BrowserXhr, base_response_options_1.ResponseOptions])
	    ], XHRBackend);
	    return XHRBackend;
	}());
	exports.XHRBackend = XHRBackend;


/***/ },
/* 244 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var http_utils_1 = __webpack_require__(239);
	/**
	 * Creates `Response` instances from provided values.
	 *
	 * Though this object isn't
	 * usually instantiated by end-users, it is the primary object interacted with when it comes time to
	 * add data to a view.
	 *
	 * ### Example
	 *
	 * ```
	 * http.request('my-friends.txt').subscribe(response => this.friends = response.text());
	 * ```
	 *
	 * The Response's interface is inspired by the Response constructor defined in the [Fetch
	 * Spec](https://fetch.spec.whatwg.org/#response-class), but is considered a static value whose body
	 * can be accessed many times. There are other differences in the implementation, but this is the
	 * most significant.
	 */
	var Response = (function () {
	    function Response(responseOptions) {
	        this._body = responseOptions.body;
	        this.status = responseOptions.status;
	        this.ok = (this.status >= 200 && this.status <= 299);
	        this.statusText = responseOptions.statusText;
	        this.headers = responseOptions.headers;
	        this.type = responseOptions.type;
	        this.url = responseOptions.url;
	    }
	    /**
	     * Not yet implemented
	     */
	    // TODO: Blob return type
	    Response.prototype.blob = function () { throw new exceptions_1.BaseException('"blob()" method not implemented on Response superclass'); };
	    /**
	     * Attempts to return body as parsed `JSON` object, or raises an exception.
	     */
	    Response.prototype.json = function () {
	        var jsonResponse;
	        if (http_utils_1.isJsObject(this._body)) {
	            jsonResponse = this._body;
	        }
	        else if (lang_1.isString(this._body)) {
	            jsonResponse = lang_1.Json.parse(this._body);
	        }
	        return jsonResponse;
	    };
	    /**
	     * Returns the body as a string, presuming `toString()` can be called on the response body.
	     */
	    Response.prototype.text = function () { return this._body.toString(); };
	    /**
	     * Not yet implemented
	     */
	    // TODO: ArrayBuffer return type
	    Response.prototype.arrayBuffer = function () {
	        throw new exceptions_1.BaseException('"arrayBuffer()" method not implemented on Response superclass');
	    };
	    return Response;
	}());
	exports.Response = Response;


/***/ },
/* 245 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var core_1 = __webpack_require__(2);
	var lang_1 = __webpack_require__(5);
	var headers_1 = __webpack_require__(238);
	var enums_1 = __webpack_require__(240);
	/**
	 * Creates a response options object to be optionally provided when instantiating a
	 * {@link Response}.
	 *
	 * This class is based on the `ResponseInit` description in the [Fetch
	 * Spec](https://fetch.spec.whatwg.org/#responseinit).
	 *
	 * All values are null by default. Typical defaults can be found in the
	 * {@link BaseResponseOptions} class, which sub-classes `ResponseOptions`.
	 *
	 * This class may be used in tests to build {@link Response Responses} for
	 * mock responses (see {@link MockBackend}).
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/P9Jkk8e8cz6NVzbcxEsD?p=preview))
	 *
	 * ```typescript
	 * import {ResponseOptions, Response} from 'angular2/http';
	 *
	 * var options = new ResponseOptions({
	 *   body: '{"name":"Jeff"}'
	 * });
	 * var res = new Response(options);
	 *
	 * console.log('res.json():', res.json()); // Object {name: "Jeff"}
	 * ```
	 */
	var ResponseOptions = (function () {
	    function ResponseOptions(_a) {
	        var _b = _a === void 0 ? {} : _a, body = _b.body, status = _b.status, headers = _b.headers, statusText = _b.statusText, type = _b.type, url = _b.url;
	        this.body = lang_1.isPresent(body) ? body : null;
	        this.status = lang_1.isPresent(status) ? status : null;
	        this.headers = lang_1.isPresent(headers) ? headers : null;
	        this.statusText = lang_1.isPresent(statusText) ? statusText : null;
	        this.type = lang_1.isPresent(type) ? type : null;
	        this.url = lang_1.isPresent(url) ? url : null;
	    }
	    /**
	     * Creates a copy of the `ResponseOptions` instance, using the optional input as values to
	     * override
	     * existing values. This method will not change the values of the instance on which it is being
	     * called.
	     *
	     * This may be useful when sharing a base `ResponseOptions` object inside tests,
	     * where certain properties may change from test to test.
	     *
	     * ### Example ([live demo](http://plnkr.co/edit/1lXquqFfgduTFBWjNoRE?p=preview))
	     *
	     * ```typescript
	     * import {ResponseOptions, Response} from 'angular2/http';
	     *
	     * var options = new ResponseOptions({
	     *   body: {name: 'Jeff'}
	     * });
	     * var res = new Response(options.merge({
	     *   url: 'https://google.com'
	     * }));
	     * console.log('options.url:', options.url); // null
	     * console.log('res.json():', res.json()); // Object {name: "Jeff"}
	     * console.log('res.url:', res.url); // https://google.com
	     * ```
	     */
	    ResponseOptions.prototype.merge = function (options) {
	        return new ResponseOptions({
	            body: lang_1.isPresent(options) && lang_1.isPresent(options.body) ? options.body : this.body,
	            status: lang_1.isPresent(options) && lang_1.isPresent(options.status) ? options.status : this.status,
	            headers: lang_1.isPresent(options) && lang_1.isPresent(options.headers) ? options.headers : this.headers,
	            statusText: lang_1.isPresent(options) && lang_1.isPresent(options.statusText) ? options.statusText :
	                this.statusText,
	            type: lang_1.isPresent(options) && lang_1.isPresent(options.type) ? options.type : this.type,
	            url: lang_1.isPresent(options) && lang_1.isPresent(options.url) ? options.url : this.url,
	        });
	    };
	    return ResponseOptions;
	}());
	exports.ResponseOptions = ResponseOptions;
	/**
	 * Subclass of {@link ResponseOptions}, with default values.
	 *
	 * Default values:
	 *  * status: 200
	 *  * headers: empty {@link Headers} object
	 *
	 * This class could be extended and bound to the {@link ResponseOptions} class
	 * when configuring an {@link Injector}, in order to override the default options
	 * used by {@link Http} to create {@link Response Responses}.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/qv8DLT?p=preview))
	 *
	 * ```typescript
	 * import {provide} from 'angular2/core';
	 * import {bootstrap} from 'angular2/platform/browser';
	 * import {HTTP_PROVIDERS, Headers, Http, BaseResponseOptions, ResponseOptions} from
	 * 'angular2/http';
	 * import {App} from './myapp';
	 *
	 * class MyOptions extends BaseResponseOptions {
	 *   headers:Headers = new Headers({network: 'github'});
	 * }
	 *
	 * bootstrap(App, [HTTP_PROVIDERS, provide(ResponseOptions, {useClass: MyOptions})]);
	 * ```
	 *
	 * The options could also be extended when manually creating a {@link Response}
	 * object.
	 *
	 * ### Example ([live demo](http://plnkr.co/edit/VngosOWiaExEtbstDoix?p=preview))
	 *
	 * ```
	 * import {BaseResponseOptions, Response} from 'angular2/http';
	 *
	 * var options = new BaseResponseOptions();
	 * var res = new Response(options.merge({
	 *   body: 'Angular2',
	 *   headers: new Headers({framework: 'angular'})
	 * }));
	 * console.log('res.headers.get("framework"):', res.headers.get('framework')); // angular
	 * console.log('res.text():', res.text()); // Angular2;
	 * ```
	 */
	var BaseResponseOptions = (function (_super) {
	    __extends(BaseResponseOptions, _super);
	    function BaseResponseOptions() {
	        _super.call(this, { status: 200, statusText: 'Ok', type: enums_1.ResponseType.Default, headers: new headers_1.Headers() });
	    }
	    BaseResponseOptions = __decorate([
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], BaseResponseOptions);
	    return BaseResponseOptions;
	}(ResponseOptions));
	exports.BaseResponseOptions = BaseResponseOptions;


/***/ },
/* 246 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var core_1 = __webpack_require__(2);
	/**
	 * A backend for http that uses the `XMLHttpRequest` browser API.
	 *
	 * Take care not to evaluate this in non-browser contexts.
	 */
	var BrowserXhr = (function () {
	    function BrowserXhr() {
	    }
	    BrowserXhr.prototype.build = function () { return (new XMLHttpRequest()); };
	    BrowserXhr = __decorate([
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], BrowserXhr);
	    return BrowserXhr;
	}());
	exports.BrowserXhr = BrowserXhr;


/***/ },
/* 247 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var interfaces_1 = __webpack_require__(236);
	var enums_1 = __webpack_require__(240);
	var static_response_1 = __webpack_require__(244);
	var base_response_options_1 = __webpack_require__(245);
	var core_1 = __webpack_require__(2);
	var browser_jsonp_1 = __webpack_require__(248);
	var exceptions_1 = __webpack_require__(12);
	var lang_1 = __webpack_require__(5);
	var Observable_1 = __webpack_require__(43);
	var JSONP_ERR_NO_CALLBACK = 'JSONP injected script did not invoke callback.';
	var JSONP_ERR_WRONG_METHOD = 'JSONP requests must use GET request method.';
	/**
	 * Abstract base class for an in-flight JSONP request.
	 */
	var JSONPConnection = (function () {
	    function JSONPConnection() {
	    }
	    return JSONPConnection;
	}());
	exports.JSONPConnection = JSONPConnection;
	var JSONPConnection_ = (function (_super) {
	    __extends(JSONPConnection_, _super);
	    function JSONPConnection_(req, _dom, baseResponseOptions) {
	        var _this = this;
	        _super.call(this);
	        this._dom = _dom;
	        this.baseResponseOptions = baseResponseOptions;
	        this._finished = false;
	        if (req.method !== enums_1.RequestMethod.Get) {
	            throw exceptions_1.makeTypeError(JSONP_ERR_WRONG_METHOD);
	        }
	        this.request = req;
	        this.response = new Observable_1.Observable(function (responseObserver) {
	            _this.readyState = enums_1.ReadyState.Loading;
	            var id = _this._id = _dom.nextRequestID();
	            _dom.exposeConnection(id, _this);
	            // Workaround Dart
	            // url = url.replace(/=JSONP_CALLBACK(&|$)/, `generated method`);
	            var callback = _dom.requestCallback(_this._id);
	            var url = req.url;
	            if (url.indexOf('=JSONP_CALLBACK&') > -1) {
	                url = lang_1.StringWrapper.replace(url, '=JSONP_CALLBACK&', "=" + callback + "&");
	            }
	            else if (url.lastIndexOf('=JSONP_CALLBACK') === url.length - '=JSONP_CALLBACK'.length) {
	                url = url.substring(0, url.length - '=JSONP_CALLBACK'.length) + ("=" + callback);
	            }
	            var script = _this._script = _dom.build(url);
	            var onLoad = function (event) {
	                if (_this.readyState === enums_1.ReadyState.Cancelled)
	                    return;
	                _this.readyState = enums_1.ReadyState.Done;
	                _dom.cleanup(script);
	                if (!_this._finished) {
	                    var responseOptions_1 = new base_response_options_1.ResponseOptions({ body: JSONP_ERR_NO_CALLBACK, type: enums_1.ResponseType.Error, url: url });
	                    if (lang_1.isPresent(baseResponseOptions)) {
	                        responseOptions_1 = baseResponseOptions.merge(responseOptions_1);
	                    }
	                    responseObserver.error(new static_response_1.Response(responseOptions_1));
	                    return;
	                }
	                var responseOptions = new base_response_options_1.ResponseOptions({ body: _this._responseData, url: url });
	                if (lang_1.isPresent(_this.baseResponseOptions)) {
	                    responseOptions = _this.baseResponseOptions.merge(responseOptions);
	                }
	                responseObserver.next(new static_response_1.Response(responseOptions));
	                responseObserver.complete();
	            };
	            var onError = function (error) {
	                if (_this.readyState === enums_1.ReadyState.Cancelled)
	                    return;
	                _this.readyState = enums_1.ReadyState.Done;
	                _dom.cleanup(script);
	                var responseOptions = new base_response_options_1.ResponseOptions({ body: error.message, type: enums_1.ResponseType.Error });
	                if (lang_1.isPresent(baseResponseOptions)) {
	                    responseOptions = baseResponseOptions.merge(responseOptions);
	                }
	                responseObserver.error(new static_response_1.Response(responseOptions));
	            };
	            script.addEventListener('load', onLoad);
	            script.addEventListener('error', onError);
	            _dom.send(script);
	            return function () {
	                _this.readyState = enums_1.ReadyState.Cancelled;
	                script.removeEventListener('load', onLoad);
	                script.removeEventListener('error', onError);
	                if (lang_1.isPresent(script)) {
	                    _this._dom.cleanup(script);
	                }
	            };
	        });
	    }
	    JSONPConnection_.prototype.finished = function (data) {
	        // Don't leak connections
	        this._finished = true;
	        this._dom.removeConnection(this._id);
	        if (this.readyState === enums_1.ReadyState.Cancelled)
	            return;
	        this._responseData = data;
	    };
	    return JSONPConnection_;
	}(JSONPConnection));
	exports.JSONPConnection_ = JSONPConnection_;
	/**
	 * A {@link ConnectionBackend} that uses the JSONP strategy of making requests.
	 */
	var JSONPBackend = (function (_super) {
	    __extends(JSONPBackend, _super);
	    function JSONPBackend() {
	        _super.apply(this, arguments);
	    }
	    return JSONPBackend;
	}(interfaces_1.ConnectionBackend));
	exports.JSONPBackend = JSONPBackend;
	var JSONPBackend_ = (function (_super) {
	    __extends(JSONPBackend_, _super);
	    function JSONPBackend_(_browserJSONP, _baseResponseOptions) {
	        _super.call(this);
	        this._browserJSONP = _browserJSONP;
	        this._baseResponseOptions = _baseResponseOptions;
	    }
	    JSONPBackend_.prototype.createConnection = function (request) {
	        return new JSONPConnection_(request, this._browserJSONP, this._baseResponseOptions);
	    };
	    JSONPBackend_ = __decorate([
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [browser_jsonp_1.BrowserJsonp, base_response_options_1.ResponseOptions])
	    ], JSONPBackend_);
	    return JSONPBackend_;
	}(JSONPBackend));
	exports.JSONPBackend_ = JSONPBackend_;


/***/ },
/* 248 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var core_1 = __webpack_require__(2);
	var lang_1 = __webpack_require__(5);
	var _nextRequestId = 0;
	exports.JSONP_HOME = '__ng_jsonp__';
	var _jsonpConnections = null;
	function _getJsonpConnections() {
	    if (_jsonpConnections === null) {
	        _jsonpConnections = lang_1.global[exports.JSONP_HOME] = {};
	    }
	    return _jsonpConnections;
	}
	// Make sure not to evaluate this in a non-browser environment!
	var BrowserJsonp = (function () {
	    function BrowserJsonp() {
	    }
	    // Construct a <script> element with the specified URL
	    BrowserJsonp.prototype.build = function (url) {
	        var node = document.createElement('script');
	        node.src = url;
	        return node;
	    };
	    BrowserJsonp.prototype.nextRequestID = function () { return "__req" + _nextRequestId++; };
	    BrowserJsonp.prototype.requestCallback = function (id) { return exports.JSONP_HOME + "." + id + ".finished"; };
	    BrowserJsonp.prototype.exposeConnection = function (id, connection) {
	        var connections = _getJsonpConnections();
	        connections[id] = connection;
	    };
	    BrowserJsonp.prototype.removeConnection = function (id) {
	        var connections = _getJsonpConnections();
	        connections[id] = null;
	    };
	    // Attach the <script> element to the DOM
	    BrowserJsonp.prototype.send = function (node) { document.body.appendChild((node)); };
	    // Remove <script> element from the DOM
	    BrowserJsonp.prototype.cleanup = function (node) {
	        if (node.parentNode) {
	            node.parentNode.removeChild((node));
	        }
	    };
	    BrowserJsonp = __decorate([
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], BrowserJsonp);
	    return BrowserJsonp;
	}());
	exports.BrowserJsonp = BrowserJsonp;


/***/ },
/* 249 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * @module
	 * @description
	 * Maps application URLs into application states, to support deep-linking and navigation.
	 */
	"use strict";
	function __export(m) {
	    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
	}
	var router_1 = __webpack_require__(250);
	exports.Router = router_1.Router;
	var router_outlet_1 = __webpack_require__(274);
	exports.RouterOutlet = router_outlet_1.RouterOutlet;
	var router_link_1 = __webpack_require__(276);
	exports.RouterLink = router_link_1.RouterLink;
	var instruction_1 = __webpack_require__(262);
	exports.RouteParams = instruction_1.RouteParams;
	exports.RouteData = instruction_1.RouteData;
	var route_registry_1 = __webpack_require__(258);
	exports.RouteRegistry = route_registry_1.RouteRegistry;
	exports.ROUTER_PRIMARY_COMPONENT = route_registry_1.ROUTER_PRIMARY_COMPONENT;
	__export(__webpack_require__(271));
	var lifecycle_annotations_1 = __webpack_require__(275);
	exports.CanActivate = lifecycle_annotations_1.CanActivate;
	var instruction_2 = __webpack_require__(262);
	exports.Instruction = instruction_2.Instruction;
	exports.ComponentInstruction = instruction_2.ComponentInstruction;
	var core_1 = __webpack_require__(2);
	exports.OpaqueToken = core_1.OpaqueToken;
	var router_providers_common_1 = __webpack_require__(277);
	exports.ROUTER_PROVIDERS_COMMON = router_providers_common_1.ROUTER_PROVIDERS_COMMON;
	var router_providers_1 = __webpack_require__(278);
	exports.ROUTER_PROVIDERS = router_providers_1.ROUTER_PROVIDERS;
	exports.ROUTER_BINDINGS = router_providers_1.ROUTER_BINDINGS;
	var router_outlet_2 = __webpack_require__(274);
	var router_link_2 = __webpack_require__(276);
	/**
	 * 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]);
	 * ```
	 */
	exports.ROUTER_DIRECTIVES = [router_outlet_2.RouterOutlet, router_link_2.RouterLink];


/***/ },
/* 250 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var async_1 = __webpack_require__(41);
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var common_1 = __webpack_require__(251);
	var core_1 = __webpack_require__(2);
	var route_registry_1 = __webpack_require__(258);
	var route_lifecycle_reflector_1 = __webpack_require__(272);
	var _resolveToTrue = async_1.PromiseWrapper.resolve(true);
	var _resolveToFalse = async_1.PromiseWrapper.resolve(false);
	/**
	 * The `Router` is responsible for mapping URLs to components.
	 *
	 * You can see the state of the router by inspecting the read-only field `router.navigating`.
	 * This may be useful for showing a spinner, for instance.
	 *
	 * ## Concepts
	 *
	 * Routers and component instances have a 1:1 correspondence.
	 *
	 * The router holds reference to a number of {@link RouterOutlet}.
	 * An outlet is a placeholder that the router dynamically fills in depending on the current URL.
	 *
	 * When the router navigates from a URL, it must first recognize it and serialize it into an
	 * `Instruction`.
	 * The router uses the `RouteRegistry` to get an `Instruction`.
	 */
	var Router = (function () {
	    function Router(registry, parent, hostComponent, root) {
	        this.registry = registry;
	        this.parent = parent;
	        this.hostComponent = hostComponent;
	        this.root = root;
	        this.navigating = false;
	        /**
	         * The current `Instruction` for the router
	         */
	        this.currentInstruction = null;
	        this._currentNavigation = _resolveToTrue;
	        this._outlet = null;
	        this._auxRouters = new collection_1.Map();
	        this._subject = new async_1.EventEmitter();
	    }
	    /**
	     * Constructs a child router. You probably don't need to use this unless you're writing a reusable
	     * component.
	     */
	    Router.prototype.childRouter = function (hostComponent) {
	        return this._childRouter = new ChildRouter(this, hostComponent);
	    };
	    /**
	     * Constructs a child router. You probably don't need to use this unless you're writing a reusable
	     * component.
	     */
	    Router.prototype.auxRouter = function (hostComponent) { return new ChildRouter(this, hostComponent); };
	    /**
	     * Register an outlet to be notified of primary route changes.
	     *
	     * You probably don't need to use this unless you're writing a reusable component.
	     */
	    Router.prototype.registerPrimaryOutlet = function (outlet) {
	        if (lang_1.isPresent(outlet.name)) {
	            throw new exceptions_1.BaseException("registerPrimaryOutlet expects to be called with an unnamed outlet.");
	        }
	        if (lang_1.isPresent(this._outlet)) {
	            throw new exceptions_1.BaseException("Primary outlet is already registered.");
	        }
	        this._outlet = outlet;
	        if (lang_1.isPresent(this.currentInstruction)) {
	            return this.commit(this.currentInstruction, false);
	        }
	        return _resolveToTrue;
	    };
	    /**
	     * Unregister an outlet (because it was destroyed, etc).
	     *
	     * You probably don't need to use this unless you're writing a custom outlet implementation.
	     */
	    Router.prototype.unregisterPrimaryOutlet = function (outlet) {
	        if (lang_1.isPresent(outlet.name)) {
	            throw new exceptions_1.BaseException("registerPrimaryOutlet expects to be called with an unnamed outlet.");
	        }
	        this._outlet = null;
	    };
	    /**
	     * Register an outlet to notified of auxiliary route changes.
	     *
	     * You probably don't need to use this unless you're writing a reusable component.
	     */
	    Router.prototype.registerAuxOutlet = function (outlet) {
	        var outletName = outlet.name;
	        if (lang_1.isBlank(outletName)) {
	            throw new exceptions_1.BaseException("registerAuxOutlet expects to be called with an outlet with a name.");
	        }
	        var router = this.auxRouter(this.hostComponent);
	        this._auxRouters.set(outletName, router);
	        router._outlet = outlet;
	        var auxInstruction;
	        if (lang_1.isPresent(this.currentInstruction) &&
	            lang_1.isPresent(auxInstruction = this.currentInstruction.auxInstruction[outletName])) {
	            return router.commit(auxInstruction);
	        }
	        return _resolveToTrue;
	    };
	    /**
	     * Given an instruction, returns `true` if the instruction is currently active,
	     * otherwise `false`.
	     */
	    Router.prototype.isRouteActive = function (instruction) {
	        var _this = this;
	        var router = this;
	        if (lang_1.isBlank(this.currentInstruction)) {
	            return false;
	        }
	        // `instruction` corresponds to the root router
	        while (lang_1.isPresent(router.parent) && lang_1.isPresent(instruction.child)) {
	            router = router.parent;
	            instruction = instruction.child;
	        }
	        if (lang_1.isBlank(instruction.component) || lang_1.isBlank(this.currentInstruction.component) ||
	            this.currentInstruction.component.routeName != instruction.component.routeName) {
	            return false;
	        }
	        var paramEquals = true;
	        if (lang_1.isPresent(this.currentInstruction.component.params)) {
	            collection_1.StringMapWrapper.forEach(instruction.component.params, function (value, key) {
	                if (_this.currentInstruction.component.params[key] !== value) {
	                    paramEquals = false;
	                }
	            });
	        }
	        return paramEquals;
	    };
	    /**
	     * Dynamically update the routing configuration and trigger a navigation.
	     *
	     * ### Usage
	     *
	     * ```
	     * router.config([
	     *   { 'path': '/', 'component': IndexComp },
	     *   { 'path': '/user/:id', 'component': UserComp },
	     * ]);
	     * ```
	     */
	    Router.prototype.config = function (definitions) {
	        var _this = this;
	        definitions.forEach(function (routeDefinition) { _this.registry.config(_this.hostComponent, routeDefinition); });
	        return this.renavigate();
	    };
	    /**
	     * Navigate based on the provided Route Link DSL. It's preferred to navigate with this method
	     * over `navigateByUrl`.
	     *
	     * ### Usage
	     *
	     * This method takes an array representing the Route Link DSL:
	     * ```
	     * ['./MyCmp', {param: 3}]
	     * ```
	     * See the {@link RouterLink} directive for more.
	     */
	    Router.prototype.navigate = function (linkParams) {
	        var instruction = this.generate(linkParams);
	        return this.navigateByInstruction(instruction, false);
	    };
	    /**
	     * Navigate to a URL. Returns a promise that resolves when navigation is complete.
	     * It's preferred to navigate with `navigate` instead of this method, since URLs are more brittle.
	     *
	     * If the given URL begins with a `/`, router will navigate absolutely.
	     * If the given URL does not begin with `/`, the router will navigate relative to this component.
	     */
	    Router.prototype.navigateByUrl = function (url, _skipLocationChange) {
	        var _this = this;
	        if (_skipLocationChange === void 0) { _skipLocationChange = false; }
	        return this._currentNavigation = this._currentNavigation.then(function (_) {
	            _this.lastNavigationAttempt = url;
	            _this._startNavigating();
	            return _this._afterPromiseFinishNavigating(_this.recognize(url).then(function (instruction) {
	                if (lang_1.isBlank(instruction)) {
	                    return false;
	                }
	                return _this._navigate(instruction, _skipLocationChange);
	            }));
	        });
	    };
	    /**
	     * Navigate via the provided instruction. Returns a promise that resolves when navigation is
	     * complete.
	     */
	    Router.prototype.navigateByInstruction = function (instruction, _skipLocationChange) {
	        var _this = this;
	        if (_skipLocationChange === void 0) { _skipLocationChange = false; }
	        if (lang_1.isBlank(instruction)) {
	            return _resolveToFalse;
	        }
	        return this._currentNavigation = this._currentNavigation.then(function (_) {
	            _this._startNavigating();
	            return _this._afterPromiseFinishNavigating(_this._navigate(instruction, _skipLocationChange));
	        });
	    };
	    /** @internal */
	    Router.prototype._settleInstruction = function (instruction) {
	        var _this = this;
	        return instruction.resolveComponent().then(function (_) {
	            var unsettledInstructions = [];
	            if (lang_1.isPresent(instruction.component)) {
	                instruction.component.reuse = false;
	            }
	            if (lang_1.isPresent(instruction.child)) {
	                unsettledInstructions.push(_this._settleInstruction(instruction.child));
	            }
	            collection_1.StringMapWrapper.forEach(instruction.auxInstruction, function (instruction, _) {
	                unsettledInstructions.push(_this._settleInstruction(instruction));
	            });
	            return async_1.PromiseWrapper.all(unsettledInstructions);
	        });
	    };
	    /** @internal */
	    Router.prototype._navigate = function (instruction, _skipLocationChange) {
	        var _this = this;
	        return this._settleInstruction(instruction)
	            .then(function (_) { return _this._routerCanReuse(instruction); })
	            .then(function (_) { return _this._canActivate(instruction); })
	            .then(function (result) {
	            if (!result) {
	                return false;
	            }
	            return _this._routerCanDeactivate(instruction)
	                .then(function (result) {
	                if (result) {
	                    return _this.commit(instruction, _skipLocationChange)
	                        .then(function (_) {
	                        _this._emitNavigationFinish(instruction.toRootUrl());
	                        return true;
	                    });
	                }
	            });
	        });
	    };
	    Router.prototype._emitNavigationFinish = function (url) { async_1.ObservableWrapper.callEmit(this._subject, url); };
	    /** @internal */
	    Router.prototype._emitNavigationFail = function (url) { async_1.ObservableWrapper.callError(this._subject, url); };
	    Router.prototype._afterPromiseFinishNavigating = function (promise) {
	        var _this = this;
	        return async_1.PromiseWrapper.catchError(promise.then(function (_) { return _this._finishNavigating(); }), function (err) {
	            _this._finishNavigating();
	            throw err;
	        });
	    };
	    /*
	     * Recursively set reuse flags
	     */
	    /** @internal */
	    Router.prototype._routerCanReuse = function (instruction) {
	        var _this = this;
	        if (lang_1.isBlank(this._outlet)) {
	            return _resolveToFalse;
	        }
	        if (lang_1.isBlank(instruction.component)) {
	            return _resolveToTrue;
	        }
	        return this._outlet.routerCanReuse(instruction.component)
	            .then(function (result) {
	            instruction.component.reuse = result;
	            if (result && lang_1.isPresent(_this._childRouter) && lang_1.isPresent(instruction.child)) {
	                return _this._childRouter._routerCanReuse(instruction.child);
	            }
	        });
	    };
	    Router.prototype._canActivate = function (nextInstruction) {
	        return canActivateOne(nextInstruction, this.currentInstruction);
	    };
	    Router.prototype._routerCanDeactivate = function (instruction) {
	        var _this = this;
	        if (lang_1.isBlank(this._outlet)) {
	            return _resolveToTrue;
	        }
	        var next;
	        var childInstruction = null;
	        var reuse = false;
	        var componentInstruction = null;
	        if (lang_1.isPresent(instruction)) {
	            childInstruction = instruction.child;
	            componentInstruction = instruction.component;
	            reuse = lang_1.isBlank(instruction.component) || instruction.component.reuse;
	        }
	        if (reuse) {
	            next = _resolveToTrue;
	        }
	        else {
	            next = this._outlet.routerCanDeactivate(componentInstruction);
	        }
	        // TODO: aux route lifecycle hooks
	        return next.then(function (result) {
	            if (result == false) {
	                return false;
	            }
	            if (lang_1.isPresent(_this._childRouter)) {
	                // TODO: ideally, this closure would map to async-await in Dart.
	                // For now, casting to any to suppress an error.
	                return _this._childRouter._routerCanDeactivate(childInstruction);
	            }
	            return true;
	        });
	    };
	    /**
	     * Updates this router and all descendant routers according to the given instruction
	     */
	    Router.prototype.commit = function (instruction, _skipLocationChange) {
	        var _this = this;
	        if (_skipLocationChange === void 0) { _skipLocationChange = false; }
	        this.currentInstruction = instruction;
	        var next = _resolveToTrue;
	        if (lang_1.isPresent(this._outlet) && lang_1.isPresent(instruction.component)) {
	            var componentInstruction = instruction.component;
	            if (componentInstruction.reuse) {
	                next = this._outlet.reuse(componentInstruction);
	            }
	            else {
	                next =
	                    this.deactivate(instruction).then(function (_) { return _this._outlet.activate(componentInstruction); });
	            }
	            if (lang_1.isPresent(instruction.child)) {
	                next = next.then(function (_) {
	                    if (lang_1.isPresent(_this._childRouter)) {
	                        return _this._childRouter.commit(instruction.child);
	                    }
	                });
	            }
	        }
	        var promises = [];
	        this._auxRouters.forEach(function (router, name) {
	            if (lang_1.isPresent(instruction.auxInstruction[name])) {
	                promises.push(router.commit(instruction.auxInstruction[name]));
	            }
	        });
	        return next.then(function (_) { return async_1.PromiseWrapper.all(promises); });
	    };
	    /** @internal */
	    Router.prototype._startNavigating = function () { this.navigating = true; };
	    /** @internal */
	    Router.prototype._finishNavigating = function () { this.navigating = false; };
	    /**
	     * Subscribe to URL updates from the router
	     */
	    Router.prototype.subscribe = function (onNext, onError) {
	        return async_1.ObservableWrapper.subscribe(this._subject, onNext, onError);
	    };
	    /**
	     * Removes the contents of this router's outlet and all descendant outlets
	     */
	    Router.prototype.deactivate = function (instruction) {
	        var _this = this;
	        var childInstruction = null;
	        var componentInstruction = null;
	        if (lang_1.isPresent(instruction)) {
	            childInstruction = instruction.child;
	            componentInstruction = instruction.component;
	        }
	        var next = _resolveToTrue;
	        if (lang_1.isPresent(this._childRouter)) {
	            next = this._childRouter.deactivate(childInstruction);
	        }
	        if (lang_1.isPresent(this._outlet)) {
	            next = next.then(function (_) { return _this._outlet.deactivate(componentInstruction); });
	        }
	        // TODO: handle aux routes
	        return next;
	    };
	    /**
	     * Given a URL, returns an instruction representing the component graph
	     */
	    Router.prototype.recognize = function (url) {
	        var ancestorComponents = this._getAncestorInstructions();
	        return this.registry.recognize(url, ancestorComponents);
	    };
	    Router.prototype._getAncestorInstructions = function () {
	        var ancestorInstructions = [this.currentInstruction];
	        var ancestorRouter = this;
	        while (lang_1.isPresent(ancestorRouter = ancestorRouter.parent)) {
	            ancestorInstructions.unshift(ancestorRouter.currentInstruction);
	        }
	        return ancestorInstructions;
	    };
	    /**
	     * Navigates to either the last URL successfully navigated to, or the last URL requested if the
	     * router has yet to successfully navigate.
	     */
	    Router.prototype.renavigate = function () {
	        if (lang_1.isBlank(this.lastNavigationAttempt)) {
	            return this._currentNavigation;
	        }
	        return this.navigateByUrl(this.lastNavigationAttempt);
	    };
	    /**
	     * Generate an `Instruction` based on the provided Route Link DSL.
	     */
	    Router.prototype.generate = function (linkParams) {
	        var ancestorInstructions = this._getAncestorInstructions();
	        return this.registry.generate(linkParams, ancestorInstructions);
	    };
	    Router = __decorate([
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [route_registry_1.RouteRegistry, Router, Object, Router])
	    ], Router);
	    return Router;
	}());
	exports.Router = Router;
	var RootRouter = (function (_super) {
	    __extends(RootRouter, _super);
	    function RootRouter(registry, location, primaryComponent) {
	        var _this = this;
	        _super.call(this, registry, null, primaryComponent);
	        this.root = this;
	        this._location = location;
	        this._locationSub = this._location.subscribe(function (change) {
	            // we call recognize ourselves
	            _this.recognize(change['url'])
	                .then(function (instruction) {
	                if (lang_1.isPresent(instruction)) {
	                    _this.navigateByInstruction(instruction, lang_1.isPresent(change['pop']))
	                        .then(function (_) {
	                        // this is a popstate event; no need to change the URL
	                        if (lang_1.isPresent(change['pop']) && change['type'] != 'hashchange') {
	                            return;
	                        }
	                        var emitPath = instruction.toUrlPath();
	                        var emitQuery = instruction.toUrlQuery();
	                        if (emitPath.length > 0 && emitPath[0] != '/') {
	                            emitPath = '/' + emitPath;
	                        }
	                        // We've opted to use pushstate and popState APIs regardless of whether you
	                        // an app uses HashLocationStrategy or PathLocationStrategy.
	                        // However, apps that are migrating might have hash links that operate outside
	                        // angular to which routing must respond.
	                        // Therefore we know that all hashchange events occur outside Angular.
	                        // To support these cases where we respond to hashchanges and redirect as a
	                        // result, we need to replace the top item on the stack.
	                        if (change['type'] == 'hashchange') {
	                            if (instruction.toRootUrl() != _this._location.path()) {
	                                _this._location.replaceState(emitPath, emitQuery);
	                            }
	                        }
	                        else {
	                            _this._location.go(emitPath, emitQuery);
	                        }
	                    });
	                }
	                else {
	                    _this._emitNavigationFail(change['url']);
	                }
	            });
	        });
	        this.registry.configFromComponent(primaryComponent);
	        this.navigateByUrl(location.path());
	    }
	    RootRouter.prototype.commit = function (instruction, _skipLocationChange) {
	        var _this = this;
	        if (_skipLocationChange === void 0) { _skipLocationChange = false; }
	        var emitPath = instruction.toUrlPath();
	        var emitQuery = instruction.toUrlQuery();
	        if (emitPath.length > 0 && emitPath[0] != '/') {
	            emitPath = '/' + emitPath;
	        }
	        var promise = _super.prototype.commit.call(this, instruction);
	        if (!_skipLocationChange) {
	            promise = promise.then(function (_) { _this._location.go(emitPath, emitQuery); });
	        }
	        return promise;
	    };
	    RootRouter.prototype.dispose = function () {
	        if (lang_1.isPresent(this._locationSub)) {
	            async_1.ObservableWrapper.dispose(this._locationSub);
	            this._locationSub = null;
	        }
	    };
	    RootRouter = __decorate([
	        core_1.Injectable(),
	        __param(2, core_1.Inject(route_registry_1.ROUTER_PRIMARY_COMPONENT)), 
	        __metadata('design:paramtypes', [route_registry_1.RouteRegistry, common_1.Location, lang_1.Type])
	    ], RootRouter);
	    return RootRouter;
	}(Router));
	exports.RootRouter = RootRouter;
	var ChildRouter = (function (_super) {
	    __extends(ChildRouter, _super);
	    function ChildRouter(parent, hostComponent) {
	        _super.call(this, parent.registry, parent, hostComponent, parent.root);
	        this.parent = parent;
	    }
	    ChildRouter.prototype.navigateByUrl = function (url, _skipLocationChange) {
	        if (_skipLocationChange === void 0) { _skipLocationChange = false; }
	        // Delegate navigation to the root router
	        return this.parent.navigateByUrl(url, _skipLocationChange);
	    };
	    ChildRouter.prototype.navigateByInstruction = function (instruction, _skipLocationChange) {
	        if (_skipLocationChange === void 0) { _skipLocationChange = false; }
	        // Delegate navigation to the root router
	        return this.parent.navigateByInstruction(instruction, _skipLocationChange);
	    };
	    return ChildRouter;
	}(Router));
	function canActivateOne(nextInstruction, prevInstruction) {
	    var next = _resolveToTrue;
	    if (lang_1.isBlank(nextInstruction.component)) {
	        return next;
	    }
	    if (lang_1.isPresent(nextInstruction.child)) {
	        next = canActivateOne(nextInstruction.child, lang_1.isPresent(prevInstruction) ? prevInstruction.child : null);
	    }
	    return next.then(function (result) {
	        if (result == false) {
	            return false;
	        }
	        if (nextInstruction.component.reuse) {
	            return true;
	        }
	        var hook = route_lifecycle_reflector_1.getCanActivateHook(nextInstruction.component.componentType);
	        if (lang_1.isPresent(hook)) {
	            return hook(nextInstruction.component, lang_1.isPresent(prevInstruction) ? prevInstruction.component : null);
	        }
	        return true;
	    });
	}


/***/ },
/* 251 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	function __export(m) {
	    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
	}
	/**
	 * Platform agnostic services.
	 * Can be used both in the browser and on the server.
	 */
	__export(__webpack_require__(252));


/***/ },
/* 252 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	function __export(m) {
	    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
	}
	__export(__webpack_require__(253));
	__export(__webpack_require__(254));
	__export(__webpack_require__(255));
	__export(__webpack_require__(257));
	__export(__webpack_require__(256));


/***/ },
/* 253 */
/***/ function(module, exports) {

	"use strict";
	/**
	 * This class should not be used directly by an application developer. Instead, use
	 * {@link Location}.
	 *
	 * `PlatformLocation` encapsulates all calls to DOM apis, which allows the Router to be platform
	 * agnostic.
	 * This means that we can have different implementation of `PlatformLocation` for the different
	 * platforms
	 * that angular supports. For example, the default `PlatformLocation` is {@link
	 * BrowserPlatformLocation},
	 * however when you run your app in a WebWorker you use {@link WebWorkerPlatformLocation}.
	 *
	 * The `PlatformLocation` class is used directly by all implementations of {@link LocationStrategy}
	 * when
	 * they need to interact with the DOM apis like pushState, popState, etc...
	 *
	 * {@link LocationStrategy} in turn is used by the {@link Location} service which is used directly
	 * by
	 * the {@link Router} in order to navigate between routes. Since all interactions between {@link
	 * Router} /
	 * {@link Location} / {@link LocationStrategy} and DOM apis flow through the `PlatformLocation`
	 * class
	 * they are all platform independent.
	 */
	var PlatformLocation = (function () {
	    function PlatformLocation() {
	    }
	    Object.defineProperty(PlatformLocation.prototype, "pathname", {
	        /* abstract */ get: function () { return null; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(PlatformLocation.prototype, "search", {
	        /* abstract */ get: function () { return null; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(PlatformLocation.prototype, "hash", {
	        /* abstract */ get: function () { return null; },
	        enumerable: true,
	        configurable: true
	    });
	    return PlatformLocation;
	}());
	exports.PlatformLocation = PlatformLocation;


/***/ },
/* 254 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var core_1 = __webpack_require__(2);
	/**
	 * `LocationStrategy` is responsible for representing and reading route state
	 * from the browser's URL. Angular provides two strategies:
	 * {@link HashLocationStrategy} and {@link PathLocationStrategy} (default).
	 *
	 * This is used under the hood of the {@link Location} service.
	 *
	 * Applications should use the {@link Router} or {@link Location} services to
	 * interact with application route state.
	 *
	 * For instance, {@link HashLocationStrategy} produces URLs like
	 * `http://example.com#/foo`, and {@link PathLocationStrategy} produces
	 * `http://example.com/foo` as an equivalent URL.
	 *
	 * See these two classes for more.
	 */
	var LocationStrategy = (function () {
	    function LocationStrategy() {
	    }
	    return LocationStrategy;
	}());
	exports.LocationStrategy = LocationStrategy;
	/**
	 * The `APP_BASE_HREF` token represents the base href to be used with the
	 * {@link PathLocationStrategy}.
	 *
	 * If you're using {@link PathLocationStrategy}, you must provide a provider to a string
	 * representing the URL prefix that should be preserved when generating and recognizing
	 * URLs.
	 *
	 * ### Example
	 *
	 * ```
	 * import {Component} from 'angular2/core';
	 * import {ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig} from 'angular2/router';
	 * import {APP_BASE_HREF} from 'angular2/platform/common';
	 *
	 * @Component({directives: [ROUTER_DIRECTIVES]})
	 * @RouteConfig([
	 *  {...},
	 * ])
	 * class AppCmp {
	 *   // ...
	 * }
	 *
	 * bootstrap(AppCmp, [
	 *   ROUTER_PROVIDERS,
	 *   provide(APP_BASE_HREF, {useValue: '/my/app'})
	 * ]);
	 * ```
	 */
	exports.APP_BASE_HREF = new core_1.OpaqueToken('appBaseHref');


/***/ },
/* 255 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var core_1 = __webpack_require__(2);
	var location_strategy_1 = __webpack_require__(254);
	var location_1 = __webpack_require__(256);
	var platform_location_1 = __webpack_require__(253);
	var lang_1 = __webpack_require__(5);
	/**
	 * `HashLocationStrategy` is a {@link LocationStrategy} used to configure the
	 * {@link Location} service to represent its state in the
	 * [hash fragment](https://en.wikipedia.org/wiki/Uniform_Resource_Locator#Syntax)
	 * of the browser's URL.
	 *
	 * For instance, if you call `location.go('/foo')`, the browser's URL will become
	 * `example.com#/foo`.
	 *
	 * ### Example
	 *
	 * ```
	 * import {Component, provide} from 'angular2/core';
	 * import {
	 *   Location,
	 *   LocationStrategy,
	 *   HashLocationStrategy
	 * } from 'angular2/platform/common';
	 * import {
	 *   ROUTER_DIRECTIVES,
	 *   ROUTER_PROVIDERS,
	 *   RouteConfig
	 * } from 'angular2/router';
	 *
	 * @Component({directives: [ROUTER_DIRECTIVES]})
	 * @RouteConfig([
	 *  {...},
	 * ])
	 * class AppCmp {
	 *   constructor(location: Location) {
	 *     location.go('/foo');
	 *   }
	 * }
	 *
	 * bootstrap(AppCmp, [
	 *   ROUTER_PROVIDERS,
	 *   provide(LocationStrategy, {useClass: HashLocationStrategy})
	 * ]);
	 * ```
	 */
	var HashLocationStrategy = (function (_super) {
	    __extends(HashLocationStrategy, _super);
	    function HashLocationStrategy(_platformLocation, _baseHref) {
	        _super.call(this);
	        this._platformLocation = _platformLocation;
	        this._baseHref = '';
	        if (lang_1.isPresent(_baseHref)) {
	            this._baseHref = _baseHref;
	        }
	    }
	    HashLocationStrategy.prototype.onPopState = function (fn) {
	        this._platformLocation.onPopState(fn);
	        this._platformLocation.onHashChange(fn);
	    };
	    HashLocationStrategy.prototype.getBaseHref = function () { return this._baseHref; };
	    HashLocationStrategy.prototype.path = function () {
	        // the hash value is always prefixed with a `#`
	        // and if it is empty then it will stay empty
	        var path = this._platformLocation.hash;
	        if (!lang_1.isPresent(path))
	            path = '#';
	        // Dart will complain if a call to substring is
	        // executed with a position value that extends the
	        // length of string.
	        return (path.length > 0 ? path.substring(1) : path);
	    };
	    HashLocationStrategy.prototype.prepareExternalUrl = function (internal) {
	        var url = location_1.Location.joinWithSlash(this._baseHref, internal);
	        return url.length > 0 ? ('#' + url) : url;
	    };
	    HashLocationStrategy.prototype.pushState = function (state, title, path, queryParams) {
	        var url = this.prepareExternalUrl(path + location_1.Location.normalizeQueryParams(queryParams));
	        if (url.length == 0) {
	            url = this._platformLocation.pathname;
	        }
	        this._platformLocation.pushState(state, title, url);
	    };
	    HashLocationStrategy.prototype.replaceState = function (state, title, path, queryParams) {
	        var url = this.prepareExternalUrl(path + location_1.Location.normalizeQueryParams(queryParams));
	        if (url.length == 0) {
	            url = this._platformLocation.pathname;
	        }
	        this._platformLocation.replaceState(state, title, url);
	    };
	    HashLocationStrategy.prototype.forward = function () { this._platformLocation.forward(); };
	    HashLocationStrategy.prototype.back = function () { this._platformLocation.back(); };
	    HashLocationStrategy = __decorate([
	        core_1.Injectable(),
	        __param(1, core_1.Optional()),
	        __param(1, core_1.Inject(location_strategy_1.APP_BASE_HREF)), 
	        __metadata('design:paramtypes', [platform_location_1.PlatformLocation, String])
	    ], HashLocationStrategy);
	    return HashLocationStrategy;
	}(location_strategy_1.LocationStrategy));
	exports.HashLocationStrategy = HashLocationStrategy;


/***/ },
/* 256 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var async_1 = __webpack_require__(41);
	var core_1 = __webpack_require__(2);
	var location_strategy_1 = __webpack_require__(254);
	/**
	 * `Location` is a service that applications can use to interact with a browser's URL.
	 * Depending on which {@link LocationStrategy} is used, `Location` will either persist
	 * to the URL's path or the URL's hash segment.
	 *
	 * Note: it's better to use {@link Router#navigate} service to trigger route changes. Use
	 * `Location` only if you need to interact with or create normalized URLs outside of
	 * routing.
	 *
	 * `Location` is responsible for normalizing the URL against the application's base href.
	 * A normalized URL is absolute from the URL host, includes the application's base href, and has no
	 * trailing slash:
	 * - `/my/app/user/123` is normalized
	 * - `my/app/user/123` **is not** normalized
	 * - `/my/app/user/123/` **is not** normalized
	 *
	 * ### Example
	 *
	 * ```
	 * import {Component} from 'angular2/core';
	 * import {Location} from 'angular2/platform/common';
	 * import {
	 *   ROUTER_DIRECTIVES,
	 *   ROUTER_PROVIDERS,
	 *   RouteConfig
	 * } from 'angular2/router';
	 *
	 * @Component({directives: [ROUTER_DIRECTIVES]})
	 * @RouteConfig([
	 *  {...},
	 * ])
	 * class AppCmp {
	 *   constructor(location: Location) {
	 *     location.go('/foo');
	 *   }
	 * }
	 *
	 * bootstrap(AppCmp, [ROUTER_PROVIDERS]);
	 * ```
	 */
	var Location = (function () {
	    function Location(platformStrategy) {
	        var _this = this;
	        this.platformStrategy = platformStrategy;
	        /** @internal */
	        this._subject = new async_1.EventEmitter();
	        var browserBaseHref = this.platformStrategy.getBaseHref();
	        this._baseHref = Location.stripTrailingSlash(_stripIndexHtml(browserBaseHref));
	        this.platformStrategy.onPopState(function (ev) {
	            async_1.ObservableWrapper.callEmit(_this._subject, { 'url': _this.path(), 'pop': true, 'type': ev.type });
	        });
	    }
	    /**
	     * Returns the normalized URL path.
	     */
	    Location.prototype.path = function () { return this.normalize(this.platformStrategy.path()); };
	    /**
	     * Given a string representing a URL, returns the normalized URL path without leading or
	     * trailing slashes
	     */
	    Location.prototype.normalize = function (url) {
	        return Location.stripTrailingSlash(_stripBaseHref(this._baseHref, _stripIndexHtml(url)));
	    };
	    /**
	     * Given a string representing a URL, returns the platform-specific external URL path.
	     * If the given URL doesn't begin with a leading slash (`'/'`), this method adds one
	     * before normalizing. This method will also add a hash if `HashLocationStrategy` is
	     * used, or the `APP_BASE_HREF` if the `PathLocationStrategy` is in use.
	     */
	    Location.prototype.prepareExternalUrl = function (url) {
	        if (url.length > 0 && !url.startsWith('/')) {
	            url = '/' + url;
	        }
	        return this.platformStrategy.prepareExternalUrl(url);
	    };
	    // TODO: rename this method to pushState
	    /**
	     * Changes the browsers URL to the normalized version of the given URL, and pushes a
	     * new item onto the platform's history.
	     */
	    Location.prototype.go = function (path, query) {
	        if (query === void 0) { query = ''; }
	        this.platformStrategy.pushState(null, '', path, query);
	    };
	    /**
	     * Changes the browsers URL to the normalized version of the given URL, and replaces
	     * the top item on the platform's history stack.
	     */
	    Location.prototype.replaceState = function (path, query) {
	        if (query === void 0) { query = ''; }
	        this.platformStrategy.replaceState(null, '', path, query);
	    };
	    /**
	     * Navigates forward in the platform's history.
	     */
	    Location.prototype.forward = function () { this.platformStrategy.forward(); };
	    /**
	     * Navigates back in the platform's history.
	     */
	    Location.prototype.back = function () { this.platformStrategy.back(); };
	    /**
	     * Subscribe to the platform's `popState` events.
	     */
	    Location.prototype.subscribe = function (onNext, onThrow, onReturn) {
	        if (onThrow === void 0) { onThrow = null; }
	        if (onReturn === void 0) { onReturn = null; }
	        return async_1.ObservableWrapper.subscribe(this._subject, onNext, onThrow, onReturn);
	    };
	    /**
	     * Given a string of url parameters, prepend with '?' if needed, otherwise return parameters as
	     * is.
	     */
	    Location.normalizeQueryParams = function (params) {
	        return (params.length > 0 && params.substring(0, 1) != '?') ? ('?' + params) : params;
	    };
	    /**
	     * Given 2 parts of a url, join them with a slash if needed.
	     */
	    Location.joinWithSlash = function (start, end) {
	        if (start.length == 0) {
	            return end;
	        }
	        if (end.length == 0) {
	            return start;
	        }
	        var slashes = 0;
	        if (start.endsWith('/')) {
	            slashes++;
	        }
	        if (end.startsWith('/')) {
	            slashes++;
	        }
	        if (slashes == 2) {
	            return start + end.substring(1);
	        }
	        if (slashes == 1) {
	            return start + end;
	        }
	        return start + '/' + end;
	    };
	    /**
	     * If url has a trailing slash, remove it, otherwise return url as is.
	     */
	    Location.stripTrailingSlash = function (url) {
	        if (/\/$/g.test(url)) {
	            url = url.substring(0, url.length - 1);
	        }
	        return url;
	    };
	    Location = __decorate([
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [location_strategy_1.LocationStrategy])
	    ], Location);
	    return Location;
	}());
	exports.Location = Location;
	function _stripBaseHref(baseHref, url) {
	    if (baseHref.length > 0 && url.startsWith(baseHref)) {
	        return url.substring(baseHref.length);
	    }
	    return url;
	}
	function _stripIndexHtml(url) {
	    if (/\/index.html$/g.test(url)) {
	        // '/index.html'.length == 11
	        return url.substring(0, url.length - 11);
	    }
	    return url;
	}


/***/ },
/* 257 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var core_1 = __webpack_require__(2);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var platform_location_1 = __webpack_require__(253);
	var location_strategy_1 = __webpack_require__(254);
	var location_1 = __webpack_require__(256);
	/**
	 * `PathLocationStrategy` is a {@link LocationStrategy} used to configure the
	 * {@link Location} service to represent its state in the
	 * [path](https://en.wikipedia.org/wiki/Uniform_Resource_Locator#Syntax) of the
	 * browser's URL.
	 *
	 * `PathLocationStrategy` is the default binding for {@link LocationStrategy}
	 * provided in {@link ROUTER_PROVIDERS}.
	 *
	 * If you're using `PathLocationStrategy`, you must provide a provider for
	 * {@link APP_BASE_HREF} to a string representing the URL prefix that should
	 * be preserved when generating and recognizing URLs.
	 *
	 * For instance, if you provide an `APP_BASE_HREF` of `'/my/app'` and call
	 * `location.go('/foo')`, the browser's URL will become
	 * `example.com/my/app/foo`.
	 *
	 * ### Example
	 *
	 * ```
	 * import {Component, provide} from 'angular2/core';
	 * import {bootstrap} from 'angular2/platform/browser';
	 * import {
	 *   Location,
	 *   APP_BASE_HREF
	 * } from 'angular2/platform/common';
	 * import {
	 *   ROUTER_DIRECTIVES,
	 *   ROUTER_PROVIDERS,
	 *   RouteConfig
	 * } from 'angular2/router';
	 *
	 * @Component({directives: [ROUTER_DIRECTIVES]})
	 * @RouteConfig([
	 *  {...},
	 * ])
	 * class AppCmp {
	 *   constructor(location: Location) {
	 *     location.go('/foo');
	 *   }
	 * }
	 *
	 * bootstrap(AppCmp, [
	 *   ROUTER_PROVIDERS, // includes binding to PathLocationStrategy
	 *   provide(APP_BASE_HREF, {useValue: '/my/app'})
	 * ]);
	 * ```
	 */
	var PathLocationStrategy = (function (_super) {
	    __extends(PathLocationStrategy, _super);
	    function PathLocationStrategy(_platformLocation, href) {
	        _super.call(this);
	        this._platformLocation = _platformLocation;
	        if (lang_1.isBlank(href)) {
	            href = this._platformLocation.getBaseHrefFromDOM();
	        }
	        if (lang_1.isBlank(href)) {
	            throw new exceptions_1.BaseException("No base href set. Please provide a value for the APP_BASE_HREF token or add a base element to the document.");
	        }
	        this._baseHref = href;
	    }
	    PathLocationStrategy.prototype.onPopState = function (fn) {
	        this._platformLocation.onPopState(fn);
	        this._platformLocation.onHashChange(fn);
	    };
	    PathLocationStrategy.prototype.getBaseHref = function () { return this._baseHref; };
	    PathLocationStrategy.prototype.prepareExternalUrl = function (internal) {
	        return location_1.Location.joinWithSlash(this._baseHref, internal);
	    };
	    PathLocationStrategy.prototype.path = function () {
	        return this._platformLocation.pathname +
	            location_1.Location.normalizeQueryParams(this._platformLocation.search);
	    };
	    PathLocationStrategy.prototype.pushState = function (state, title, url, queryParams) {
	        var externalUrl = this.prepareExternalUrl(url + location_1.Location.normalizeQueryParams(queryParams));
	        this._platformLocation.pushState(state, title, externalUrl);
	    };
	    PathLocationStrategy.prototype.replaceState = function (state, title, url, queryParams) {
	        var externalUrl = this.prepareExternalUrl(url + location_1.Location.normalizeQueryParams(queryParams));
	        this._platformLocation.replaceState(state, title, externalUrl);
	    };
	    PathLocationStrategy.prototype.forward = function () { this._platformLocation.forward(); };
	    PathLocationStrategy.prototype.back = function () { this._platformLocation.back(); };
	    PathLocationStrategy = __decorate([
	        core_1.Injectable(),
	        __param(1, core_1.Optional()),
	        __param(1, core_1.Inject(location_strategy_1.APP_BASE_HREF)), 
	        __metadata('design:paramtypes', [platform_location_1.PlatformLocation, String])
	    ], PathLocationStrategy);
	    return PathLocationStrategy;
	}(location_strategy_1.LocationStrategy));
	exports.PathLocationStrategy = PathLocationStrategy;


/***/ },
/* 258 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var collection_1 = __webpack_require__(15);
	var async_1 = __webpack_require__(41);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var reflection_1 = __webpack_require__(18);
	var core_1 = __webpack_require__(2);
	var route_config_impl_1 = __webpack_require__(259);
	var rules_1 = __webpack_require__(260);
	var rule_set_1 = __webpack_require__(263);
	var instruction_1 = __webpack_require__(262);
	var route_config_normalizer_1 = __webpack_require__(270);
	var url_parser_1 = __webpack_require__(261);
	var _resolveToNull = async_1.PromiseWrapper.resolve(null);
	// A LinkItemArray is an array, which describes a set of routes
	// The items in the array are found in groups:
	// - the first item is the name of the route
	// - the next items are:
	//   - an object containing parameters
	//   - or an array describing an aux route
	// export type LinkRouteItem = string | Object;
	// export type LinkItem = LinkRouteItem | Array<LinkRouteItem>;
	// export type LinkItemArray = Array<LinkItem>;
	/**
	 * Token used to bind the component with the top-level {@link RouteConfig}s for the
	 * application.
	 *
	 * ### 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]);
	 * ```
	 */
	exports.ROUTER_PRIMARY_COMPONENT = 
	/*@ts2dart_const*/ new core_1.OpaqueToken('RouterPrimaryComponent');
	/**
	 * The RouteRegistry holds route configurations for each component in an Angular app.
	 * It is responsible for creating Instructions from URLs, and generating URLs based on route and
	 * parameters.
	 */
	var RouteRegistry = (function () {
	    function RouteRegistry(_rootComponent) {
	        this._rootComponent = _rootComponent;
	        this._rules = new collection_1.Map();
	    }
	    /**
	     * Given a component and a configuration object, add the route to this registry
	     */
	    RouteRegistry.prototype.config = function (parentComponent, config) {
	        config = route_config_normalizer_1.normalizeRouteConfig(config, this);
	        // this is here because Dart type guard reasons
	        if (config instanceof route_config_impl_1.Route) {
	            route_config_normalizer_1.assertComponentExists(config.component, config.path);
	        }
	        else if (config instanceof route_config_impl_1.AuxRoute) {
	            route_config_normalizer_1.assertComponentExists(config.component, config.path);
	        }
	        var rules = this._rules.get(parentComponent);
	        if (lang_1.isBlank(rules)) {
	            rules = new rule_set_1.RuleSet();
	            this._rules.set(parentComponent, rules);
	        }
	        var terminal = rules.config(config);
	        if (config instanceof route_config_impl_1.Route) {
	            if (terminal) {
	                assertTerminalComponent(config.component, config.path);
	            }
	            else {
	                this.configFromComponent(config.component);
	            }
	        }
	    };
	    /**
	     * Reads the annotations of a component and configures the registry based on them
	     */
	    RouteRegistry.prototype.configFromComponent = function (component) {
	        var _this = this;
	        if (!lang_1.isType(component)) {
	            return;
	        }
	        // Don't read the annotations from a type more than once –
	        // this prevents an infinite loop if a component routes recursively.
	        if (this._rules.has(component)) {
	            return;
	        }
	        var annotations = reflection_1.reflector.annotations(component);
	        if (lang_1.isPresent(annotations)) {
	            for (var i = 0; i < annotations.length; i++) {
	                var annotation = annotations[i];
	                if (annotation instanceof route_config_impl_1.RouteConfig) {
	                    var routeCfgs = annotation.configs;
	                    routeCfgs.forEach(function (config) { return _this.config(component, config); });
	                }
	            }
	        }
	    };
	    /**
	     * Given a URL and a parent component, return the most specific instruction for navigating
	     * the application into the state specified by the url
	     */
	    RouteRegistry.prototype.recognize = function (url, ancestorInstructions) {
	        var parsedUrl = url_parser_1.parser.parse(url);
	        return this._recognize(parsedUrl, []);
	    };
	    /**
	     * Recognizes all parent-child routes, but creates unresolved auxiliary routes
	     */
	    RouteRegistry.prototype._recognize = function (parsedUrl, ancestorInstructions, _aux) {
	        var _this = this;
	        if (_aux === void 0) { _aux = false; }
	        var parentInstruction = collection_1.ListWrapper.last(ancestorInstructions);
	        var parentComponent = lang_1.isPresent(parentInstruction) ? parentInstruction.component.componentType :
	            this._rootComponent;
	        var rules = this._rules.get(parentComponent);
	        if (lang_1.isBlank(rules)) {
	            return _resolveToNull;
	        }
	        // Matches some beginning part of the given URL
	        var possibleMatches = _aux ? rules.recognizeAuxiliary(parsedUrl) : rules.recognize(parsedUrl);
	        var matchPromises = possibleMatches.map(function (candidate) { return candidate.then(function (candidate) {
	            if (candidate instanceof rules_1.PathMatch) {
	                var auxParentInstructions = ancestorInstructions.length > 0 ? [collection_1.ListWrapper.last(ancestorInstructions)] : [];
	                var auxInstructions = _this._auxRoutesToUnresolved(candidate.remainingAux, auxParentInstructions);
	                var instruction = new instruction_1.ResolvedInstruction(candidate.instruction, null, auxInstructions);
	                if (lang_1.isBlank(candidate.instruction) || candidate.instruction.terminal) {
	                    return instruction;
	                }
	                var newAncestorInstructions = ancestorInstructions.concat([instruction]);
	                return _this._recognize(candidate.remaining, newAncestorInstructions)
	                    .then(function (childInstruction) {
	                    if (lang_1.isBlank(childInstruction)) {
	                        return null;
	                    }
	                    // redirect instructions are already absolute
	                    if (childInstruction instanceof instruction_1.RedirectInstruction) {
	                        return childInstruction;
	                    }
	                    instruction.child = childInstruction;
	                    return instruction;
	                });
	            }
	            if (candidate instanceof rules_1.RedirectMatch) {
	                var instruction = _this.generate(candidate.redirectTo, ancestorInstructions.concat([null]));
	                return new instruction_1.RedirectInstruction(instruction.component, instruction.child, instruction.auxInstruction, candidate.specificity);
	            }
	        }); });
	        if ((lang_1.isBlank(parsedUrl) || parsedUrl.path == '') && possibleMatches.length == 0) {
	            return async_1.PromiseWrapper.resolve(this.generateDefault(parentComponent));
	        }
	        return async_1.PromiseWrapper.all(matchPromises).then(mostSpecific);
	    };
	    RouteRegistry.prototype._auxRoutesToUnresolved = function (auxRoutes, parentInstructions) {
	        var _this = this;
	        var unresolvedAuxInstructions = {};
	        auxRoutes.forEach(function (auxUrl) {
	            unresolvedAuxInstructions[auxUrl.path] = new instruction_1.UnresolvedInstruction(function () { return _this._recognize(auxUrl, parentInstructions, true); });
	        });
	        return unresolvedAuxInstructions;
	    };
	    /**
	     * Given a normalized list with component names and params like: `['user', {id: 3 }]`
	     * generates a url with a leading slash relative to the provided `parentComponent`.
	     *
	     * If the optional param `_aux` is `true`, then we generate starting at an auxiliary
	     * route boundary.
	     */
	    RouteRegistry.prototype.generate = function (linkParams, ancestorInstructions, _aux) {
	        if (_aux === void 0) { _aux = false; }
	        var params = splitAndFlattenLinkParams(linkParams);
	        var prevInstruction;
	        // The first segment should be either '.' (generate from parent) or '' (generate from root).
	        // When we normalize above, we strip all the slashes, './' becomes '.' and '/' becomes ''.
	        if (collection_1.ListWrapper.first(params) == '') {
	            params.shift();
	            prevInstruction = collection_1.ListWrapper.first(ancestorInstructions);
	            ancestorInstructions = [];
	        }
	        else {
	            prevInstruction = ancestorInstructions.length > 0 ? ancestorInstructions.pop() : null;
	            if (collection_1.ListWrapper.first(params) == '.') {
	                params.shift();
	            }
	            else if (collection_1.ListWrapper.first(params) == '..') {
	                while (collection_1.ListWrapper.first(params) == '..') {
	                    if (ancestorInstructions.length <= 0) {
	                        throw new exceptions_1.BaseException("Link \"" + collection_1.ListWrapper.toJSON(linkParams) + "\" has too many \"../\" segments.");
	                    }
	                    prevInstruction = ancestorInstructions.pop();
	                    params = collection_1.ListWrapper.slice(params, 1);
	                }
	            }
	            else {
	                // we must only peak at the link param, and not consume it
	                var routeName = collection_1.ListWrapper.first(params);
	                var parentComponentType = this._rootComponent;
	                var grandparentComponentType = null;
	                if (ancestorInstructions.length > 1) {
	                    var parentComponentInstruction = ancestorInstructions[ancestorInstructions.length - 1];
	                    var grandComponentInstruction = ancestorInstructions[ancestorInstructions.length - 2];
	                    parentComponentType = parentComponentInstruction.component.componentType;
	                    grandparentComponentType = grandComponentInstruction.component.componentType;
	                }
	                else if (ancestorInstructions.length == 1) {
	                    parentComponentType = ancestorInstructions[0].component.componentType;
	                    grandparentComponentType = this._rootComponent;
	                }
	                // For a link with no leading `./`, `/`, or `../`, we look for a sibling and child.
	                // If both exist, we throw. Otherwise, we prefer whichever exists.
	                var childRouteExists = this.hasRoute(routeName, parentComponentType);
	                var parentRouteExists = lang_1.isPresent(grandparentComponentType) &&
	                    this.hasRoute(routeName, grandparentComponentType);
	                if (parentRouteExists && childRouteExists) {
	                    var msg = "Link \"" + collection_1.ListWrapper.toJSON(linkParams) + "\" is ambiguous, use \"./\" or \"../\" to disambiguate.";
	                    throw new exceptions_1.BaseException(msg);
	                }
	                if (parentRouteExists) {
	                    prevInstruction = ancestorInstructions.pop();
	                }
	            }
	        }
	        if (params[params.length - 1] == '') {
	            params.pop();
	        }
	        if (params.length > 0 && params[0] == '') {
	            params.shift();
	        }
	        if (params.length < 1) {
	            var msg = "Link \"" + collection_1.ListWrapper.toJSON(linkParams) + "\" must include a route name.";
	            throw new exceptions_1.BaseException(msg);
	        }
	        var generatedInstruction = this._generate(params, ancestorInstructions, prevInstruction, _aux, linkParams);
	        // we don't clone the first (root) element
	        for (var i = ancestorInstructions.length - 1; i >= 0; i--) {
	            var ancestorInstruction = ancestorInstructions[i];
	            if (lang_1.isBlank(ancestorInstruction)) {
	                break;
	            }
	            generatedInstruction = ancestorInstruction.replaceChild(generatedInstruction);
	        }
	        return generatedInstruction;
	    };
	    /*
	     * Internal helper that does not make any assertions about the beginning of the link DSL.
	     * `ancestorInstructions` are parents that will be cloned.
	     * `prevInstruction` is the existing instruction that would be replaced, but which might have
	     * aux routes that need to be cloned.
	     */
	    RouteRegistry.prototype._generate = function (linkParams, ancestorInstructions, prevInstruction, _aux, _originalLink) {
	        var _this = this;
	        if (_aux === void 0) { _aux = false; }
	        var parentComponentType = this._rootComponent;
	        var componentInstruction = null;
	        var auxInstructions = {};
	        var parentInstruction = collection_1.ListWrapper.last(ancestorInstructions);
	        if (lang_1.isPresent(parentInstruction) && lang_1.isPresent(parentInstruction.component)) {
	            parentComponentType = parentInstruction.component.componentType;
	        }
	        if (linkParams.length == 0) {
	            var defaultInstruction = this.generateDefault(parentComponentType);
	            if (lang_1.isBlank(defaultInstruction)) {
	                throw new exceptions_1.BaseException("Link \"" + collection_1.ListWrapper.toJSON(_originalLink) + "\" does not resolve to a terminal instruction.");
	            }
	            return defaultInstruction;
	        }
	        // for non-aux routes, we want to reuse the predecessor's existing primary and aux routes
	        // and only override routes for which the given link DSL provides
	        if (lang_1.isPresent(prevInstruction) && !_aux) {
	            auxInstructions = collection_1.StringMapWrapper.merge(prevInstruction.auxInstruction, auxInstructions);
	            componentInstruction = prevInstruction.component;
	        }
	        var rules = this._rules.get(parentComponentType);
	        if (lang_1.isBlank(rules)) {
	            throw new exceptions_1.BaseException("Component \"" + lang_1.getTypeNameForDebugging(parentComponentType) + "\" has no route config.");
	        }
	        var linkParamIndex = 0;
	        var routeParams = {};
	        // first, recognize the primary route if one is provided
	        if (linkParamIndex < linkParams.length && lang_1.isString(linkParams[linkParamIndex])) {
	            var routeName = linkParams[linkParamIndex];
	            if (routeName == '' || routeName == '.' || routeName == '..') {
	                throw new exceptions_1.BaseException("\"" + routeName + "/\" is only allowed at the beginning of a link DSL.");
	            }
	            linkParamIndex += 1;
	            if (linkParamIndex < linkParams.length) {
	                var linkParam = linkParams[linkParamIndex];
	                if (lang_1.isStringMap(linkParam) && !lang_1.isArray(linkParam)) {
	                    routeParams = linkParam;
	                    linkParamIndex += 1;
	                }
	            }
	            var routeRecognizer = (_aux ? rules.auxRulesByName : rules.rulesByName).get(routeName);
	            if (lang_1.isBlank(routeRecognizer)) {
	                throw new exceptions_1.BaseException("Component \"" + lang_1.getTypeNameForDebugging(parentComponentType) + "\" has no route named \"" + routeName + "\".");
	            }
	            // Create an "unresolved instruction" for async routes
	            // we'll figure out the rest of the route when we resolve the instruction and
	            // perform a navigation
	            if (lang_1.isBlank(routeRecognizer.handler.componentType)) {
	                var generatedUrl = routeRecognizer.generateComponentPathValues(routeParams);
	                return new instruction_1.UnresolvedInstruction(function () {
	                    return routeRecognizer.handler.resolveComponentType().then(function (_) {
	                        return _this._generate(linkParams, ancestorInstructions, prevInstruction, _aux, _originalLink);
	                    });
	                }, generatedUrl.urlPath, url_parser_1.convertUrlParamsToArray(generatedUrl.urlParams));
	            }
	            componentInstruction = _aux ? rules.generateAuxiliary(routeName, routeParams) :
	                rules.generate(routeName, routeParams);
	        }
	        // Next, recognize auxiliary instructions.
	        // If we have an ancestor instruction, we preserve whatever aux routes are active from it.
	        while (linkParamIndex < linkParams.length && lang_1.isArray(linkParams[linkParamIndex])) {
	            var auxParentInstruction = [parentInstruction];
	            var auxInstruction = this._generate(linkParams[linkParamIndex], auxParentInstruction, null, true, _originalLink);
	            // TODO: this will not work for aux routes with parameters or multiple segments
	            auxInstructions[auxInstruction.component.urlPath] = auxInstruction;
	            linkParamIndex += 1;
	        }
	        var instruction = new instruction_1.ResolvedInstruction(componentInstruction, null, auxInstructions);
	        // If the component is sync, we can generate resolved child route instructions
	        // If not, we'll resolve the instructions at navigation time
	        if (lang_1.isPresent(componentInstruction) && lang_1.isPresent(componentInstruction.componentType)) {
	            var childInstruction = null;
	            if (componentInstruction.terminal) {
	                if (linkParamIndex >= linkParams.length) {
	                }
	            }
	            else {
	                var childAncestorComponents = ancestorInstructions.concat([instruction]);
	                var remainingLinkParams = linkParams.slice(linkParamIndex);
	                childInstruction = this._generate(remainingLinkParams, childAncestorComponents, null, false, _originalLink);
	            }
	            instruction.child = childInstruction;
	        }
	        return instruction;
	    };
	    RouteRegistry.prototype.hasRoute = function (name, parentComponent) {
	        var rules = this._rules.get(parentComponent);
	        if (lang_1.isBlank(rules)) {
	            return false;
	        }
	        return rules.hasRoute(name);
	    };
	    RouteRegistry.prototype.generateDefault = function (componentCursor) {
	        var _this = this;
	        if (lang_1.isBlank(componentCursor)) {
	            return null;
	        }
	        var rules = this._rules.get(componentCursor);
	        if (lang_1.isBlank(rules) || lang_1.isBlank(rules.defaultRule)) {
	            return null;
	        }
	        var defaultChild = null;
	        if (lang_1.isPresent(rules.defaultRule.handler.componentType)) {
	            var componentInstruction = rules.defaultRule.generate({});
	            if (!rules.defaultRule.terminal) {
	                defaultChild = this.generateDefault(rules.defaultRule.handler.componentType);
	            }
	            return new instruction_1.DefaultInstruction(componentInstruction, defaultChild);
	        }
	        return new instruction_1.UnresolvedInstruction(function () {
	            return rules.defaultRule.handler.resolveComponentType().then(function (_) { return _this.generateDefault(componentCursor); });
	        });
	    };
	    RouteRegistry = __decorate([
	        core_1.Injectable(),
	        __param(0, core_1.Inject(exports.ROUTER_PRIMARY_COMPONENT)), 
	        __metadata('design:paramtypes', [lang_1.Type])
	    ], RouteRegistry);
	    return RouteRegistry;
	}());
	exports.RouteRegistry = RouteRegistry;
	/*
	 * Given: ['/a/b', {c: 2}]
	 * Returns: ['', 'a', 'b', {c: 2}]
	 */
	function splitAndFlattenLinkParams(linkParams) {
	    var accumulation = [];
	    linkParams.forEach(function (item) {
	        if (lang_1.isString(item)) {
	            var strItem = item;
	            accumulation = accumulation.concat(strItem.split('/'));
	        }
	        else {
	            accumulation.push(item);
	        }
	    });
	    return accumulation;
	}
	/*
	 * Given a list of instructions, returns the most specific instruction
	 */
	function mostSpecific(instructions) {
	    instructions = instructions.filter(function (instruction) { return lang_1.isPresent(instruction); });
	    if (instructions.length == 0) {
	        return null;
	    }
	    if (instructions.length == 1) {
	        return instructions[0];
	    }
	    var first = instructions[0];
	    var rest = instructions.slice(1);
	    return rest.reduce(function (instruction, contender) {
	        if (compareSpecificityStrings(contender.specificity, instruction.specificity) == -1) {
	            return contender;
	        }
	        return instruction;
	    }, first);
	}
	/*
	 * Expects strings to be in the form of "[0-2]+"
	 * Returns -1 if string A should be sorted above string B, 1 if it should be sorted after,
	 * or 0 if they are the same.
	 */
	function compareSpecificityStrings(a, b) {
	    var l = lang_1.Math.min(a.length, b.length);
	    for (var i = 0; i < l; i += 1) {
	        var ai = lang_1.StringWrapper.charCodeAt(a, i);
	        var bi = lang_1.StringWrapper.charCodeAt(b, i);
	        var difference = bi - ai;
	        if (difference != 0) {
	            return difference;
	        }
	    }
	    return a.length - b.length;
	}
	function assertTerminalComponent(component, path) {
	    if (!lang_1.isType(component)) {
	        return;
	    }
	    var annotations = reflection_1.reflector.annotations(component);
	    if (lang_1.isPresent(annotations)) {
	        for (var i = 0; i < annotations.length; i++) {
	            var annotation = annotations[i];
	            if (annotation instanceof route_config_impl_1.RouteConfig) {
	                throw new exceptions_1.BaseException("Child routes are not allowed for \"" + path + "\". Use \"...\" on the parent's route path.");
	            }
	        }
	    }
	}


/***/ },
/* 259 */
/***/ function(module, exports) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __make_dart_analyzer_happy = null;
	/**
	 * The `RouteConfig` decorator defines routes for a given component.
	 *
	 * It takes an array of {@link RouteDefinition}s.
	 * @ts2dart_const
	 */
	var RouteConfig = (function () {
	    function RouteConfig(configs) {
	        this.configs = configs;
	    }
	    return RouteConfig;
	}());
	exports.RouteConfig = RouteConfig;
	/* @ts2dart_const */
	var AbstractRoute = (function () {
	    function AbstractRoute(_a) {
	        var name = _a.name, useAsDefault = _a.useAsDefault, path = _a.path, regex = _a.regex, serializer = _a.serializer, data = _a.data;
	        this.name = name;
	        this.useAsDefault = useAsDefault;
	        this.path = path;
	        this.regex = regex;
	        this.serializer = serializer;
	        this.data = data;
	    }
	    return AbstractRoute;
	}());
	exports.AbstractRoute = AbstractRoute;
	/**
	 * `Route` is a type of {@link RouteDefinition} used to route a path to a component.
	 *
	 * It has the following properties:
	 * - `path` is a string that uses the route matcher DSL.
	 * - `component` a component type.
	 * - `name` is an optional `CamelCase` string representing the name of the route.
	 * - `data` is an optional property of any type representing arbitrary route metadata for the given
	 * route. It is injectable via {@link RouteData}.
	 * - `useAsDefault` is a boolean value. If `true`, the child route will be navigated to if no child
	 * route is specified during the navigation.
	 *
	 * ### Example
	 * ```
	 * import {RouteConfig, Route} from 'angular2/router';
	 *
	 * @RouteConfig([
	 *   new Route({path: '/home', component: HomeCmp, name: 'HomeCmp' })
	 * ])
	 * class MyApp {}
	 * ```
	 * @ts2dart_const
	 */
	var Route = (function (_super) {
	    __extends(Route, _super);
	    function Route(_a) {
	        var name = _a.name, useAsDefault = _a.useAsDefault, path = _a.path, regex = _a.regex, serializer = _a.serializer, data = _a.data, component = _a.component;
	        _super.call(this, {
	            name: name,
	            useAsDefault: useAsDefault,
	            path: path,
	            regex: regex,
	            serializer: serializer,
	            data: data
	        });
	        this.aux = null;
	        this.component = component;
	    }
	    return Route;
	}(AbstractRoute));
	exports.Route = Route;
	/**
	 * `AuxRoute` is a type of {@link RouteDefinition} used to define an auxiliary route.
	 *
	 * It takes an object with the following properties:
	 * - `path` is a string that uses the route matcher DSL.
	 * - `component` a component type.
	 * - `name` is an optional `CamelCase` string representing the name of the route.
	 * - `data` is an optional property of any type representing arbitrary route metadata for the given
	 * route. It is injectable via {@link RouteData}.
	 *
	 * ### Example
	 * ```
	 * import {RouteConfig, AuxRoute} from 'angular2/router';
	 *
	 * @RouteConfig([
	 *   new AuxRoute({path: '/home', component: HomeCmp})
	 * ])
	 * class MyApp {}
	 * ```
	 * @ts2dart_const
	 */
	var AuxRoute = (function (_super) {
	    __extends(AuxRoute, _super);
	    function AuxRoute(_a) {
	        var name = _a.name, useAsDefault = _a.useAsDefault, path = _a.path, regex = _a.regex, serializer = _a.serializer, data = _a.data, component = _a.component;
	        _super.call(this, {
	            name: name,
	            useAsDefault: useAsDefault,
	            path: path,
	            regex: regex,
	            serializer: serializer,
	            data: data
	        });
	        this.component = component;
	    }
	    return AuxRoute;
	}(AbstractRoute));
	exports.AuxRoute = AuxRoute;
	/**
	 * `AsyncRoute` is a type of {@link RouteDefinition} used to route a path to an asynchronously
	 * loaded component.
	 *
	 * It has the following properties:
	 * - `path` is a string that uses the route matcher DSL.
	 * - `loader` is a function that returns a promise that resolves to a component.
	 * - `name` is an optional `CamelCase` string representing the name of the route.
	 * - `data` is an optional property of any type representing arbitrary route metadata for the given
	 * route. It is injectable via {@link RouteData}.
	 * - `useAsDefault` is a boolean value. If `true`, the child route will be navigated to if no child
	 * route is specified during the navigation.
	 *
	 * ### Example
	 * ```
	 * import {RouteConfig, AsyncRoute} from 'angular2/router';
	 *
	 * @RouteConfig([
	 *   new AsyncRoute({path: '/home', loader: () => Promise.resolve(MyLoadedCmp), name:
	 * 'MyLoadedCmp'})
	 * ])
	 * class MyApp {}
	 * ```
	 * @ts2dart_const
	 */
	var AsyncRoute = (function (_super) {
	    __extends(AsyncRoute, _super);
	    function AsyncRoute(_a) {
	        var name = _a.name, useAsDefault = _a.useAsDefault, path = _a.path, regex = _a.regex, serializer = _a.serializer, data = _a.data, loader = _a.loader;
	        _super.call(this, {
	            name: name,
	            useAsDefault: useAsDefault,
	            path: path,
	            regex: regex,
	            serializer: serializer,
	            data: data
	        });
	        this.aux = null;
	        this.loader = loader;
	    }
	    return AsyncRoute;
	}(AbstractRoute));
	exports.AsyncRoute = AsyncRoute;
	/**
	 * `Redirect` is a type of {@link RouteDefinition} used to route a path to a canonical route.
	 *
	 * It has the following properties:
	 * - `path` is a string that uses the route matcher DSL.
	 * - `redirectTo` is an array representing the link DSL.
	 *
	 * Note that redirects **do not** affect how links are generated. For that, see the `useAsDefault`
	 * option.
	 *
	 * ### Example
	 * ```
	 * import {RouteConfig, Route, Redirect} from 'angular2/router';
	 *
	 * @RouteConfig([
	 *   new Redirect({path: '/', redirectTo: ['/Home'] }),
	 *   new Route({path: '/home', component: HomeCmp, name: 'Home'})
	 * ])
	 * class MyApp {}
	 * ```
	 * @ts2dart_const
	 */
	var Redirect = (function (_super) {
	    __extends(Redirect, _super);
	    function Redirect(_a) {
	        var name = _a.name, useAsDefault = _a.useAsDefault, path = _a.path, regex = _a.regex, serializer = _a.serializer, data = _a.data, redirectTo = _a.redirectTo;
	        _super.call(this, {
	            name: name,
	            useAsDefault: useAsDefault,
	            path: path,
	            regex: regex,
	            serializer: serializer,
	            data: data
	        });
	        this.redirectTo = redirectTo;
	    }
	    return Redirect;
	}(AbstractRoute));
	exports.Redirect = Redirect;


/***/ },
/* 260 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var promise_1 = __webpack_require__(42);
	var collection_1 = __webpack_require__(15);
	var url_parser_1 = __webpack_require__(261);
	var instruction_1 = __webpack_require__(262);
	// RouteMatch objects hold information about a match between a rule and a URL
	var RouteMatch = (function () {
	    function RouteMatch() {
	    }
	    return RouteMatch;
	}());
	exports.RouteMatch = RouteMatch;
	var PathMatch = (function (_super) {
	    __extends(PathMatch, _super);
	    function PathMatch(instruction, remaining, remainingAux) {
	        _super.call(this);
	        this.instruction = instruction;
	        this.remaining = remaining;
	        this.remainingAux = remainingAux;
	    }
	    return PathMatch;
	}(RouteMatch));
	exports.PathMatch = PathMatch;
	var RedirectMatch = (function (_super) {
	    __extends(RedirectMatch, _super);
	    function RedirectMatch(redirectTo, specificity) {
	        _super.call(this);
	        this.redirectTo = redirectTo;
	        this.specificity = specificity;
	    }
	    return RedirectMatch;
	}(RouteMatch));
	exports.RedirectMatch = RedirectMatch;
	var RedirectRule = (function () {
	    function RedirectRule(_pathRecognizer, redirectTo) {
	        this._pathRecognizer = _pathRecognizer;
	        this.redirectTo = redirectTo;
	        this.hash = this._pathRecognizer.hash;
	    }
	    Object.defineProperty(RedirectRule.prototype, "path", {
	        get: function () { return this._pathRecognizer.toString(); },
	        set: function (val) { throw new exceptions_1.BaseException('you cannot set the path of a RedirectRule directly'); },
	        enumerable: true,
	        configurable: true
	    });
	    /**
	     * Returns `null` or a `ParsedUrl` representing the new path to match
	     */
	    RedirectRule.prototype.recognize = function (beginningSegment) {
	        var match = null;
	        if (lang_1.isPresent(this._pathRecognizer.matchUrl(beginningSegment))) {
	            match = new RedirectMatch(this.redirectTo, this._pathRecognizer.specificity);
	        }
	        return promise_1.PromiseWrapper.resolve(match);
	    };
	    RedirectRule.prototype.generate = function (params) {
	        throw new exceptions_1.BaseException("Tried to generate a redirect.");
	    };
	    return RedirectRule;
	}());
	exports.RedirectRule = RedirectRule;
	// represents something like '/foo/:bar'
	var RouteRule = (function () {
	    // TODO: cache component instruction instances by params and by ParsedUrl instance
	    function RouteRule(_routePath, handler, _routeName) {
	        this._routePath = _routePath;
	        this.handler = handler;
	        this._routeName = _routeName;
	        this._cache = new collection_1.Map();
	        this.specificity = this._routePath.specificity;
	        this.hash = this._routePath.hash;
	        this.terminal = this._routePath.terminal;
	    }
	    Object.defineProperty(RouteRule.prototype, "path", {
	        get: function () { return this._routePath.toString(); },
	        set: function (val) { throw new exceptions_1.BaseException('you cannot set the path of a RouteRule directly'); },
	        enumerable: true,
	        configurable: true
	    });
	    RouteRule.prototype.recognize = function (beginningSegment) {
	        var _this = this;
	        var res = this._routePath.matchUrl(beginningSegment);
	        if (lang_1.isBlank(res)) {
	            return null;
	        }
	        return this.handler.resolveComponentType().then(function (_) {
	            var componentInstruction = _this._getInstruction(res.urlPath, res.urlParams, res.allParams);
	            return new PathMatch(componentInstruction, res.rest, res.auxiliary);
	        });
	    };
	    RouteRule.prototype.generate = function (params) {
	        var generated = this._routePath.generateUrl(params);
	        var urlPath = generated.urlPath;
	        var urlParams = generated.urlParams;
	        return this._getInstruction(urlPath, url_parser_1.convertUrlParamsToArray(urlParams), params);
	    };
	    RouteRule.prototype.generateComponentPathValues = function (params) {
	        return this._routePath.generateUrl(params);
	    };
	    RouteRule.prototype._getInstruction = function (urlPath, urlParams, params) {
	        if (lang_1.isBlank(this.handler.componentType)) {
	            throw new exceptions_1.BaseException("Tried to get instruction before the type was loaded.");
	        }
	        var hashKey = urlPath + '?' + urlParams.join('&');
	        if (this._cache.has(hashKey)) {
	            return this._cache.get(hashKey);
	        }
	        var instruction = new instruction_1.ComponentInstruction(urlPath, urlParams, this.handler.data, this.handler.componentType, this.terminal, this.specificity, params, this._routeName);
	        this._cache.set(hashKey, instruction);
	        return instruction;
	    };
	    return RouteRule;
	}());
	exports.RouteRule = RouteRule;


/***/ },
/* 261 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	function convertUrlParamsToArray(urlParams) {
	    var paramsArray = [];
	    if (lang_1.isBlank(urlParams)) {
	        return [];
	    }
	    collection_1.StringMapWrapper.forEach(urlParams, function (value, key) { paramsArray.push((value === true) ? key : key + '=' + value); });
	    return paramsArray;
	}
	exports.convertUrlParamsToArray = convertUrlParamsToArray;
	// Convert an object of url parameters into a string that can be used in an URL
	function serializeParams(urlParams, joiner) {
	    if (joiner === void 0) { joiner = '&'; }
	    return convertUrlParamsToArray(urlParams).join(joiner);
	}
	exports.serializeParams = serializeParams;
	/**
	 * This class represents a parsed URL
	 */
	var Url = (function () {
	    function Url(path, child, auxiliary, params) {
	        if (child === void 0) { child = null; }
	        if (auxiliary === void 0) { auxiliary = []; }
	        if (params === void 0) { params = {}; }
	        this.path = path;
	        this.child = child;
	        this.auxiliary = auxiliary;
	        this.params = params;
	    }
	    Url.prototype.toString = function () {
	        return this.path + this._matrixParamsToString() + this._auxToString() + this._childString();
	    };
	    Url.prototype.segmentToString = function () { return this.path + this._matrixParamsToString(); };
	    /** @internal */
	    Url.prototype._auxToString = function () {
	        return this.auxiliary.length > 0 ?
	            ('(' + this.auxiliary.map(function (sibling) { return sibling.toString(); }).join('//') + ')') :
	            '';
	    };
	    Url.prototype._matrixParamsToString = function () {
	        var paramString = serializeParams(this.params, ';');
	        if (paramString.length > 0) {
	            return ';' + paramString;
	        }
	        return '';
	    };
	    /** @internal */
	    Url.prototype._childString = function () { return lang_1.isPresent(this.child) ? ('/' + this.child.toString()) : ''; };
	    return Url;
	}());
	exports.Url = Url;
	var RootUrl = (function (_super) {
	    __extends(RootUrl, _super);
	    function RootUrl(path, child, auxiliary, params) {
	        if (child === void 0) { child = null; }
	        if (auxiliary === void 0) { auxiliary = []; }
	        if (params === void 0) { params = null; }
	        _super.call(this, path, child, auxiliary, params);
	    }
	    RootUrl.prototype.toString = function () {
	        return this.path + this._auxToString() + this._childString() + this._queryParamsToString();
	    };
	    RootUrl.prototype.segmentToString = function () { return this.path + this._queryParamsToString(); };
	    RootUrl.prototype._queryParamsToString = function () {
	        if (lang_1.isBlank(this.params)) {
	            return '';
	        }
	        return '?' + serializeParams(this.params);
	    };
	    return RootUrl;
	}(Url));
	exports.RootUrl = RootUrl;
	function pathSegmentsToUrl(pathSegments) {
	    var url = new Url(pathSegments[pathSegments.length - 1]);
	    for (var i = pathSegments.length - 2; i >= 0; i -= 1) {
	        url = new Url(pathSegments[i], url);
	    }
	    return url;
	}
	exports.pathSegmentsToUrl = pathSegmentsToUrl;
	var SEGMENT_RE = lang_1.RegExpWrapper.create('^[^\\/\\(\\)\\?;=&#]+');
	function matchUrlSegment(str) {
	    var match = lang_1.RegExpWrapper.firstMatch(SEGMENT_RE, str);
	    return lang_1.isPresent(match) ? match[0] : '';
	}
	var QUERY_PARAM_VALUE_RE = lang_1.RegExpWrapper.create('^[^\\(\\)\\?;&#]+');
	function matchUrlQueryParamValue(str) {
	    var match = lang_1.RegExpWrapper.firstMatch(QUERY_PARAM_VALUE_RE, str);
	    return lang_1.isPresent(match) ? match[0] : '';
	}
	var UrlParser = (function () {
	    function UrlParser() {
	    }
	    UrlParser.prototype.peekStartsWith = function (str) { return this._remaining.startsWith(str); };
	    UrlParser.prototype.capture = function (str) {
	        if (!this._remaining.startsWith(str)) {
	            throw new exceptions_1.BaseException("Expected \"" + str + "\".");
	        }
	        this._remaining = this._remaining.substring(str.length);
	    };
	    UrlParser.prototype.parse = function (url) {
	        this._remaining = url;
	        if (url == '' || url == '/') {
	            return new Url('');
	        }
	        return this.parseRoot();
	    };
	    // segment + (aux segments) + (query params)
	    UrlParser.prototype.parseRoot = function () {
	        if (this.peekStartsWith('/')) {
	            this.capture('/');
	        }
	        var path = matchUrlSegment(this._remaining);
	        this.capture(path);
	        var aux = [];
	        if (this.peekStartsWith('(')) {
	            aux = this.parseAuxiliaryRoutes();
	        }
	        if (this.peekStartsWith(';')) {
	            // TODO: should these params just be dropped?
	            this.parseMatrixParams();
	        }
	        var child = null;
	        if (this.peekStartsWith('/') && !this.peekStartsWith('//')) {
	            this.capture('/');
	            child = this.parseSegment();
	        }
	        var queryParams = null;
	        if (this.peekStartsWith('?')) {
	            queryParams = this.parseQueryParams();
	        }
	        return new RootUrl(path, child, aux, queryParams);
	    };
	    // segment + (matrix params) + (aux segments)
	    UrlParser.prototype.parseSegment = function () {
	        if (this._remaining.length == 0) {
	            return null;
	        }
	        if (this.peekStartsWith('/')) {
	            this.capture('/');
	        }
	        var path = matchUrlSegment(this._remaining);
	        this.capture(path);
	        var matrixParams = null;
	        if (this.peekStartsWith(';')) {
	            matrixParams = this.parseMatrixParams();
	        }
	        var aux = [];
	        if (this.peekStartsWith('(')) {
	            aux = this.parseAuxiliaryRoutes();
	        }
	        var child = null;
	        if (this.peekStartsWith('/') && !this.peekStartsWith('//')) {
	            this.capture('/');
	            child = this.parseSegment();
	        }
	        return new Url(path, child, aux, matrixParams);
	    };
	    UrlParser.prototype.parseQueryParams = function () {
	        var params = {};
	        this.capture('?');
	        this.parseQueryParam(params);
	        while (this._remaining.length > 0 && this.peekStartsWith('&')) {
	            this.capture('&');
	            this.parseQueryParam(params);
	        }
	        return params;
	    };
	    UrlParser.prototype.parseMatrixParams = function () {
	        var params = {};
	        while (this._remaining.length > 0 && this.peekStartsWith(';')) {
	            this.capture(';');
	            this.parseParam(params);
	        }
	        return params;
	    };
	    UrlParser.prototype.parseParam = function (params) {
	        var key = matchUrlSegment(this._remaining);
	        if (lang_1.isBlank(key)) {
	            return;
	        }
	        this.capture(key);
	        var value = true;
	        if (this.peekStartsWith('=')) {
	            this.capture('=');
	            var valueMatch = matchUrlSegment(this._remaining);
	            if (lang_1.isPresent(valueMatch)) {
	                value = valueMatch;
	                this.capture(value);
	            }
	        }
	        params[key] = value;
	    };
	    UrlParser.prototype.parseQueryParam = function (params) {
	        var key = matchUrlSegment(this._remaining);
	        if (lang_1.isBlank(key)) {
	            return;
	        }
	        this.capture(key);
	        var value = true;
	        if (this.peekStartsWith('=')) {
	            this.capture('=');
	            var valueMatch = matchUrlQueryParamValue(this._remaining);
	            if (lang_1.isPresent(valueMatch)) {
	                value = valueMatch;
	                this.capture(value);
	            }
	        }
	        params[key] = value;
	    };
	    UrlParser.prototype.parseAuxiliaryRoutes = function () {
	        var routes = [];
	        this.capture('(');
	        while (!this.peekStartsWith(')') && this._remaining.length > 0) {
	            routes.push(this.parseSegment());
	            if (this.peekStartsWith('//')) {
	                this.capture('//');
	            }
	        }
	        this.capture(')');
	        return routes;
	    };
	    return UrlParser;
	}());
	exports.UrlParser = UrlParser;
	exports.parser = new UrlParser();


/***/ },
/* 262 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	var async_1 = __webpack_require__(41);
	/**
	 * `RouteParams` is an immutable map of parameters for the given route
	 * based on the url matcher and optional parameters for that route.
	 *
	 * You can inject `RouteParams` into the constructor of a component to use it.
	 *
	 * ### Example
	 *
	 * ```
	 * import {Component} from 'angular2/core';
	 * import {bootstrap} from 'angular2/platform/browser';
	 * import {Router, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig, RouteParams} from
	 * 'angular2/router';
	 *
	 * @Component({directives: [ROUTER_DIRECTIVES]})
	 * @RouteConfig([
	 *  {path: '/user/:id', component: UserCmp, name: 'UserCmp'},
	 * ])
	 * class AppCmp {}
	 *
	 * @Component({ template: 'user: {{id}}' })
	 * class UserCmp {
	 *   id: string;
	 *   constructor(params: RouteParams) {
	 *     this.id = params.get('id');
	 *   }
	 * }
	 *
	 * bootstrap(AppCmp, ROUTER_PROVIDERS);
	 * ```
	 */
	var RouteParams = (function () {
	    function RouteParams(params) {
	        this.params = params;
	    }
	    RouteParams.prototype.get = function (param) { return lang_1.normalizeBlank(collection_1.StringMapWrapper.get(this.params, param)); };
	    return RouteParams;
	}());
	exports.RouteParams = RouteParams;
	/**
	 * `RouteData` is an immutable map of additional data you can configure in your {@link Route}.
	 *
	 * You can inject `RouteData` into the constructor of a component to use it.
	 *
	 * ### Example
	 *
	 * ```
	 * import {Component} from 'angular2/core';
	 * import {bootstrap} from 'angular2/platform/browser';
	 * import {Router, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig, RouteData} from
	 * 'angular2/router';
	 *
	 * @Component({directives: [ROUTER_DIRECTIVES]})
	 * @RouteConfig([
	 *  {path: '/user/:id', component: UserCmp, name: 'UserCmp', data: {isAdmin: true}},
	 * ])
	 * class AppCmp {}
	 *
	 * @Component({
	 *   ...,
	 *   template: 'user: {{isAdmin}}'
	 * })
	 * class UserCmp {
	 *   string: isAdmin;
	 *   constructor(data: RouteData) {
	 *     this.isAdmin = data.get('isAdmin');
	 *   }
	 * }
	 *
	 * bootstrap(AppCmp, ROUTER_PROVIDERS);
	 * ```
	 */
	var RouteData = (function () {
	    function RouteData(data) {
	        if (data === void 0) { data = {}; }
	        this.data = data;
	    }
	    RouteData.prototype.get = function (key) { return lang_1.normalizeBlank(collection_1.StringMapWrapper.get(this.data, key)); };
	    return RouteData;
	}());
	exports.RouteData = RouteData;
	exports.BLANK_ROUTE_DATA = new RouteData();
	/**
	 * `Instruction` is a tree of {@link ComponentInstruction}s with all the information needed
	 * to transition each component in the app to a given route, including all auxiliary routes.
	 *
	 * `Instruction`s can be created using {@link Router#generate}, and can be used to
	 * perform route changes with {@link Router#navigateByInstruction}.
	 *
	 * ### Example
	 *
	 * ```
	 * import {Component} from 'angular2/core';
	 * import {bootstrap} from 'angular2/platform/browser';
	 * import {Router, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig} from 'angular2/router';
	 *
	 * @Component({directives: [ROUTER_DIRECTIVES]})
	 * @RouteConfig([
	 *  {...},
	 * ])
	 * class AppCmp {
	 *   constructor(router: Router) {
	 *     var instruction = router.generate(['/MyRoute']);
	 *     router.navigateByInstruction(instruction);
	 *   }
	 * }
	 *
	 * bootstrap(AppCmp, ROUTER_PROVIDERS);
	 * ```
	 */
	var Instruction = (function () {
	    function Instruction(component, child, auxInstruction) {
	        this.component = component;
	        this.child = child;
	        this.auxInstruction = auxInstruction;
	    }
	    Object.defineProperty(Instruction.prototype, "urlPath", {
	        get: function () { return lang_1.isPresent(this.component) ? this.component.urlPath : ''; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(Instruction.prototype, "urlParams", {
	        get: function () { return lang_1.isPresent(this.component) ? this.component.urlParams : []; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(Instruction.prototype, "specificity", {
	        get: function () {
	            var total = '';
	            if (lang_1.isPresent(this.component)) {
	                total += this.component.specificity;
	            }
	            if (lang_1.isPresent(this.child)) {
	                total += this.child.specificity;
	            }
	            return total;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    /**
	     * converts the instruction into a URL string
	     */
	    Instruction.prototype.toRootUrl = function () { return this.toUrlPath() + this.toUrlQuery(); };
	    /** @internal */
	    Instruction.prototype._toNonRootUrl = function () {
	        return this._stringifyPathMatrixAuxPrefixed() +
	            (lang_1.isPresent(this.child) ? this.child._toNonRootUrl() : '');
	    };
	    Instruction.prototype.toUrlQuery = function () { return this.urlParams.length > 0 ? ('?' + this.urlParams.join('&')) : ''; };
	    /**
	     * Returns a new instruction that shares the state of the existing instruction, but with
	     * the given child {@link Instruction} replacing the existing child.
	     */
	    Instruction.prototype.replaceChild = function (child) {
	        return new ResolvedInstruction(this.component, child, this.auxInstruction);
	    };
	    /**
	     * If the final URL for the instruction is ``
	     */
	    Instruction.prototype.toUrlPath = function () {
	        return this.urlPath + this._stringifyAux() +
	            (lang_1.isPresent(this.child) ? this.child._toNonRootUrl() : '');
	    };
	    // default instructions override these
	    Instruction.prototype.toLinkUrl = function () {
	        return this.urlPath + this._stringifyAux() +
	            (lang_1.isPresent(this.child) ? this.child._toLinkUrl() : '') + this.toUrlQuery();
	    };
	    // this is the non-root version (called recursively)
	    /** @internal */
	    Instruction.prototype._toLinkUrl = function () {
	        return this._stringifyPathMatrixAuxPrefixed() +
	            (lang_1.isPresent(this.child) ? this.child._toLinkUrl() : '');
	    };
	    /** @internal */
	    Instruction.prototype._stringifyPathMatrixAuxPrefixed = function () {
	        var primary = this._stringifyPathMatrixAux();
	        if (primary.length > 0) {
	            primary = '/' + primary;
	        }
	        return primary;
	    };
	    /** @internal */
	    Instruction.prototype._stringifyMatrixParams = function () {
	        return this.urlParams.length > 0 ? (';' + this.urlParams.join(';')) : '';
	    };
	    /** @internal */
	    Instruction.prototype._stringifyPathMatrixAux = function () {
	        if (lang_1.isBlank(this.component)) {
	            return '';
	        }
	        return this.urlPath + this._stringifyMatrixParams() + this._stringifyAux();
	    };
	    /** @internal */
	    Instruction.prototype._stringifyAux = function () {
	        var routes = [];
	        collection_1.StringMapWrapper.forEach(this.auxInstruction, function (auxInstruction, _) {
	            routes.push(auxInstruction._stringifyPathMatrixAux());
	        });
	        if (routes.length > 0) {
	            return '(' + routes.join('//') + ')';
	        }
	        return '';
	    };
	    return Instruction;
	}());
	exports.Instruction = Instruction;
	/**
	 * a resolved instruction has an outlet instruction for itself, but maybe not for...
	 */
	var ResolvedInstruction = (function (_super) {
	    __extends(ResolvedInstruction, _super);
	    function ResolvedInstruction(component, child, auxInstruction) {
	        _super.call(this, component, child, auxInstruction);
	    }
	    ResolvedInstruction.prototype.resolveComponent = function () {
	        return async_1.PromiseWrapper.resolve(this.component);
	    };
	    return ResolvedInstruction;
	}(Instruction));
	exports.ResolvedInstruction = ResolvedInstruction;
	/**
	 * Represents a resolved default route
	 */
	var DefaultInstruction = (function (_super) {
	    __extends(DefaultInstruction, _super);
	    function DefaultInstruction(component, child) {
	        _super.call(this, component, child, {});
	    }
	    DefaultInstruction.prototype.toLinkUrl = function () { return ''; };
	    /** @internal */
	    DefaultInstruction.prototype._toLinkUrl = function () { return ''; };
	    return DefaultInstruction;
	}(ResolvedInstruction));
	exports.DefaultInstruction = DefaultInstruction;
	/**
	 * Represents a component that may need to do some redirection or lazy loading at a later time.
	 */
	var UnresolvedInstruction = (function (_super) {
	    __extends(UnresolvedInstruction, _super);
	    function UnresolvedInstruction(_resolver, _urlPath, _urlParams) {
	        if (_urlPath === void 0) { _urlPath = ''; }
	        if (_urlParams === void 0) { _urlParams = []; }
	        _super.call(this, null, null, {});
	        this._resolver = _resolver;
	        this._urlPath = _urlPath;
	        this._urlParams = _urlParams;
	    }
	    Object.defineProperty(UnresolvedInstruction.prototype, "urlPath", {
	        get: function () {
	            if (lang_1.isPresent(this.component)) {
	                return this.component.urlPath;
	            }
	            if (lang_1.isPresent(this._urlPath)) {
	                return this._urlPath;
	            }
	            return '';
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(UnresolvedInstruction.prototype, "urlParams", {
	        get: function () {
	            if (lang_1.isPresent(this.component)) {
	                return this.component.urlParams;
	            }
	            if (lang_1.isPresent(this._urlParams)) {
	                return this._urlParams;
	            }
	            return [];
	        },
	        enumerable: true,
	        configurable: true
	    });
	    UnresolvedInstruction.prototype.resolveComponent = function () {
	        var _this = this;
	        if (lang_1.isPresent(this.component)) {
	            return async_1.PromiseWrapper.resolve(this.component);
	        }
	        return this._resolver().then(function (instruction) {
	            _this.child = lang_1.isPresent(instruction) ? instruction.child : null;
	            return _this.component = lang_1.isPresent(instruction) ? instruction.component : null;
	        });
	    };
	    return UnresolvedInstruction;
	}(Instruction));
	exports.UnresolvedInstruction = UnresolvedInstruction;
	var RedirectInstruction = (function (_super) {
	    __extends(RedirectInstruction, _super);
	    function RedirectInstruction(component, child, auxInstruction, _specificity) {
	        _super.call(this, component, child, auxInstruction);
	        this._specificity = _specificity;
	    }
	    Object.defineProperty(RedirectInstruction.prototype, "specificity", {
	        get: function () { return this._specificity; },
	        enumerable: true,
	        configurable: true
	    });
	    return RedirectInstruction;
	}(ResolvedInstruction));
	exports.RedirectInstruction = RedirectInstruction;
	/**
	 * A `ComponentInstruction` represents the route state for a single component.
	 *
	 * `ComponentInstructions` is a public API. Instances of `ComponentInstruction` are passed
	 * to route lifecycle hooks, like {@link CanActivate}.
	 *
	 * `ComponentInstruction`s are [hash consed](https://en.wikipedia.org/wiki/Hash_consing). You should
	 * never construct one yourself with "new." Instead, rely on router's internal recognizer to
	 * construct `ComponentInstruction`s.
	 *
	 * You should not modify this object. It should be treated as immutable.
	 */
	var ComponentInstruction = (function () {
	    /**
	     * @internal
	     */
	    function ComponentInstruction(urlPath, urlParams, data, componentType, terminal, specificity, params, routeName) {
	        if (params === void 0) { params = null; }
	        this.urlPath = urlPath;
	        this.urlParams = urlParams;
	        this.componentType = componentType;
	        this.terminal = terminal;
	        this.specificity = specificity;
	        this.params = params;
	        this.routeName = routeName;
	        this.reuse = false;
	        this.routeData = lang_1.isPresent(data) ? data : exports.BLANK_ROUTE_DATA;
	    }
	    return ComponentInstruction;
	}());
	exports.ComponentInstruction = ComponentInstruction;


/***/ },
/* 263 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var collection_1 = __webpack_require__(15);
	var async_1 = __webpack_require__(41);
	var rules_1 = __webpack_require__(260);
	var route_config_impl_1 = __webpack_require__(259);
	var async_route_handler_1 = __webpack_require__(264);
	var sync_route_handler_1 = __webpack_require__(265);
	var param_route_path_1 = __webpack_require__(266);
	var regex_route_path_1 = __webpack_require__(269);
	/**
	 * A `RuleSet` is responsible for recognizing routes for a particular component.
	 * It is consumed by `RouteRegistry`, which knows how to recognize an entire hierarchy of
	 * components.
	 */
	var RuleSet = (function () {
	    function RuleSet() {
	        this.rulesByName = new collection_1.Map();
	        // map from name to rule
	        this.auxRulesByName = new collection_1.Map();
	        // map from starting path to rule
	        this.auxRulesByPath = new collection_1.Map();
	        // TODO: optimize this into a trie
	        this.rules = [];
	        // the rule to use automatically when recognizing or generating from this rule set
	        this.defaultRule = null;
	    }
	    /**
	     * Configure additional rules in this rule set from a route definition
	     * @returns {boolean} true if the config is terminal
	     */
	    RuleSet.prototype.config = function (config) {
	        var handler;
	        if (lang_1.isPresent(config.name) && config.name[0].toUpperCase() != config.name[0]) {
	            var suggestedName = config.name[0].toUpperCase() + config.name.substring(1);
	            throw new exceptions_1.BaseException("Route \"" + config.path + "\" with name \"" + config.name + "\" does not begin with an uppercase letter. Route names should be CamelCase like \"" + suggestedName + "\".");
	        }
	        if (config instanceof route_config_impl_1.AuxRoute) {
	            handler = new sync_route_handler_1.SyncRouteHandler(config.component, config.data);
	            var routePath_1 = this._getRoutePath(config);
	            var auxRule = new rules_1.RouteRule(routePath_1, handler, config.name);
	            this.auxRulesByPath.set(routePath_1.toString(), auxRule);
	            if (lang_1.isPresent(config.name)) {
	                this.auxRulesByName.set(config.name, auxRule);
	            }
	            return auxRule.terminal;
	        }
	        var useAsDefault = false;
	        if (config instanceof route_config_impl_1.Redirect) {
	            var routePath_2 = this._getRoutePath(config);
	            var redirector = new rules_1.RedirectRule(routePath_2, config.redirectTo);
	            this._assertNoHashCollision(redirector.hash, config.path);
	            this.rules.push(redirector);
	            return true;
	        }
	        if (config instanceof route_config_impl_1.Route) {
	            handler = new sync_route_handler_1.SyncRouteHandler(config.component, config.data);
	            useAsDefault = lang_1.isPresent(config.useAsDefault) && config.useAsDefault;
	        }
	        else if (config instanceof route_config_impl_1.AsyncRoute) {
	            handler = new async_route_handler_1.AsyncRouteHandler(config.loader, config.data);
	            useAsDefault = lang_1.isPresent(config.useAsDefault) && config.useAsDefault;
	        }
	        var routePath = this._getRoutePath(config);
	        var newRule = new rules_1.RouteRule(routePath, handler, config.name);
	        this._assertNoHashCollision(newRule.hash, config.path);
	        if (useAsDefault) {
	            if (lang_1.isPresent(this.defaultRule)) {
	                throw new exceptions_1.BaseException("Only one route can be default");
	            }
	            this.defaultRule = newRule;
	        }
	        this.rules.push(newRule);
	        if (lang_1.isPresent(config.name)) {
	            this.rulesByName.set(config.name, newRule);
	        }
	        return newRule.terminal;
	    };
	    /**
	     * Given a URL, returns a list of `RouteMatch`es, which are partial recognitions for some route.
	     */
	    RuleSet.prototype.recognize = function (urlParse) {
	        var solutions = [];
	        this.rules.forEach(function (routeRecognizer) {
	            var pathMatch = routeRecognizer.recognize(urlParse);
	            if (lang_1.isPresent(pathMatch)) {
	                solutions.push(pathMatch);
	            }
	        });
	        // handle cases where we are routing just to an aux route
	        if (solutions.length == 0 && lang_1.isPresent(urlParse) && urlParse.auxiliary.length > 0) {
	            return [async_1.PromiseWrapper.resolve(new rules_1.PathMatch(null, null, urlParse.auxiliary))];
	        }
	        return solutions;
	    };
	    RuleSet.prototype.recognizeAuxiliary = function (urlParse) {
	        var routeRecognizer = this.auxRulesByPath.get(urlParse.path);
	        if (lang_1.isPresent(routeRecognizer)) {
	            return [routeRecognizer.recognize(urlParse)];
	        }
	        return [async_1.PromiseWrapper.resolve(null)];
	    };
	    RuleSet.prototype.hasRoute = function (name) { return this.rulesByName.has(name); };
	    RuleSet.prototype.componentLoaded = function (name) {
	        return this.hasRoute(name) && lang_1.isPresent(this.rulesByName.get(name).handler.componentType);
	    };
	    RuleSet.prototype.loadComponent = function (name) {
	        return this.rulesByName.get(name).handler.resolveComponentType();
	    };
	    RuleSet.prototype.generate = function (name, params) {
	        var rule = this.rulesByName.get(name);
	        if (lang_1.isBlank(rule)) {
	            return null;
	        }
	        return rule.generate(params);
	    };
	    RuleSet.prototype.generateAuxiliary = function (name, params) {
	        var rule = this.auxRulesByName.get(name);
	        if (lang_1.isBlank(rule)) {
	            return null;
	        }
	        return rule.generate(params);
	    };
	    RuleSet.prototype._assertNoHashCollision = function (hash, path) {
	        this.rules.forEach(function (rule) {
	            if (hash == rule.hash) {
	                throw new exceptions_1.BaseException("Configuration '" + path + "' conflicts with existing route '" + rule.path + "'");
	            }
	        });
	    };
	    RuleSet.prototype._getRoutePath = function (config) {
	        if (lang_1.isPresent(config.regex)) {
	            if (lang_1.isFunction(config.serializer)) {
	                return new regex_route_path_1.RegexRoutePath(config.regex, config.serializer);
	            }
	            else {
	                throw new exceptions_1.BaseException("Route provides a regex property, '" + config.regex + "', but no serializer property");
	            }
	        }
	        if (lang_1.isPresent(config.path)) {
	            // Auxiliary routes do not have a slash at the start
	            var path = (config instanceof route_config_impl_1.AuxRoute && config.path.startsWith('/')) ?
	                config.path.substring(1) :
	                config.path;
	            return new param_route_path_1.ParamRoutePath(path);
	        }
	        throw new exceptions_1.BaseException('Route must provide either a path or regex property');
	    };
	    return RuleSet;
	}());
	exports.RuleSet = RuleSet;


/***/ },
/* 264 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var instruction_1 = __webpack_require__(262);
	var AsyncRouteHandler = (function () {
	    function AsyncRouteHandler(_loader, data) {
	        if (data === void 0) { data = null; }
	        this._loader = _loader;
	        /** @internal */
	        this._resolvedComponent = null;
	        this.data = lang_1.isPresent(data) ? new instruction_1.RouteData(data) : instruction_1.BLANK_ROUTE_DATA;
	    }
	    AsyncRouteHandler.prototype.resolveComponentType = function () {
	        var _this = this;
	        if (lang_1.isPresent(this._resolvedComponent)) {
	            return this._resolvedComponent;
	        }
	        return this._resolvedComponent = this._loader().then(function (componentType) {
	            _this.componentType = componentType;
	            return componentType;
	        });
	    };
	    return AsyncRouteHandler;
	}());
	exports.AsyncRouteHandler = AsyncRouteHandler;


/***/ },
/* 265 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var async_1 = __webpack_require__(41);
	var lang_1 = __webpack_require__(5);
	var instruction_1 = __webpack_require__(262);
	var SyncRouteHandler = (function () {
	    function SyncRouteHandler(componentType, data) {
	        this.componentType = componentType;
	        /** @internal */
	        this._resolvedComponent = null;
	        this._resolvedComponent = async_1.PromiseWrapper.resolve(componentType);
	        this.data = lang_1.isPresent(data) ? new instruction_1.RouteData(data) : instruction_1.BLANK_ROUTE_DATA;
	    }
	    SyncRouteHandler.prototype.resolveComponentType = function () { return this._resolvedComponent; };
	    return SyncRouteHandler;
	}());
	exports.SyncRouteHandler = SyncRouteHandler;


/***/ },
/* 266 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	var collection_1 = __webpack_require__(15);
	var utils_1 = __webpack_require__(267);
	var url_parser_1 = __webpack_require__(261);
	var route_path_1 = __webpack_require__(268);
	/**
	 * Identified by a `...` URL segment. This indicates that the
	 * Route will continue to be matched by child `Router`s.
	 */
	var ContinuationPathSegment = (function () {
	    function ContinuationPathSegment() {
	        this.name = '';
	        this.specificity = '';
	        this.hash = '...';
	    }
	    ContinuationPathSegment.prototype.generate = function (params) { return ''; };
	    ContinuationPathSegment.prototype.match = function (path) { return true; };
	    return ContinuationPathSegment;
	}());
	/**
	 * Identified by a string not starting with a `:` or `*`.
	 * Only matches the URL segments that equal the segment path
	 */
	var StaticPathSegment = (function () {
	    function StaticPathSegment(path) {
	        this.path = path;
	        this.name = '';
	        this.specificity = '2';
	        this.hash = path;
	    }
	    StaticPathSegment.prototype.match = function (path) { return path == this.path; };
	    StaticPathSegment.prototype.generate = function (params) { return this.path; };
	    return StaticPathSegment;
	}());
	/**
	 * Identified by a string starting with `:`. Indicates a segment
	 * that can contain a value that will be extracted and provided to
	 * a matching `Instruction`.
	 */
	var DynamicPathSegment = (function () {
	    function DynamicPathSegment(name) {
	        this.name = name;
	        this.specificity = '1';
	        this.hash = ':';
	    }
	    DynamicPathSegment.prototype.match = function (path) { return path.length > 0; };
	    DynamicPathSegment.prototype.generate = function (params) {
	        if (!collection_1.StringMapWrapper.contains(params.map, this.name)) {
	            throw new exceptions_1.BaseException("Route generator for '" + this.name + "' was not included in parameters passed.");
	        }
	        return encodeDynamicSegment(utils_1.normalizeString(params.get(this.name)));
	    };
	    DynamicPathSegment.paramMatcher = /^:([^\/]+)$/g;
	    return DynamicPathSegment;
	}());
	/**
	 * Identified by a string starting with `*` Indicates that all the following
	 * segments match this route and that the value of these segments should
	 * be provided to a matching `Instruction`.
	 */
	var StarPathSegment = (function () {
	    function StarPathSegment(name) {
	        this.name = name;
	        this.specificity = '0';
	        this.hash = '*';
	    }
	    StarPathSegment.prototype.match = function (path) { return true; };
	    StarPathSegment.prototype.generate = function (params) { return utils_1.normalizeString(params.get(this.name)); };
	    StarPathSegment.wildcardMatcher = /^\*([^\/]+)$/g;
	    return StarPathSegment;
	}());
	/**
	 * Parses a URL string using a given matcher DSL, and generates URLs from param maps
	 */
	var ParamRoutePath = (function () {
	    /**
	     * Takes a string representing the matcher DSL
	     */
	    function ParamRoutePath(routePath) {
	        this.routePath = routePath;
	        this.terminal = true;
	        this._assertValidPath(routePath);
	        this._parsePathString(routePath);
	        this.specificity = this._calculateSpecificity();
	        this.hash = this._calculateHash();
	        var lastSegment = this._segments[this._segments.length - 1];
	        this.terminal = !(lastSegment instanceof ContinuationPathSegment);
	    }
	    ParamRoutePath.prototype.matchUrl = function (url) {
	        var nextUrlSegment = url;
	        var currentUrlSegment;
	        var positionalParams = {};
	        var captured = [];
	        for (var i = 0; i < this._segments.length; i += 1) {
	            var pathSegment = this._segments[i];
	            currentUrlSegment = nextUrlSegment;
	            if (pathSegment instanceof ContinuationPathSegment) {
	                break;
	            }
	            if (lang_1.isPresent(currentUrlSegment)) {
	                // the star segment consumes all of the remaining URL, including matrix params
	                if (pathSegment instanceof StarPathSegment) {
	                    positionalParams[pathSegment.name] = currentUrlSegment.toString();
	                    captured.push(currentUrlSegment.toString());
	                    nextUrlSegment = null;
	                    break;
	                }
	                captured.push(currentUrlSegment.path);
	                if (pathSegment instanceof DynamicPathSegment) {
	                    positionalParams[pathSegment.name] = decodeDynamicSegment(currentUrlSegment.path);
	                }
	                else if (!pathSegment.match(currentUrlSegment.path)) {
	                    return null;
	                }
	                nextUrlSegment = currentUrlSegment.child;
	            }
	            else if (!pathSegment.match('')) {
	                return null;
	            }
	        }
	        if (this.terminal && lang_1.isPresent(nextUrlSegment)) {
	            return null;
	        }
	        var urlPath = captured.join('/');
	        var auxiliary = [];
	        var urlParams = [];
	        var allParams = positionalParams;
	        if (lang_1.isPresent(currentUrlSegment)) {
	            // If this is the root component, read query params. Otherwise, read matrix params.
	            var paramsSegment = url instanceof url_parser_1.RootUrl ? url : currentUrlSegment;
	            if (lang_1.isPresent(paramsSegment.params)) {
	                allParams = collection_1.StringMapWrapper.merge(paramsSegment.params, positionalParams);
	                urlParams = url_parser_1.convertUrlParamsToArray(paramsSegment.params);
	            }
	            else {
	                allParams = positionalParams;
	            }
	            auxiliary = currentUrlSegment.auxiliary;
	        }
	        return new route_path_1.MatchedUrl(urlPath, urlParams, allParams, auxiliary, nextUrlSegment);
	    };
	    ParamRoutePath.prototype.generateUrl = function (params) {
	        var paramTokens = new utils_1.TouchMap(params);
	        var path = [];
	        for (var i = 0; i < this._segments.length; i++) {
	            var segment = this._segments[i];
	            if (!(segment instanceof ContinuationPathSegment)) {
	                path.push(segment.generate(paramTokens));
	            }
	        }
	        var urlPath = path.join('/');
	        var nonPositionalParams = paramTokens.getUnused();
	        var urlParams = nonPositionalParams;
	        return new route_path_1.GeneratedUrl(urlPath, urlParams);
	    };
	    ParamRoutePath.prototype.toString = function () { return this.routePath; };
	    ParamRoutePath.prototype._parsePathString = function (routePath) {
	        // normalize route as not starting with a "/". Recognition will
	        // also normalize.
	        if (routePath.startsWith("/")) {
	            routePath = routePath.substring(1);
	        }
	        var segmentStrings = routePath.split('/');
	        this._segments = [];
	        var limit = segmentStrings.length - 1;
	        for (var i = 0; i <= limit; i++) {
	            var segment = segmentStrings[i], match;
	            if (lang_1.isPresent(match = lang_1.RegExpWrapper.firstMatch(DynamicPathSegment.paramMatcher, segment))) {
	                this._segments.push(new DynamicPathSegment(match[1]));
	            }
	            else if (lang_1.isPresent(match = lang_1.RegExpWrapper.firstMatch(StarPathSegment.wildcardMatcher, segment))) {
	                this._segments.push(new StarPathSegment(match[1]));
	            }
	            else if (segment == '...') {
	                if (i < limit) {
	                    throw new exceptions_1.BaseException("Unexpected \"...\" before the end of the path for \"" + routePath + "\".");
	                }
	                this._segments.push(new ContinuationPathSegment());
	            }
	            else {
	                this._segments.push(new StaticPathSegment(segment));
	            }
	        }
	    };
	    ParamRoutePath.prototype._calculateSpecificity = function () {
	        // The "specificity" of a path is used to determine which route is used when multiple routes
	        // match
	        // a URL. Static segments (like "/foo") are the most specific, followed by dynamic segments
	        // (like
	        // "/:id"). Star segments add no specificity. Segments at the start of the path are more
	        // specific
	        // than proceeding ones.
	        //
	        // The code below uses place values to combine the different types of segments into a single
	        // string that we can sort later. Each static segment is marked as a specificity of "2," each
	        // dynamic segment is worth "1" specificity, and stars are worth "0" specificity.
	        var i, length = this._segments.length, specificity;
	        if (length == 0) {
	            // a single slash (or "empty segment" is as specific as a static segment
	            specificity += '2';
	        }
	        else {
	            specificity = '';
	            for (i = 0; i < length; i++) {
	                specificity += this._segments[i].specificity;
	            }
	        }
	        return specificity;
	    };
	    ParamRoutePath.prototype._calculateHash = function () {
	        // this function is used to determine whether a route config path like `/foo/:id` collides with
	        // `/foo/:name`
	        var i, length = this._segments.length;
	        var hashParts = [];
	        for (i = 0; i < length; i++) {
	            hashParts.push(this._segments[i].hash);
	        }
	        return hashParts.join('/');
	    };
	    ParamRoutePath.prototype._assertValidPath = function (path) {
	        if (lang_1.StringWrapper.contains(path, '#')) {
	            throw new exceptions_1.BaseException("Path \"" + path + "\" should not include \"#\". Use \"HashLocationStrategy\" instead.");
	        }
	        var illegalCharacter = lang_1.RegExpWrapper.firstMatch(ParamRoutePath.RESERVED_CHARS, path);
	        if (lang_1.isPresent(illegalCharacter)) {
	            throw new exceptions_1.BaseException("Path \"" + path + "\" contains \"" + illegalCharacter[0] + "\" which is not allowed in a route config.");
	        }
	    };
	    ParamRoutePath.RESERVED_CHARS = lang_1.RegExpWrapper.create('//|\\(|\\)|;|\\?|=');
	    return ParamRoutePath;
	}());
	exports.ParamRoutePath = ParamRoutePath;
	var REGEXP_PERCENT = /%/g;
	var REGEXP_SLASH = /\//g;
	var REGEXP_OPEN_PARENT = /\(/g;
	var REGEXP_CLOSE_PARENT = /\)/g;
	var REGEXP_SEMICOLON = /;/g;
	function encodeDynamicSegment(value) {
	    if (lang_1.isBlank(value)) {
	        return null;
	    }
	    value = lang_1.StringWrapper.replaceAll(value, REGEXP_PERCENT, '%25');
	    value = lang_1.StringWrapper.replaceAll(value, REGEXP_SLASH, '%2F');
	    value = lang_1.StringWrapper.replaceAll(value, REGEXP_OPEN_PARENT, '%28');
	    value = lang_1.StringWrapper.replaceAll(value, REGEXP_CLOSE_PARENT, '%29');
	    value = lang_1.StringWrapper.replaceAll(value, REGEXP_SEMICOLON, '%3B');
	    return value;
	}
	var REGEXP_ENC_SEMICOLON = /%3B/ig;
	var REGEXP_ENC_CLOSE_PARENT = /%29/ig;
	var REGEXP_ENC_OPEN_PARENT = /%28/ig;
	var REGEXP_ENC_SLASH = /%2F/ig;
	var REGEXP_ENC_PERCENT = /%25/ig;
	function decodeDynamicSegment(value) {
	    if (lang_1.isBlank(value)) {
	        return null;
	    }
	    value = lang_1.StringWrapper.replaceAll(value, REGEXP_ENC_SEMICOLON, ';');
	    value = lang_1.StringWrapper.replaceAll(value, REGEXP_ENC_CLOSE_PARENT, ')');
	    value = lang_1.StringWrapper.replaceAll(value, REGEXP_ENC_OPEN_PARENT, '(');
	    value = lang_1.StringWrapper.replaceAll(value, REGEXP_ENC_SLASH, '/');
	    value = lang_1.StringWrapper.replaceAll(value, REGEXP_ENC_PERCENT, '%');
	    return value;
	}


/***/ },
/* 267 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var collection_1 = __webpack_require__(15);
	var TouchMap = (function () {
	    function TouchMap(map) {
	        var _this = this;
	        this.map = {};
	        this.keys = {};
	        if (lang_1.isPresent(map)) {
	            collection_1.StringMapWrapper.forEach(map, function (value, key) {
	                _this.map[key] = lang_1.isPresent(value) ? value.toString() : null;
	                _this.keys[key] = true;
	            });
	        }
	    }
	    TouchMap.prototype.get = function (key) {
	        collection_1.StringMapWrapper.delete(this.keys, key);
	        return this.map[key];
	    };
	    TouchMap.prototype.getUnused = function () {
	        var _this = this;
	        var unused = {};
	        var keys = collection_1.StringMapWrapper.keys(this.keys);
	        keys.forEach(function (key) { return unused[key] = collection_1.StringMapWrapper.get(_this.map, key); });
	        return unused;
	    };
	    return TouchMap;
	}());
	exports.TouchMap = TouchMap;
	function normalizeString(obj) {
	    if (lang_1.isBlank(obj)) {
	        return null;
	    }
	    else {
	        return obj.toString();
	    }
	}
	exports.normalizeString = normalizeString;


/***/ },
/* 268 */
/***/ function(module, exports) {

	"use strict";
	var MatchedUrl = (function () {
	    function MatchedUrl(urlPath, urlParams, allParams, auxiliary, rest) {
	        this.urlPath = urlPath;
	        this.urlParams = urlParams;
	        this.allParams = allParams;
	        this.auxiliary = auxiliary;
	        this.rest = rest;
	    }
	    return MatchedUrl;
	}());
	exports.MatchedUrl = MatchedUrl;
	var GeneratedUrl = (function () {
	    function GeneratedUrl(urlPath, urlParams) {
	        this.urlPath = urlPath;
	        this.urlParams = urlParams;
	    }
	    return GeneratedUrl;
	}());
	exports.GeneratedUrl = GeneratedUrl;


/***/ },
/* 269 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var route_path_1 = __webpack_require__(268);
	var RegexRoutePath = (function () {
	    function RegexRoutePath(_reString, _serializer) {
	        this._reString = _reString;
	        this._serializer = _serializer;
	        this.terminal = true;
	        this.specificity = '2';
	        this.hash = this._reString;
	        this._regex = lang_1.RegExpWrapper.create(this._reString);
	    }
	    RegexRoutePath.prototype.matchUrl = function (url) {
	        var urlPath = url.toString();
	        var params = {};
	        var matcher = lang_1.RegExpWrapper.matcher(this._regex, urlPath);
	        var match = lang_1.RegExpMatcherWrapper.next(matcher);
	        if (lang_1.isBlank(match)) {
	            return null;
	        }
	        for (var i = 0; i < match.length; i += 1) {
	            params[i.toString()] = match[i];
	        }
	        return new route_path_1.MatchedUrl(urlPath, [], params, [], null);
	    };
	    RegexRoutePath.prototype.generateUrl = function (params) { return this._serializer(params); };
	    RegexRoutePath.prototype.toString = function () { return this._reString; };
	    return RegexRoutePath;
	}());
	exports.RegexRoutePath = RegexRoutePath;


/***/ },
/* 270 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var route_config_decorator_1 = __webpack_require__(271);
	var lang_1 = __webpack_require__(5);
	var exceptions_1 = __webpack_require__(12);
	/**
	 * Given a JS Object that represents a route config, returns a corresponding Route, AsyncRoute,
	 * AuxRoute or Redirect object.
	 *
	 * Also wraps an AsyncRoute's loader function to add the loaded component's route config to the
	 * `RouteRegistry`.
	 */
	function normalizeRouteConfig(config, registry) {
	    if (config instanceof route_config_decorator_1.AsyncRoute) {
	        var wrappedLoader = wrapLoaderToReconfigureRegistry(config.loader, registry);
	        return new route_config_decorator_1.AsyncRoute({
	            path: config.path,
	            loader: wrappedLoader,
	            name: config.name,
	            data: config.data,
	            useAsDefault: config.useAsDefault
	        });
	    }
	    if (config instanceof route_config_decorator_1.Route || config instanceof route_config_decorator_1.Redirect || config instanceof route_config_decorator_1.AuxRoute) {
	        return config;
	    }
	    if ((+!!config.component) + (+!!config.redirectTo) + (+!!config.loader) != 1) {
	        throw new exceptions_1.BaseException("Route config should contain exactly one \"component\", \"loader\", or \"redirectTo\" property.");
	    }
	    if (config.as && config.name) {
	        throw new exceptions_1.BaseException("Route config should contain exactly one \"as\" or \"name\" property.");
	    }
	    if (config.as) {
	        config.name = config.as;
	    }
	    if (config.loader) {
	        var wrappedLoader = wrapLoaderToReconfigureRegistry(config.loader, registry);
	        return new route_config_decorator_1.AsyncRoute({
	            path: config.path,
	            loader: wrappedLoader,
	            name: config.name,
	            data: config.data,
	            useAsDefault: config.useAsDefault
	        });
	    }
	    if (config.aux) {
	        return new route_config_decorator_1.AuxRoute({ path: config.aux, component: config.component, name: config.name });
	    }
	    if (config.component) {
	        if (typeof config.component == 'object') {
	            var componentDefinitionObject = config.component;
	            if (componentDefinitionObject.type == 'constructor') {
	                return new route_config_decorator_1.Route({
	                    path: config.path,
	                    component: componentDefinitionObject.constructor,
	                    name: config.name,
	                    data: config.data,
	                    useAsDefault: config.useAsDefault
	                });
	            }
	            else if (componentDefinitionObject.type == 'loader') {
	                return new route_config_decorator_1.AsyncRoute({
	                    path: config.path,
	                    loader: componentDefinitionObject.loader,
	                    name: config.name,
	                    data: config.data,
	                    useAsDefault: config.useAsDefault
	                });
	            }
	            else {
	                throw new exceptions_1.BaseException("Invalid component type \"" + componentDefinitionObject.type + "\". Valid types are \"constructor\" and \"loader\".");
	            }
	        }
	        return new route_config_decorator_1.Route(config);
	    }
	    if (config.redirectTo) {
	        return new route_config_decorator_1.Redirect({ path: config.path, redirectTo: config.redirectTo });
	    }
	    return config;
	}
	exports.normalizeRouteConfig = normalizeRouteConfig;
	function wrapLoaderToReconfigureRegistry(loader, registry) {
	    return function () {
	        return loader().then(function (componentType) {
	            registry.configFromComponent(componentType);
	            return componentType;
	        });
	    };
	}
	function assertComponentExists(component, path) {
	    if (!lang_1.isType(component)) {
	        throw new exceptions_1.BaseException("Component for route \"" + path + "\" is not defined, or is not a class.");
	    }
	}
	exports.assertComponentExists = assertComponentExists;


/***/ },
/* 271 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var route_config_impl_1 = __webpack_require__(259);
	var decorators_1 = __webpack_require__(9);
	var route_config_impl_2 = __webpack_require__(259);
	exports.Route = route_config_impl_2.Route;
	exports.Redirect = route_config_impl_2.Redirect;
	exports.AuxRoute = route_config_impl_2.AuxRoute;
	exports.AsyncRoute = route_config_impl_2.AsyncRoute;
	// Copied from RouteConfig in route_config_impl.
	/**
	 * The `RouteConfig` decorator defines routes for a given component.
	 *
	 * It takes an array of {@link RouteDefinition}s.
	 */
	exports.RouteConfig = decorators_1.makeDecorator(route_config_impl_1.RouteConfig);


/***/ },
/* 272 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var lang_1 = __webpack_require__(5);
	var lifecycle_annotations_impl_1 = __webpack_require__(273);
	var reflection_1 = __webpack_require__(18);
	function hasLifecycleHook(e, type) {
	    if (!(type instanceof lang_1.Type))
	        return false;
	    return e.name in type.prototype;
	}
	exports.hasLifecycleHook = hasLifecycleHook;
	function getCanActivateHook(type) {
	    var annotations = reflection_1.reflector.annotations(type);
	    for (var i = 0; i < annotations.length; i += 1) {
	        var annotation = annotations[i];
	        if (annotation instanceof lifecycle_annotations_impl_1.CanActivate) {
	            return annotation.fn;
	        }
	    }
	    return null;
	}
	exports.getCanActivateHook = getCanActivateHook;


/***/ },
/* 273 */
/***/ function(module, exports) {

	"use strict";
	/* @ts2dart_const */
	var RouteLifecycleHook = (function () {
	    function RouteLifecycleHook(name) {
	        this.name = name;
	    }
	    return RouteLifecycleHook;
	}());
	exports.RouteLifecycleHook = RouteLifecycleHook;
	/* @ts2dart_const */
	var CanActivate = (function () {
	    function CanActivate(fn) {
	        this.fn = fn;
	    }
	    return CanActivate;
	}());
	exports.CanActivate = CanActivate;
	exports.routerCanReuse = 
	/*@ts2dart_const*/ new RouteLifecycleHook("routerCanReuse");
	exports.routerCanDeactivate = 
	/*@ts2dart_const*/ new RouteLifecycleHook("routerCanDeactivate");
	exports.routerOnActivate = 
	/*@ts2dart_const*/ new RouteLifecycleHook("routerOnActivate");
	exports.routerOnReuse = 
	/*@ts2dart_const*/ new RouteLifecycleHook("routerOnReuse");
	exports.routerOnDeactivate = 
	/*@ts2dart_const*/ new RouteLifecycleHook("routerOnDeactivate");


/***/ },
/* 274 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var __param = (this && this.__param) || function (paramIndex, decorator) {
	    return function (target, key) { decorator(target, key, paramIndex); }
	};
	var async_1 = __webpack_require__(41);
	var collection_1 = __webpack_require__(15);
	var lang_1 = __webpack_require__(5);
	var core_1 = __webpack_require__(2);
	var routerMod = __webpack_require__(250);
	var instruction_1 = __webpack_require__(262);
	var hookMod = __webpack_require__(275);
	var route_lifecycle_reflector_1 = __webpack_require__(272);
	var _resolveToTrue = async_1.PromiseWrapper.resolve(true);
	/**
	 * A router outlet is a placeholder that Angular dynamically fills based on the application's route.
	 *
	 * ## Use
	 *
	 * ```
	 * <router-outlet></router-outlet>
	 * ```
	 */
	var RouterOutlet = (function () {
	    function RouterOutlet(_viewContainerRef, _loader, _parentRouter, nameAttr) {
	        this._viewContainerRef = _viewContainerRef;
	        this._loader = _loader;
	        this._parentRouter = _parentRouter;
	        this.name = null;
	        this._componentRef = null;
	        this._currentInstruction = null;
	        this.activateEvents = new async_1.EventEmitter();
	        if (lang_1.isPresent(nameAttr)) {
	            this.name = nameAttr;
	            this._parentRouter.registerAuxOutlet(this);
	        }
	        else {
	            this._parentRouter.registerPrimaryOutlet(this);
	        }
	    }
	    /**
	     * Called by the Router to instantiate a new component during the commit phase of a navigation.
	     * This method in turn is responsible for calling the `routerOnActivate` hook of its child.
	     */
	    RouterOutlet.prototype.activate = function (nextInstruction) {
	        var _this = this;
	        var previousInstruction = this._currentInstruction;
	        this._currentInstruction = nextInstruction;
	        var componentType = nextInstruction.componentType;
	        var childRouter = this._parentRouter.childRouter(componentType);
	        var providers = core_1.ReflectiveInjector.resolve([
	            core_1.provide(instruction_1.RouteData, { useValue: nextInstruction.routeData }),
	            core_1.provide(instruction_1.RouteParams, { useValue: new instruction_1.RouteParams(nextInstruction.params) }),
	            core_1.provide(routerMod.Router, { useValue: childRouter })
	        ]);
	        this._componentRef =
	            this._loader.loadNextToLocation(componentType, this._viewContainerRef, providers);
	        return this._componentRef.then(function (componentRef) {
	            _this.activateEvents.emit(componentRef.instance);
	            if (route_lifecycle_reflector_1.hasLifecycleHook(hookMod.routerOnActivate, componentType)) {
	                return _this._componentRef.then(function (ref) {
	                    return ref.instance.routerOnActivate(nextInstruction, previousInstruction);
	                });
	            }
	            else {
	                return componentRef;
	            }
	        });
	    };
	    /**
	     * Called by the {@link Router} during the commit phase of a navigation when an outlet
	     * reuses a component between different routes.
	     * This method in turn is responsible for calling the `routerOnReuse` hook of its child.
	     */
	    RouterOutlet.prototype.reuse = function (nextInstruction) {
	        var previousInstruction = this._currentInstruction;
	        this._currentInstruction = nextInstruction;
	        // it's possible the component is removed before it can be reactivated (if nested withing
	        // another dynamically loaded component, for instance). In that case, we simply activate
	        // a new one.
	        if (lang_1.isBlank(this._componentRef)) {
	            return this.activate(nextInstruction);
	        }
	        else {
	            return async_1.PromiseWrapper.resolve(route_lifecycle_reflector_1.hasLifecycleHook(hookMod.routerOnReuse, this._currentInstruction.componentType) ?
	                this._componentRef.then(function (ref) {
	                    return ref.instance.routerOnReuse(nextInstruction, previousInstruction);
	                }) :
	                true);
	        }
	    };
	    /**
	     * Called by the {@link Router} when an outlet disposes of a component's contents.
	     * This method in turn is responsible for calling the `routerOnDeactivate` hook of its child.
	     */
	    RouterOutlet.prototype.deactivate = function (nextInstruction) {
	        var _this = this;
	        var next = _resolveToTrue;
	        if (lang_1.isPresent(this._componentRef) && lang_1.isPresent(this._currentInstruction) &&
	            route_lifecycle_reflector_1.hasLifecycleHook(hookMod.routerOnDeactivate, this._currentInstruction.componentType)) {
	            next = this._componentRef.then(function (ref) {
	                return ref.instance
	                    .routerOnDeactivate(nextInstruction, _this._currentInstruction);
	            });
	        }
	        return next.then(function (_) {
	            if (lang_1.isPresent(_this._componentRef)) {
	                var onDispose = _this._componentRef.then(function (ref) { return ref.destroy(); });
	                _this._componentRef = null;
	                return onDispose;
	            }
	        });
	    };
	    /**
	     * Called by the {@link Router} during recognition phase of a navigation.
	     *
	     * If this resolves to `false`, the given navigation is cancelled.
	     *
	     * This method delegates to the child component's `routerCanDeactivate` hook if it exists,
	     * and otherwise resolves to true.
	     */
	    RouterOutlet.prototype.routerCanDeactivate = function (nextInstruction) {
	        var _this = this;
	        if (lang_1.isBlank(this._currentInstruction)) {
	            return _resolveToTrue;
	        }
	        if (route_lifecycle_reflector_1.hasLifecycleHook(hookMod.routerCanDeactivate, this._currentInstruction.componentType)) {
	            return this._componentRef.then(function (ref) {
	                return ref.instance
	                    .routerCanDeactivate(nextInstruction, _this._currentInstruction);
	            });
	        }
	        else {
	            return _resolveToTrue;
	        }
	    };
	    /**
	     * Called by the {@link Router} during recognition phase of a navigation.
	     *
	     * If the new child component has a different Type than the existing child component,
	     * this will resolve to `false`. You can't reuse an old component when the new component
	     * is of a different Type.
	     *
	     * Otherwise, this method delegates to the child component's `routerCanReuse` hook if it exists,
	     * or resolves to true if the hook is not present.
	     */
	    RouterOutlet.prototype.routerCanReuse = function (nextInstruction) {
	        var _this = this;
	        var result;
	        if (lang_1.isBlank(this._currentInstruction) ||
	            this._currentInstruction.componentType != nextInstruction.componentType) {
	            result = false;
	        }
	        else if (route_lifecycle_reflector_1.hasLifecycleHook(hookMod.routerCanReuse, this._currentInstruction.componentType)) {
	            result = this._componentRef.then(function (ref) {
	                return ref.instance.routerCanReuse(nextInstruction, _this._currentInstruction);
	            });
	        }
	        else {
	            result = nextInstruction == this._currentInstruction ||
	                (lang_1.isPresent(nextInstruction.params) && lang_1.isPresent(this._currentInstruction.params) &&
	                    collection_1.StringMapWrapper.equals(nextInstruction.params, this._currentInstruction.params));
	        }
	        return async_1.PromiseWrapper.resolve(result);
	    };
	    RouterOutlet.prototype.ngOnDestroy = function () { this._parentRouter.unregisterPrimaryOutlet(this); };
	    __decorate([
	        core_1.Output('activate'), 
	        __metadata('design:type', Object)
	    ], RouterOutlet.prototype, "activateEvents", void 0);
	    RouterOutlet = __decorate([
	        core_1.Directive({ selector: 'router-outlet' }),
	        __param(3, core_1.Attribute('name')), 
	        __metadata('design:paramtypes', [core_1.ViewContainerRef, core_1.DynamicComponentLoader, routerMod.Router, String])
	    ], RouterOutlet);
	    return RouterOutlet;
	}());
	exports.RouterOutlet = RouterOutlet;


/***/ },
/* 275 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * This indirection is needed to free up Component, etc symbols in the public API
	 * to be used by the decorator versions of these annotations.
	 */
	"use strict";
	var decorators_1 = __webpack_require__(9);
	var lifecycle_annotations_impl_1 = __webpack_require__(273);
	var lifecycle_annotations_impl_2 = __webpack_require__(273);
	exports.routerCanReuse = lifecycle_annotations_impl_2.routerCanReuse;
	exports.routerCanDeactivate = lifecycle_annotations_impl_2.routerCanDeactivate;
	exports.routerOnActivate = lifecycle_annotations_impl_2.routerOnActivate;
	exports.routerOnReuse = lifecycle_annotations_impl_2.routerOnReuse;
	exports.routerOnDeactivate = lifecycle_annotations_impl_2.routerOnDeactivate;
	/**
	 * Defines route lifecycle hook `CanActivate`, which is called by the router to determine
	 * if a component can be instantiated as part of a navigation.
	 *
	 * <aside class="is-right">
	 * Note that unlike other lifecycle hooks, this one uses an annotation rather than an interface.
	 * This is because the `CanActivate` function is called before the component is instantiated.
	 * </aside>
	 *
	 * The `CanActivate` hook is called with two {@link ComponentInstruction}s as parameters, the first
	 * representing the current route being navigated to, and the second parameter representing the
	 * previous route or `null`.
	 *
	 * ```typescript
	 * @CanActivate((next, prev) => boolean | Promise<boolean>)
	 * ```
	 *
	 * If `CanActivate` returns or resolves to `false`, the navigation is cancelled.
	 * If `CanActivate` throws or rejects, the navigation is also cancelled.
	 * If `CanActivate` returns or resolves to `true`, navigation continues, the component is
	 * instantiated, and the {@link OnActivate} hook of that component is called if implemented.
	 *
	 * ### Example
	 *
	 * {@example router/ts/can_activate/can_activate_example.ts region='canActivate' }
	 */
	exports.CanActivate = decorators_1.makeDecorator(lifecycle_annotations_impl_1.CanActivate);


/***/ },
/* 276 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var core_1 = __webpack_require__(2);
	var common_1 = __webpack_require__(251);
	var lang_1 = __webpack_require__(5);
	var router_1 = __webpack_require__(250);
	/**
	 * The RouterLink directive lets you link to specific parts of your app.
	 *
	 * Consider the following route configuration:

	 * ```
	 * @RouteConfig([
	 *   { path: '/user', component: UserCmp, as: 'User' }
	 * ]);
	 * class MyComp {}
	 * ```
	 *
	 * When linking to this `User` route, you can write:
	 *
	 * ```
	 * <a [routerLink]="['./User']">link to user component</a>
	 * ```
	 *
	 * RouterLink expects the value to be an array of route names, followed by the params
	 * for that level of routing. For instance `['/Team', {teamId: 1}, 'User', {userId: 2}]`
	 * means that we want to generate a link for the `Team` route with params `{teamId: 1}`,
	 * and with a child route `User` with params `{userId: 2}`.
	 *
	 * The first route name should be prepended with `/`, `./`, or `../`.
	 * If the route begins with `/`, the router will look up the route from the root of the app.
	 * If the route begins with `./`, the router will instead look in the current component's
	 * children for the route. And if the route begins with `../`, the router will look at the
	 * current component's parent.
	 */
	var RouterLink = (function () {
	    function RouterLink(_router, _location) {
	        var _this = this;
	        this._router = _router;
	        this._location = _location;
	        // we need to update the link whenever a route changes to account for aux routes
	        this._router.subscribe(function (_) { return _this._updateLink(); });
	    }
	    // because auxiliary links take existing primary and auxiliary routes into account,
	    // we need to update the link whenever params or other routes change.
	    RouterLink.prototype._updateLink = function () {
	        this._navigationInstruction = this._router.generate(this._routeParams);
	        var navigationHref = this._navigationInstruction.toLinkUrl();
	        this.visibleHref = this._location.prepareExternalUrl(navigationHref);
	    };
	    Object.defineProperty(RouterLink.prototype, "isRouteActive", {
	        get: function () { return this._router.isRouteActive(this._navigationInstruction); },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(RouterLink.prototype, "routeParams", {
	        set: function (changes) {
	            this._routeParams = changes;
	            this._updateLink();
	        },
	        enumerable: true,
	        configurable: true
	    });
	    RouterLink.prototype.onClick = function () {
	        // If no target, or if target is _self, prevent default browser behavior
	        if (!lang_1.isString(this.target) || this.target == '_self') {
	            this._router.navigateByInstruction(this._navigationInstruction);
	            return false;
	        }
	        return true;
	    };
	    RouterLink = __decorate([
	        core_1.Directive({
	            selector: '[routerLink]',
	            inputs: ['routeParams: routerLink', 'target: target'],
	            host: {
	                '(click)': 'onClick()',
	                '[attr.href]': 'visibleHref',
	                '[class.router-link-active]': 'isRouteActive'
	            }
	        }), 
	        __metadata('design:paramtypes', [router_1.Router, common_1.Location])
	    ], RouterLink);
	    return RouterLink;
	}());
	exports.RouterLink = RouterLink;


/***/ },
/* 277 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var common_1 = __webpack_require__(251);
	var router_1 = __webpack_require__(250);
	var route_registry_1 = __webpack_require__(258);
	var core_1 = __webpack_require__(2);
	var exceptions_1 = __webpack_require__(12);
	/**
	 * The Platform agnostic ROUTER PROVIDERS
	 */
	exports.ROUTER_PROVIDERS_COMMON = [
	    route_registry_1.RouteRegistry,
	    /* @ts2dart_Provider */ { provide: common_1.LocationStrategy, useClass: common_1.PathLocationStrategy },
	    common_1.Location,
	    {
	        provide: router_1.Router,
	        useFactory: routerFactory,
	        deps: [route_registry_1.RouteRegistry, common_1.Location, route_registry_1.ROUTER_PRIMARY_COMPONENT, core_1.ApplicationRef]
	    },
	    {
	        provide: route_registry_1.ROUTER_PRIMARY_COMPONENT,
	        useFactory: routerPrimaryComponentFactory,
	        deps: /*@ts2dart_const*/ ([core_1.ApplicationRef])
	    }
	];
	function routerFactory(registry, location, primaryComponent, appRef) {
	    var rootRouter = new router_1.RootRouter(registry, location, primaryComponent);
	    appRef.registerDisposeListener(function () { return rootRouter.dispose(); });
	    return rootRouter;
	}
	function routerPrimaryComponentFactory(app) {
	    if (app.componentTypes.length == 0) {
	        throw new exceptions_1.BaseException("Bootstrap at least one component before injecting Router.");
	    }
	    return app.componentTypes[0];
	}


/***/ },
/* 278 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var router_providers_common_1 = __webpack_require__(277);
	var browser_platform_location_1 = __webpack_require__(279);
	var common_1 = __webpack_require__(251);
	/**
	 * A list of {@link Provider}s. To use the router, you must add this to your application.
	 *
	 * ### 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]);
	 * ```
	 */
	exports.ROUTER_PROVIDERS = [
	    router_providers_common_1.ROUTER_PROVIDERS_COMMON,
	    /*@ts2dart_const*/ (
	    /* @ts2dart_Provider */ { provide: common_1.PlatformLocation, useClass: browser_platform_location_1.BrowserPlatformLocation }),
	];
	/**
	 * Use {@link ROUTER_PROVIDERS} instead.
	 *
	 * @deprecated
	 */
	exports.ROUTER_BINDINGS = exports.ROUTER_PROVIDERS;


/***/ },
/* 279 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var decorators_1 = __webpack_require__(8);
	var platform_location_1 = __webpack_require__(253);
	var dom_adapter_1 = __webpack_require__(202);
	/**
	 * `PlatformLocation` encapsulates all of the direct calls to platform APIs.
	 * This class should not be used directly by an application developer. Instead, use
	 * {@link Location}.
	 */
	var BrowserPlatformLocation = (function (_super) {
	    __extends(BrowserPlatformLocation, _super);
	    function BrowserPlatformLocation() {
	        _super.call(this);
	        this._init();
	    }
	    // This is moved to its own method so that `MockPlatformLocationStrategy` can overwrite it
	    /** @internal */
	    BrowserPlatformLocation.prototype._init = function () {
	        this._location = dom_adapter_1.DOM.getLocation();
	        this._history = dom_adapter_1.DOM.getHistory();
	    };
	    Object.defineProperty(BrowserPlatformLocation.prototype, "location", {
	        /** @internal */
	        get: function () { return this._location; },
	        enumerable: true,
	        configurable: true
	    });
	    BrowserPlatformLocation.prototype.getBaseHrefFromDOM = function () { return dom_adapter_1.DOM.getBaseHref(); };
	    BrowserPlatformLocation.prototype.onPopState = function (fn) {
	        dom_adapter_1.DOM.getGlobalEventTarget('window').addEventListener('popstate', fn, false);
	    };
	    BrowserPlatformLocation.prototype.onHashChange = function (fn) {
	        dom_adapter_1.DOM.getGlobalEventTarget('window').addEventListener('hashchange', fn, false);
	    };
	    Object.defineProperty(BrowserPlatformLocation.prototype, "pathname", {
	        get: function () { return this._location.pathname; },
	        set: function (newPath) { this._location.pathname = newPath; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(BrowserPlatformLocation.prototype, "search", {
	        get: function () { return this._location.search; },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(BrowserPlatformLocation.prototype, "hash", {
	        get: function () { return this._location.hash; },
	        enumerable: true,
	        configurable: true
	    });
	    BrowserPlatformLocation.prototype.pushState = function (state, title, url) {
	        this._history.pushState(state, title, url);
	    };
	    BrowserPlatformLocation.prototype.replaceState = function (state, title, url) {
	        this._history.replaceState(state, title, url);
	    };
	    BrowserPlatformLocation.prototype.forward = function () { this._history.forward(); };
	    BrowserPlatformLocation.prototype.back = function () { this._history.back(); };
	    BrowserPlatformLocation = __decorate([
	        decorators_1.Injectable(), 
	        __metadata('design:paramtypes', [])
	    ], BrowserPlatformLocation);
	    return BrowserPlatformLocation;
	}(platform_location_1.PlatformLocation));
	exports.BrowserPlatformLocation = BrowserPlatformLocation;


/***/ },
/* 280 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var compiler_1 = __webpack_require__(139);
	var router_link_transform_1 = __webpack_require__(281);
	var router_link_transform_2 = __webpack_require__(281);
	exports.RouterLinkTransform = router_link_transform_2.RouterLinkTransform;
	/**
	 * 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']]"> -->
	 * ```
	 */
	exports.ROUTER_LINK_DSL_PROVIDER = 
	/*@ts2dart_const*/ /* @ts2dart_Provider */ {
	    provide: compiler_1.TEMPLATE_TRANSFORMS,
	    useClass: router_link_transform_1.RouterLinkTransform,
	    multi: true
	};


/***/ },
/* 281 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var __extends = (this && this.__extends) || function (d, b) {
	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
	    function __() { this.constructor = d; }
	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	};
	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __metadata = (this && this.__metadata) || function (k, v) {
	    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
	};
	var compiler_1 = __webpack_require__(139);
	var ast_1 = __webpack_require__(143);
	var exceptions_1 = __webpack_require__(12);
	var core_1 = __webpack_require__(2);
	var parser_1 = __webpack_require__(144);
	/**
	 * e.g., './User', 'Modal' in ./User[Modal(param: value)]
	 */
	var FixedPart = (function () {
	    function FixedPart(value) {
	        this.value = value;
	    }
	    return FixedPart;
	}());
	/**
	 * The square bracket
	 */
	var AuxiliaryStart = (function () {
	    function AuxiliaryStart() {
	    }
	    return AuxiliaryStart;
	}());
	/**
	 * The square bracket
	 */
	var AuxiliaryEnd = (function () {
	    function AuxiliaryEnd() {
	    }
	    return AuxiliaryEnd;
	}());
	/**
	 * e.g., param:value in ./User[Modal(param: value)]
	 */
	var Params = (function () {
	    function Params(ast) {
	        this.ast = ast;
	    }
	    return Params;
	}());
	var RouterLinkLexer = (function () {
	    function RouterLinkLexer(parser, exp) {
	        this.parser = parser;
	        this.exp = exp;
	        this.index = 0;
	    }
	    RouterLinkLexer.prototype.tokenize = function () {
	        var tokens = [];
	        while (this.index < this.exp.length) {
	            tokens.push(this._parseToken());
	        }
	        return tokens;
	    };
	    RouterLinkLexer.prototype._parseToken = function () {
	        var c = this.exp[this.index];
	        if (c == '[') {
	            this.index++;
	            return new AuxiliaryStart();
	        }
	        else if (c == ']') {
	            this.index++;
	            return new AuxiliaryEnd();
	        }
	        else if (c == '(') {
	            return this._parseParams();
	        }
	        else if (c == '/' && this.index !== 0) {
	            this.index++;
	            return this._parseFixedPart();
	        }
	        else {
	            return this._parseFixedPart();
	        }
	    };
	    RouterLinkLexer.prototype._parseParams = function () {
	        var start = this.index;
	        for (; this.index < this.exp.length; ++this.index) {
	            var c = this.exp[this.index];
	            if (c == ')') {
	                var paramsContent = this.exp.substring(start + 1, this.index);
	                this.index++;
	                return new Params(this.parser.parseBinding("{" + paramsContent + "}", null).ast);
	            }
	        }
	        throw new exceptions_1.BaseException("Cannot find ')'");
	    };
	    RouterLinkLexer.prototype._parseFixedPart = function () {
	        var start = this.index;
	        var sawNonSlash = false;
	        for (; this.index < this.exp.length; ++this.index) {
	            var c = this.exp[this.index];
	            if (c == '(' || c == '[' || c == ']' || (c == '/' && sawNonSlash)) {
	                break;
	            }
	            if (c != '.' && c != '/') {
	                sawNonSlash = true;
	            }
	        }
	        var fixed = this.exp.substring(start, this.index);
	        if (start === this.index || !sawNonSlash || fixed.startsWith('//')) {
	            throw new exceptions_1.BaseException("Invalid router link");
	        }
	        return new FixedPart(fixed);
	    };
	    return RouterLinkLexer;
	}());
	var RouterLinkAstGenerator = (function () {
	    function RouterLinkAstGenerator(tokens) {
	        this.tokens = tokens;
	        this.index = 0;
	    }
	    RouterLinkAstGenerator.prototype.generate = function () { return this._genAuxiliary(); };
	    RouterLinkAstGenerator.prototype._genAuxiliary = function () {
	        var arr = [];
	        for (; this.index < this.tokens.length; this.index++) {
	            var r = this.tokens[this.index];
	            if (r instanceof FixedPart) {
	                arr.push(new ast_1.LiteralPrimitive(r.value));
	            }
	            else if (r instanceof Params) {
	                arr.push(r.ast);
	            }
	            else if (r instanceof AuxiliaryEnd) {
	                break;
	            }
	            else if (r instanceof AuxiliaryStart) {
	                this.index++;
	                arr.push(this._genAuxiliary());
	            }
	        }
	        return new ast_1.LiteralArray(arr);
	    };
	    return RouterLinkAstGenerator;
	}());
	var RouterLinkAstTransformer = (function (_super) {
	    __extends(RouterLinkAstTransformer, _super);
	    function RouterLinkAstTransformer(parser) {
	        _super.call(this);
	        this.parser = parser;
	    }
	    RouterLinkAstTransformer.prototype.visitQuote = function (ast, context) {
	        if (ast.prefix == "route") {
	            return parseRouterLinkExpression(this.parser, ast.uninterpretedExpression);
	        }
	        else {
	            return _super.prototype.visitQuote.call(this, ast, context);
	        }
	    };
	    return RouterLinkAstTransformer;
	}(ast_1.AstTransformer));
	function parseRouterLinkExpression(parser, exp) {
	    var tokens = new RouterLinkLexer(parser, exp.trim()).tokenize();
	    return new RouterLinkAstGenerator(tokens).generate();
	}
	exports.parseRouterLinkExpression = parseRouterLinkExpression;
	/**
	 * A compiler plugin that implements the router link DSL.
	 */
	var RouterLinkTransform = (function () {
	    function RouterLinkTransform(parser) {
	        this.astTransformer = new RouterLinkAstTransformer(parser);
	    }
	    RouterLinkTransform.prototype.visitNgContent = function (ast, context) { return ast; };
	    RouterLinkTransform.prototype.visitEmbeddedTemplate = function (ast, context) { return ast; };
	    RouterLinkTransform.prototype.visitElement = function (ast, context) {
	        var _this = this;
	        var updatedChildren = ast.children.map(function (c) { return c.visit(_this, context); });
	        var updatedInputs = ast.inputs.map(function (c) { return c.visit(_this, context); });
	        var updatedDirectives = ast.directives.map(function (c) { return c.visit(_this, context); });
	        return new compiler_1.ElementAst(ast.name, ast.attrs, updatedInputs, ast.outputs, ast.references, updatedDirectives, ast.providers, ast.hasViewContainer, updatedChildren, ast.ngContentIndex, ast.sourceSpan);
	    };
	    RouterLinkTransform.prototype.visitReference = function (ast, context) { return ast; };
	    RouterLinkTransform.prototype.visitVariable = function (ast, context) { return ast; };
	    RouterLinkTransform.prototype.visitEvent = function (ast, context) { return ast; };
	    RouterLinkTransform.prototype.visitElementProperty = function (ast, context) { return ast; };
	    RouterLinkTransform.prototype.visitAttr = function (ast, context) { return ast; };
	    RouterLinkTransform.prototype.visitBoundText = function (ast, context) { return ast; };
	    RouterLinkTransform.prototype.visitText = function (ast, context) { return ast; };
	    RouterLinkTransform.prototype.visitDirective = function (ast, context) {
	        var _this = this;
	        var updatedInputs = ast.inputs.map(function (c) { return c.visit(_this, context); });
	        return new compiler_1.DirectiveAst(ast.directive, updatedInputs, ast.hostProperties, ast.hostEvents, ast.sourceSpan);
	    };
	    RouterLinkTransform.prototype.visitDirectiveProperty = function (ast, context) {
	        var transformedValue = ast.value.visit(this.astTransformer);
	        return new compiler_1.BoundDirectivePropertyAst(ast.directiveName, ast.templateName, transformedValue, ast.sourceSpan);
	    };
	    RouterLinkTransform = __decorate([
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [parser_1.Parser])
	    ], RouterLinkTransform);
	    return RouterLinkTransform;
	}());
	exports.RouterLinkTransform = RouterLinkTransform;


/***/ },
/* 282 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var profile_1 = __webpack_require__(73);
	exports.wtfCreateScope = profile_1.wtfCreateScope;
	exports.wtfLeave = profile_1.wtfLeave;
	exports.wtfStartTimeRange = profile_1.wtfStartTimeRange;
	exports.wtfEndTimeRange = profile_1.wtfEndTimeRange;


/***/ },
/* 283 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	/**
	 * @module
	 * @description
	 * Adapter allowing AngularJS v1 and Angular v2 to run side by side in the same application.
	 */
	var upgrade_adapter_1 = __webpack_require__(284);
	exports.UpgradeAdapter = upgrade_adapter_1.UpgradeAdapter;
	exports.UpgradeAdapterRef = upgrade_adapter_1.UpgradeAdapterRef;


/***/ },
/* 284 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var core_1 = __webpack_require__(2);
	var lang_1 = __webpack_require__(5);
	var async_1 = __webpack_require__(41);
	var browser_1 = __webpack_require__(203);
	var metadata_1 = __webpack_require__(285);
	var util_1 = __webpack_require__(286);
	var constants_1 = __webpack_require__(287);
	var downgrade_ng2_adapter_1 = __webpack_require__(288);
	var upgrade_ng1_adapter_1 = __webpack_require__(289);
	var angular = __webpack_require__(290);
	var upgradeCount = 0;
	/**
	 * Use `UpgradeAdapter` to allow AngularJS v1 and Angular v2 to coexist in a single application.
	 *
	 * The `UpgradeAdapter` allows:
	 * 1. creation of Angular v2 component from AngularJS v1 component directive
	 *    (See [UpgradeAdapter#upgradeNg1Component()])
	 * 2. creation of AngularJS v1 directive from Angular v2 component.
	 *    (See [UpgradeAdapter#downgradeNg2Component()])
	 * 3. Bootstrapping of a hybrid Angular application which contains both of the frameworks
	 *    coexisting in a single application.
	 *
	 * ## Mental Model
	 *
	 * When reasoning about how a hybrid application works it is useful to have a mental model which
	 * describes what is happening and explains what is happening at the lowest level.
	 *
	 * 1. There are two independent frameworks running in a single application, each framework treats
	 *    the other as a black box.
	 * 2. Each DOM element on the page is owned exactly by one framework. Whichever framework
	 *    instantiated the element is the owner. Each framework only updates/interacts with its own
	 *    DOM elements and ignores others.
	 * 3. AngularJS v1 directives always execute inside AngularJS v1 framework codebase regardless of
	 *    where they are instantiated.
	 * 4. Angular v2 components always execute inside Angular v2 framework codebase regardless of
	 *    where they are instantiated.
	 * 5. An AngularJS v1 component can be upgraded to an Angular v2 component. This creates an
	 *    Angular v2 directive, which bootstraps the AngularJS v1 component directive in that location.
	 * 6. An Angular v2 component can be downgraded to an AngularJS v1 component directive. This creates
	 *    an AngularJS v1 directive, which bootstraps the Angular v2 component in that location.
	 * 7. Whenever an adapter component is instantiated the host element is owned by the framework
	 *    doing the instantiation. The other framework then instantiates and owns the view for that
	 *    component. This implies that component bindings will always follow the semantics of the
	 *    instantiation framework. The syntax is always that of Angular v2 syntax.
	 * 8. AngularJS v1 is always bootstrapped first and owns the bottom most view.
	 * 9. The new application is running in Angular v2 zone, and therefore it no longer needs calls to
	 *    `$apply()`.
	 *
	 * ### Example
	 *
	 * ```
	 * var adapter = new UpgradeAdapter();
	 * var module = angular.module('myExample', []);
	 * module.directive('ng2', adapter.downgradeNg2Component(Ng2));
	 *
	 * module.directive('ng1', function() {
	 *   return {
	 *      scope: { title: '=' },
	 *      template: 'ng1[Hello {{title}}!](<span ng-transclude></span>)'
	 *   };
	 * });
	 *
	 *
	 * @Component({
	 *   selector: 'ng2',
	 *   inputs: ['name'],
	 *   template: 'ng2[<ng1 [title]="name">transclude</ng1>](<ng-content></ng-content>)',
	 *   directives: [adapter.upgradeNg1Component('ng1')]
	 * })
	 * class Ng2 {
	 * }
	 *
	 * document.body.innerHTML = '<ng2 name="World">project</ng2>';
	 *
	 * adapter.bootstrap(document.body, ['myExample']).ready(function() {
	 *   expect(document.body.textContent).toEqual(
	 *       "ng2[ng1[Hello World!](transclude)](project)");
	 * });
	 * ```
	 */
	var UpgradeAdapter = (function () {
	    function UpgradeAdapter() {
	        /* @internal */
	        this.idPrefix = "NG2_UPGRADE_" + upgradeCount++ + "_";
	        /* @internal */
	        this.upgradedComponents = [];
	        /* @internal */
	        this.downgradedComponents = {};
	        /* @internal */
	        this.providers = [];
	    }
	    /**
	     * Allows Angular v2 Component to be used from AngularJS v1.
	     *
	     * Use `downgradeNg2Component` to create an AngularJS v1 Directive Definition Factory from
	     * Angular v2 Component. The adapter will bootstrap Angular v2 component from within the
	     * AngularJS v1 template.
	     *
	     * ## Mental Model
	     *
	     * 1. The component is instantiated by being listed in AngularJS v1 template. This means that the
	     *    host element is controlled by AngularJS v1, but the component's view will be controlled by
	     *    Angular v2.
	     * 2. Even thought the component is instantiated in AngularJS v1, it will be using Angular v2
	     *    syntax. This has to be done, this way because we must follow Angular v2 components do not
	     *    declare how the attributes should be interpreted.
	     *
	     * ## Supported Features
	     *
	     * - Bindings:
	     *   - Attribute: `<comp name="World">`
	     *   - Interpolation:  `<comp greeting="Hello {{name}}!">`
	     *   - Expression:  `<comp [name]="username">`
	     *   - Event:  `<comp (close)="doSomething()">`
	     * - Content projection: yes
	     *
	     * ### Example
	     *
	     * ```
	     * var adapter = new UpgradeAdapter();
	     * var module = angular.module('myExample', []);
	     * module.directive('greet', adapter.downgradeNg2Component(Greeter));
	     *
	     * @Component({
	     *   selector: 'greet',
	     *   template: '{{salutation}} {{name}}! - <ng-content></ng-content>'
	     * })
	     * class Greeter {
	     *   @Input() salutation: string;
	     *   @Input() name: string;
	     * }
	     *
	     * document.body.innerHTML =
	     *   'ng1 template: <greet salutation="Hello" [name]="world">text</greet>';
	     *
	     * adapter.bootstrap(document.body, ['myExample']).ready(function() {
	     *   expect(document.body.textContent).toEqual("ng1 template: Hello world! - text");
	     * });
	     * ```
	     */
	    UpgradeAdapter.prototype.downgradeNg2Component = function (type) {
	        this.upgradedComponents.push(type);
	        var info = metadata_1.getComponentInfo(type);
	        return ng1ComponentDirective(info, "" + this.idPrefix + info.selector + "_c");
	    };
	    /**
	     * Allows AngularJS v1 Component to be used from Angular v2.
	     *
	     * Use `upgradeNg1Component` to create an Angular v2 component from AngularJS v1 Component
	     * directive. The adapter will bootstrap AngularJS v1 component from within the Angular v2
	     * template.
	     *
	     * ## Mental Model
	     *
	     * 1. The component is instantiated by being listed in Angular v2 template. This means that the
	     *    host element is controlled by Angular v2, but the component's view will be controlled by
	     *    AngularJS v1.
	     *
	     * ## Supported Features
	     *
	     * - Bindings:
	     *   - Attribute: `<comp name="World">`
	     *   - Interpolation:  `<comp greeting="Hello {{name}}!">`
	     *   - Expression:  `<comp [name]="username">`
	     *   - Event:  `<comp (close)="doSomething()">`
	     * - Transclusion: yes
	     * - Only some of the features of
	     *   [Directive Definition Object](https://docs.angularjs.org/api/ng/service/$compile) are
	     *   supported:
	     *   - `compile`: not supported because the host element is owned by Angular v2, which does
	     *     not allow modifying DOM structure during compilation.
	     *   - `controller`: supported. (NOTE: injection of `$attrs` and `$transclude` is not supported.)
	     *   - `controllerAs': supported.
	     *   - `bindToController': supported.
	     *   - `link': supported. (NOTE: only pre-link function is supported.)
	     *   - `name': supported.
	     *   - `priority': ignored.
	     *   - `replace': not supported.
	     *   - `require`: supported.
	     *   - `restrict`: must be set to 'E'.
	     *   - `scope`: supported.
	     *   - `template`: supported.
	     *   - `templateUrl`: supported.
	     *   - `terminal`: ignored.
	     *   - `transclude`: supported.
	     *
	     *
	     * ### Example
	     *
	     * ```
	     * var adapter = new UpgradeAdapter();
	     * var module = angular.module('myExample', []);
	     *
	     * module.directive('greet', function() {
	     *   return {
	     *     scope: {salutation: '=', name: '=' },
	     *     template: '{{salutation}} {{name}}! - <span ng-transclude></span>'
	     *   };
	     * });
	     *
	     * module.directive('ng2', adapter.downgradeNg2Component(Ng2));
	     *
	     * @Component({
	     *   selector: 'ng2',
	     *   template: 'ng2 template: <greet salutation="Hello" [name]="world">text</greet>'
	     *   directives: [adapter.upgradeNg1Component('greet')]
	     * })
	     * class Ng2 {
	     * }
	     *
	     * document.body.innerHTML = '<ng2></ng2>';
	     *
	     * adapter.bootstrap(document.body, ['myExample']).ready(function() {
	     *   expect(document.body.textContent).toEqual("ng2 template: Hello world! - text");
	     * });
	     * ```
	     */
	    UpgradeAdapter.prototype.upgradeNg1Component = function (name) {
	        if (this.downgradedComponents.hasOwnProperty(name)) {
	            return this.downgradedComponents[name].type;
	        }
	        else {
	            return (this.downgradedComponents[name] = new upgrade_ng1_adapter_1.UpgradeNg1ComponentAdapterBuilder(name)).type;
	        }
	    };
	    /**
	     * Bootstrap a hybrid AngularJS v1 / Angular v2 application.
	     *
	     * This `bootstrap` method is a direct replacement (takes same arguments) for AngularJS v1
	     * [`bootstrap`](https://docs.angularjs.org/api/ng/function/angular.bootstrap) method. Unlike
	     * AngularJS v1, this bootstrap is asynchronous.
	     *
	     * ### Example
	     *
	     * ```
	     * var adapter = new UpgradeAdapter();
	     * var module = angular.module('myExample', []);
	     * module.directive('ng2', adapter.downgradeNg2Component(Ng2));
	     *
	     * module.directive('ng1', function() {
	     *   return {
	     *      scope: { title: '=' },
	     *      template: 'ng1[Hello {{title}}!](<span ng-transclude></span>)'
	     *   };
	     * });
	     *
	     *
	     * @Component({
	     *   selector: 'ng2',
	     *   inputs: ['name'],
	     *   template: 'ng2[<ng1 [title]="name">transclude</ng1>](<ng-content></ng-content>)',
	     *   directives: [adapter.upgradeNg1Component('ng1')]
	     * })
	     * class Ng2 {
	     * }
	     *
	     * document.body.innerHTML = '<ng2 name="World">project</ng2>';
	     *
	     * adapter.bootstrap(document.body, ['myExample']).ready(function() {
	     *   expect(document.body.textContent).toEqual(
	     *       "ng2[ng1[Hello World!](transclude)](project)");
	     * });
	     * ```
	     */
	    UpgradeAdapter.prototype.bootstrap = function (element, modules, config) {
	        var _this = this;
	        var upgrade = new UpgradeAdapterRef();
	        var ng1Injector = null;
	        var platformRef = browser_1.browserPlatform();
	        var applicationRef = core_1.ReflectiveInjector.resolveAndCreate([
	            browser_1.BROWSER_APP_PROVIDERS,
	            core_1.provide(constants_1.NG1_INJECTOR, { useFactory: function () { return ng1Injector; } }),
	            core_1.provide(constants_1.NG1_COMPILE, { useFactory: function () { return ng1Injector.get(constants_1.NG1_COMPILE); } }),
	            this.providers
	        ], platformRef.injector)
	            .get(core_1.ApplicationRef);
	        var injector = applicationRef.injector;
	        var ngZone = injector.get(core_1.NgZone);
	        var compiler = injector.get(core_1.ComponentResolver);
	        var delayApplyExps = [];
	        var original$applyFn;
	        var rootScopePrototype;
	        var rootScope;
	        var componentFactoryRefMap = {};
	        var ng1Module = angular.module(this.idPrefix, modules);
	        var ng1BootstrapPromise = null;
	        var ng1compilePromise = null;
	        ng1Module.value(constants_1.NG2_INJECTOR, injector)
	            .value(constants_1.NG2_ZONE, ngZone)
	            .value(constants_1.NG2_COMPILER, compiler)
	            .value(constants_1.NG2_COMPONENT_FACTORY_REF_MAP, componentFactoryRefMap)
	            .config([
	            '$provide',
	            function (provide) {
	                provide.decorator(constants_1.NG1_ROOT_SCOPE, [
	                    '$delegate',
	                    function (rootScopeDelegate) {
	                        rootScopePrototype = rootScopeDelegate.constructor.prototype;
	                        if (rootScopePrototype.hasOwnProperty('$apply')) {
	                            original$applyFn = rootScopePrototype.$apply;
	                            rootScopePrototype.$apply = function (exp) { return delayApplyExps.push(exp); };
	                        }
	                        else {
	                            throw new Error("Failed to find '$apply' on '$rootScope'!");
	                        }
	                        return rootScope = rootScopeDelegate;
	                    }
	                ]);
	                provide.decorator(constants_1.NG1_TESTABILITY, [
	                    '$delegate',
	                    function (testabilityDelegate) {
	                        var _this = this;
	                        var ng2Testability = injector.get(core_1.Testability);
	                        var origonalWhenStable = testabilityDelegate.whenStable;
	                        var newWhenStable = function (callback) {
	                            var whenStableContext = _this;
	                            origonalWhenStable.call(_this, function () {
	                                if (ng2Testability.isStable()) {
	                                    callback.apply(this, arguments);
	                                }
	                                else {
	                                    ng2Testability.whenStable(newWhenStable.bind(whenStableContext, callback));
	                                }
	                            });
	                        };
	                        testabilityDelegate.whenStable = newWhenStable;
	                        return testabilityDelegate;
	                    }
	                ]);
	            }
	        ]);
	        ng1compilePromise = new Promise(function (resolve, reject) {
	            ng1Module.run([
	                '$injector',
	                '$rootScope',
	                function (injector, rootScope) {
	                    ng1Injector = injector;
	                    async_1.ObservableWrapper.subscribe(ngZone.onMicrotaskEmpty, function (_) { return ngZone.runOutsideAngular(function () { return rootScope.$apply(); }); });
	                    upgrade_ng1_adapter_1.UpgradeNg1ComponentAdapterBuilder.resolve(_this.downgradedComponents, injector)
	                        .then(resolve, reject);
	                }
	            ]);
	        });
	        // Make sure resumeBootstrap() only exists if the current bootstrap is deferred
	        var windowAngular = lang_1.global.angular;
	        windowAngular.resumeBootstrap = undefined;
	        angular.element(element).data(util_1.controllerKey(constants_1.NG2_INJECTOR), injector);
	        ngZone.run(function () { angular.bootstrap(element, [_this.idPrefix], config); });
	        ng1BootstrapPromise = new Promise(function (resolve, reject) {
	            if (windowAngular.resumeBootstrap) {
	                var originalResumeBootstrap = windowAngular.resumeBootstrap;
	                windowAngular.resumeBootstrap = function () {
	                    windowAngular.resumeBootstrap = originalResumeBootstrap;
	                    windowAngular.resumeBootstrap.apply(this, arguments);
	                    resolve();
	                };
	            }
	            else {
	                resolve();
	            }
	        });
	        Promise.all([
	            this.compileNg2Components(compiler, componentFactoryRefMap),
	            ng1BootstrapPromise,
	            ng1compilePromise
	        ])
	            .then(function () {
	            ngZone.run(function () {
	                if (rootScopePrototype) {
	                    rootScopePrototype.$apply = original$applyFn; // restore original $apply
	                    while (delayApplyExps.length) {
	                        rootScope.$apply(delayApplyExps.shift());
	                    }
	                    upgrade._bootstrapDone(applicationRef, ng1Injector);
	                    rootScopePrototype = null;
	                }
	            });
	        }, util_1.onError);
	        return upgrade;
	    };
	    /**
	     * Adds a provider to the top level environment of a hybrid AngularJS v1 / Angular v2 application.
	     *
	     * In hybrid AngularJS v1 / Angular v2 application, there is no one root Angular v2 component,
	     * for this reason we provide an application global way of registering providers which is
	     * consistent with single global injection in AngularJS v1.
	     *
	     * ### Example
	     *
	     * ```
	     * class Greeter {
	     *   greet(name) {
	     *     alert('Hello ' + name + '!');
	     *   }
	     * }
	     *
	     * @Component({
	     *   selector: 'app',
	     *   template: ''
	     * })
	     * class App {
	     *   constructor(greeter: Greeter) {
	     *     this.greeter('World');
	     *   }
	     * }
	     *
	     * var adapter = new UpgradeAdapter();
	     * adapter.addProvider(Greeter);
	     *
	     * var module = angular.module('myExample', []);
	     * module.directive('app', adapter.downgradeNg2Component(App));
	     *
	     * document.body.innerHTML = '<app></app>'
	     * adapter.bootstrap(document.body, ['myExample']);
	     *```
	     */
	    UpgradeAdapter.prototype.addProvider = function (provider) { this.providers.push(provider); };
	    /**
	     * Allows AngularJS v1 service to be accessible from Angular v2.
	     *
	     *
	     * ### Example
	     *
	     * ```
	     * class Login { ... }
	     * class Server { ... }
	     *
	     * @Injectable()
	     * class Example {
	     *   constructor(@Inject('server') server, login: Login) {
	     *     ...
	     *   }
	     * }
	     *
	     * var module = angular.module('myExample', []);
	     * module.service('server', Server);
	     * module.service('login', Login);
	     *
	     * var adapter = new UpgradeAdapter();
	     * adapter.upgradeNg1Provider('server');
	     * adapter.upgradeNg1Provider('login', {asToken: Login});
	     * adapter.addProvider(Example);
	     *
	     * adapter.bootstrap(document.body, ['myExample']).ready((ref) => {
	     *   var example: Example = ref.ng2Injector.get(Example);
	     * });
	     *
	     * ```
	     */
	    UpgradeAdapter.prototype.upgradeNg1Provider = function (name, options) {
	        var token = options && options.asToken || name;
	        this.providers.push(core_1.provide(token, {
	            useFactory: function (ng1Injector) { return ng1Injector.get(name); },
	            deps: [constants_1.NG1_INJECTOR]
	        }));
	    };
	    /**
	     * Allows Angular v2 service to be accessible from AngularJS v1.
	     *
	     *
	     * ### Example
	     *
	     * ```
	     * class Example {
	     * }
	     *
	     * var adapter = new UpgradeAdapter();
	     * adapter.addProvider(Example);
	     *
	     * var module = angular.module('myExample', []);
	     * module.factory('example', adapter.downgradeNg2Provider(Example));
	     *
	     * adapter.bootstrap(document.body, ['myExample']).ready((ref) => {
	     *   var example: Example = ref.ng1Injector.get('example');
	     * });
	     *
	     * ```
	     */
	    UpgradeAdapter.prototype.downgradeNg2Provider = function (token) {
	        var factory = function (injector) { return injector.get(token); };
	        factory.$inject = [constants_1.NG2_INJECTOR];
	        return factory;
	    };
	    /* @internal */
	    UpgradeAdapter.prototype.compileNg2Components = function (compiler, componentFactoryRefMap) {
	        var _this = this;
	        var promises = [];
	        var types = this.upgradedComponents;
	        for (var i = 0; i < types.length; i++) {
	            promises.push(compiler.resolveComponent(types[i]));
	        }
	        return Promise.all(promises).then(function (componentFactories) {
	            var types = _this.upgradedComponents;
	            for (var i = 0; i < componentFactories.length; i++) {
	                componentFactoryRefMap[metadata_1.getComponentInfo(types[i]).selector] = componentFactories[i];
	            }
	            return componentFactoryRefMap;
	        }, util_1.onError);
	    };
	    return UpgradeAdapter;
	}());
	exports.UpgradeAdapter = UpgradeAdapter;
	function ng1ComponentDirective(info, idPrefix) {
	    directiveFactory.$inject = [constants_1.NG2_COMPONENT_FACTORY_REF_MAP, constants_1.NG1_PARSE];
	    function directiveFactory(componentFactoryRefMap, parse) {
	        var componentFactory = componentFactoryRefMap[info.selector];
	        if (!componentFactory)
	            throw new Error('Expecting ComponentFactory for: ' + info.selector);
	        var idCount = 0;
	        return {
	            restrict: 'E',
	            require: constants_1.REQUIRE_INJECTOR,
	            link: {
	                post: function (scope, element, attrs, parentInjector, transclude) {
	                    var domElement = element[0];
	                    var facade = new downgrade_ng2_adapter_1.DowngradeNg2ComponentAdapter(idPrefix + (idCount++), info, element, attrs, scope, parentInjector, parse, componentFactory);
	                    facade.setupInputs();
	                    facade.bootstrapNg2();
	                    facade.projectContent();
	                    facade.setupOutputs();
	                    facade.registerCleanup();
	                }
	            }
	        };
	    }
	    return directiveFactory;
	}
	/**
	 * Use `UgradeAdapterRef` to control a hybrid AngularJS v1 / Angular v2 application.
	 */
	var UpgradeAdapterRef = (function () {
	    function UpgradeAdapterRef() {
	        /* @internal */
	        this._readyFn = null;
	        this.ng1RootScope = null;
	        this.ng1Injector = null;
	        this.ng2ApplicationRef = null;
	        this.ng2Injector = null;
	    }
	    /* @internal */
	    UpgradeAdapterRef.prototype._bootstrapDone = function (applicationRef, ng1Injector) {
	        this.ng2ApplicationRef = applicationRef;
	        this.ng2Injector = applicationRef.injector;
	        this.ng1Injector = ng1Injector;
	        this.ng1RootScope = ng1Injector.get(constants_1.NG1_ROOT_SCOPE);
	        this._readyFn && this._readyFn(this);
	    };
	    /**
	     * Register a callback function which is notified upon successful hybrid AngularJS v1 / Angular v2
	     * application has been bootstrapped.
	     *
	     * The `ready` callback function is invoked inside the Angular v2 zone, therefore it does not
	     * require a call to `$apply()`.
	     */
	    UpgradeAdapterRef.prototype.ready = function (fn) { this._readyFn = fn; };
	    /**
	     * Dispose of running hybrid AngularJS v1 / Angular v2 application.
	     */
	    UpgradeAdapterRef.prototype.dispose = function () {
	        this.ng1Injector.get(constants_1.NG1_ROOT_SCOPE).$destroy();
	        this.ng2ApplicationRef.dispose();
	    };
	    return UpgradeAdapterRef;
	}());
	exports.UpgradeAdapterRef = UpgradeAdapterRef;


/***/ },
/* 285 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var compiler_1 = __webpack_require__(139);
	var COMPONENT_SELECTOR = /^[\w|-]*$/;
	var SKEWER_CASE = /-(\w)/g;
	var directiveResolver = new compiler_1.DirectiveResolver();
	function getComponentInfo(type) {
	    var resolvedMetadata = directiveResolver.resolve(type);
	    var selector = resolvedMetadata.selector;
	    if (!selector.match(COMPONENT_SELECTOR)) {
	        throw new Error('Only selectors matching element names are supported, got: ' + selector);
	    }
	    var selector = selector.replace(SKEWER_CASE, function (all, letter) { return letter.toUpperCase(); });
	    return {
	        type: type,
	        selector: selector,
	        inputs: parseFields(resolvedMetadata.inputs),
	        outputs: parseFields(resolvedMetadata.outputs)
	    };
	}
	exports.getComponentInfo = getComponentInfo;
	function parseFields(names) {
	    var attrProps = [];
	    if (names) {
	        for (var i = 0; i < names.length; i++) {
	            var parts = names[i].split(':');
	            var prop = parts[0].trim();
	            var attr = (parts[1] || parts[0]).trim();
	            var capitalAttr = attr.charAt(0).toUpperCase() + attr.substr(1);
	            attrProps.push({
	                prop: prop,
	                attr: attr,
	                bracketAttr: "[" + attr + "]",
	                parenAttr: "(" + attr + ")",
	                bracketParenAttr: "[(" + attr + ")]",
	                onAttr: "on" + capitalAttr,
	                bindAttr: "bind" + capitalAttr,
	                bindonAttr: "bindon" + capitalAttr
	            });
	        }
	    }
	    return attrProps;
	}
	exports.parseFields = parseFields;


/***/ },
/* 286 */
/***/ function(module, exports) {

	"use strict";
	function stringify(obj) {
	    if (typeof obj == 'function')
	        return obj.name || obj.toString();
	    return '' + obj;
	}
	exports.stringify = stringify;
	function onError(e) {
	    // TODO: (misko): We seem to not have a stack trace here!
	    console.log(e, e.stack);
	    throw e;
	}
	exports.onError = onError;
	function controllerKey(name) {
	    return '$' + name + 'Controller';
	}
	exports.controllerKey = controllerKey;


/***/ },
/* 287 */
/***/ function(module, exports) {

	"use strict";
	exports.NG2_COMPILER = 'ng2.Compiler';
	exports.NG2_INJECTOR = 'ng2.Injector';
	exports.NG2_COMPONENT_FACTORY_REF_MAP = 'ng2.ComponentFactoryRefMap';
	exports.NG2_ZONE = 'ng2.NgZone';
	exports.NG1_CONTROLLER = '$controller';
	exports.NG1_SCOPE = '$scope';
	exports.NG1_ROOT_SCOPE = '$rootScope';
	exports.NG1_COMPILE = '$compile';
	exports.NG1_HTTP_BACKEND = '$httpBackend';
	exports.NG1_INJECTOR = '$injector';
	exports.NG1_PARSE = '$parse';
	exports.NG1_TEMPLATE_CACHE = '$templateCache';
	exports.NG1_TESTABILITY = '$$testability';
	exports.REQUIRE_INJECTOR = '^' + exports.NG2_INJECTOR;


/***/ },
/* 288 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var core_1 = __webpack_require__(2);
	var constants_1 = __webpack_require__(287);
	var INITIAL_VALUE = {
	    __UNINITIALIZED__: true
	};
	var DowngradeNg2ComponentAdapter = (function () {
	    function DowngradeNg2ComponentAdapter(id, info, element, attrs, scope, parentInjector, parse, componentFactory) {
	        this.id = id;
	        this.info = info;
	        this.element = element;
	        this.attrs = attrs;
	        this.scope = scope;
	        this.parentInjector = parentInjector;
	        this.parse = parse;
	        this.componentFactory = componentFactory;
	        this.component = null;
	        this.inputChangeCount = 0;
	        this.inputChanges = null;
	        this.componentRef = null;
	        this.changeDetector = null;
	        this.contentInsertionPoint = null;
	        this.element[0].id = id;
	        this.componentScope = scope.$new();
	        this.childNodes = element.contents();
	    }
	    DowngradeNg2ComponentAdapter.prototype.bootstrapNg2 = function () {
	        var childInjector = core_1.ReflectiveInjector.resolveAndCreate([core_1.provide(constants_1.NG1_SCOPE, { useValue: this.componentScope })], this.parentInjector);
	        this.contentInsertionPoint = document.createComment('ng1 insertion point');
	        this.componentRef =
	            this.componentFactory.create(childInjector, [[this.contentInsertionPoint]], '#' + this.id);
	        this.changeDetector = this.componentRef.changeDetectorRef;
	        this.component = this.componentRef.instance;
	    };
	    DowngradeNg2ComponentAdapter.prototype.setupInputs = function () {
	        var _this = this;
	        var attrs = this.attrs;
	        var inputs = this.info.inputs;
	        for (var i = 0; i < inputs.length; i++) {
	            var input = inputs[i];
	            var expr = null;
	            if (attrs.hasOwnProperty(input.attr)) {
	                var observeFn = (function (prop) {
	                    var prevValue = INITIAL_VALUE;
	                    return function (value) {
	                        if (_this.inputChanges !== null) {
	                            _this.inputChangeCount++;
	                            _this.inputChanges[prop] =
	                                new Ng1Change(value, prevValue === INITIAL_VALUE ? value : prevValue);
	                            prevValue = value;
	                        }
	                        _this.component[prop] = value;
	                    };
	                })(input.prop);
	                attrs.$observe(input.attr, observeFn);
	            }
	            else if (attrs.hasOwnProperty(input.bindAttr)) {
	                expr = attrs[input.bindAttr];
	            }
	            else if (attrs.hasOwnProperty(input.bracketAttr)) {
	                expr = attrs[input.bracketAttr];
	            }
	            else if (attrs.hasOwnProperty(input.bindonAttr)) {
	                expr = attrs[input.bindonAttr];
	            }
	            else if (attrs.hasOwnProperty(input.bracketParenAttr)) {
	                expr = attrs[input.bracketParenAttr];
	            }
	            if (expr != null) {
	                var watchFn = (function (prop) { return function (value, prevValue) {
	                    if (_this.inputChanges != null) {
	                        _this.inputChangeCount++;
	                        _this.inputChanges[prop] = new Ng1Change(prevValue, value);
	                    }
	                    _this.component[prop] = value;
	                }; })(input.prop);
	                this.componentScope.$watch(expr, watchFn);
	            }
	        }
	        var prototype = this.info.type.prototype;
	        if (prototype && prototype.ngOnChanges) {
	            // Detect: OnChanges interface
	            this.inputChanges = {};
	            this.componentScope.$watch(function () { return _this.inputChangeCount; }, function () {
	                var inputChanges = _this.inputChanges;
	                _this.inputChanges = {};
	                _this.component.ngOnChanges(inputChanges);
	            });
	        }
	        this.componentScope.$watch(function () { return _this.changeDetector && _this.changeDetector.detectChanges(); });
	    };
	    DowngradeNg2ComponentAdapter.prototype.projectContent = function () {
	        var childNodes = this.childNodes;
	        var parent = this.contentInsertionPoint.parentNode;
	        if (parent) {
	            for (var i = 0, ii = childNodes.length; i < ii; i++) {
	                parent.insertBefore(childNodes[i], this.contentInsertionPoint);
	            }
	        }
	    };
	    DowngradeNg2ComponentAdapter.prototype.setupOutputs = function () {
	        var _this = this;
	        var attrs = this.attrs;
	        var outputs = this.info.outputs;
	        for (var j = 0; j < outputs.length; j++) {
	            var output = outputs[j];
	            var expr = null;
	            var assignExpr = false;
	            var bindonAttr = output.bindonAttr ? output.bindonAttr.substring(0, output.bindonAttr.length - 6) : null;
	            var bracketParenAttr = output.bracketParenAttr ?
	                "[(" + output.bracketParenAttr.substring(2, output.bracketParenAttr.length - 8) + ")]" :
	                null;
	            if (attrs.hasOwnProperty(output.onAttr)) {
	                expr = attrs[output.onAttr];
	            }
	            else if (attrs.hasOwnProperty(output.parenAttr)) {
	                expr = attrs[output.parenAttr];
	            }
	            else if (attrs.hasOwnProperty(bindonAttr)) {
	                expr = attrs[bindonAttr];
	                assignExpr = true;
	            }
	            else if (attrs.hasOwnProperty(bracketParenAttr)) {
	                expr = attrs[bracketParenAttr];
	                assignExpr = true;
	            }
	            if (expr != null && assignExpr != null) {
	                var getter = this.parse(expr);
	                var setter = getter.assign;
	                if (assignExpr && !setter) {
	                    throw new Error("Expression '" + expr + "' is not assignable!");
	                }
	                var emitter = this.component[output.prop];
	                if (emitter) {
	                    emitter.subscribe({
	                        next: assignExpr ? (function (setter) { return function (value) { return setter(_this.scope, value); }; })(setter) :
	                            (function (getter) { return function (value) { return getter(_this.scope, { $event: value }); }; })(getter)
	                    });
	                }
	                else {
	                    throw new Error("Missing emitter '" + output.prop + "' on component '" + this.info.selector + "'!");
	                }
	            }
	        }
	    };
	    DowngradeNg2ComponentAdapter.prototype.registerCleanup = function () {
	        var _this = this;
	        this.element.bind('$destroy', function () {
	            _this.componentScope.$destroy();
	            _this.componentRef.destroy();
	        });
	    };
	    return DowngradeNg2ComponentAdapter;
	}());
	exports.DowngradeNg2ComponentAdapter = DowngradeNg2ComponentAdapter;
	var Ng1Change = (function () {
	    function Ng1Change(previousValue, currentValue) {
	        this.previousValue = previousValue;
	        this.currentValue = currentValue;
	    }
	    Ng1Change.prototype.isFirstChange = function () { return this.previousValue === this.currentValue; };
	    return Ng1Change;
	}());


/***/ },
/* 289 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var core_1 = __webpack_require__(2);
	var constants_1 = __webpack_require__(287);
	var util_1 = __webpack_require__(286);
	var angular = __webpack_require__(290);
	var CAMEL_CASE = /([A-Z])/g;
	var INITIAL_VALUE = {
	    __UNINITIALIZED__: true
	};
	var NOT_SUPPORTED = 'NOT_SUPPORTED';
	var UpgradeNg1ComponentAdapterBuilder = (function () {
	    function UpgradeNg1ComponentAdapterBuilder(name) {
	        this.name = name;
	        this.inputs = [];
	        this.inputsRename = [];
	        this.outputs = [];
	        this.outputsRename = [];
	        this.propertyOutputs = [];
	        this.checkProperties = [];
	        this.propertyMap = {};
	        this.linkFn = null;
	        this.directive = null;
	        this.$controller = null;
	        var selector = name.replace(CAMEL_CASE, function (all, next) { return '-' + next.toLowerCase(); });
	        var self = this;
	        this.type =
	            core_1.Directive({ selector: selector, inputs: this.inputsRename, outputs: this.outputsRename })
	                .Class({
	                constructor: [
	                    new core_1.Inject(constants_1.NG1_SCOPE),
	                    core_1.ElementRef,
	                    function (scope, elementRef) {
	                        return new UpgradeNg1ComponentAdapter(self.linkFn, scope, self.directive, elementRef, self.$controller, self.inputs, self.outputs, self.propertyOutputs, self.checkProperties, self.propertyMap);
	                    }
	                ],
	                ngOnInit: function () { },
	                ngOnChanges: function () { },
	                ngDoCheck: function () { }
	            });
	    }
	    UpgradeNg1ComponentAdapterBuilder.prototype.extractDirective = function (injector) {
	        var directives = injector.get(this.name + 'Directive');
	        if (directives.length > 1) {
	            throw new Error('Only support single directive definition for: ' + this.name);
	        }
	        var directive = directives[0];
	        if (directive.replace)
	            this.notSupported('replace');
	        if (directive.terminal)
	            this.notSupported('terminal');
	        var link = directive.link;
	        if (typeof link == 'object') {
	            if (link.post)
	                this.notSupported('link.post');
	        }
	        return directive;
	    };
	    UpgradeNg1ComponentAdapterBuilder.prototype.notSupported = function (feature) {
	        throw new Error("Upgraded directive '" + this.name + "' does not support '" + feature + "'.");
	    };
	    UpgradeNg1ComponentAdapterBuilder.prototype.extractBindings = function () {
	        var btcIsObject = typeof this.directive.bindToController === 'object';
	        if (btcIsObject && Object.keys(this.directive.scope).length) {
	            throw new Error("Binding definitions on scope and controller at the same time are not supported.");
	        }
	        var context = (btcIsObject) ? this.directive.bindToController : this.directive.scope;
	        if (typeof context == 'object') {
	            for (var name in context) {
	                if (context.hasOwnProperty(name)) {
	                    var localName = context[name];
	                    var type = localName.charAt(0);
	                    localName = localName.substr(1) || name;
	                    var outputName = 'output_' + name;
	                    var outputNameRename = outputName + ': ' + name;
	                    var outputNameRenameChange = outputName + ': ' + name + 'Change';
	                    var inputName = 'input_' + name;
	                    var inputNameRename = inputName + ': ' + name;
	                    switch (type) {
	                        case '=':
	                            this.propertyOutputs.push(outputName);
	                            this.checkProperties.push(localName);
	                            this.outputs.push(outputName);
	                            this.outputsRename.push(outputNameRenameChange);
	                            this.propertyMap[outputName] = localName;
	                        // don't break; let it fall through to '@'
	                        case '@':
	                        // handle the '<' binding of angular 1.5 components
	                        case '<':
	                            this.inputs.push(inputName);
	                            this.inputsRename.push(inputNameRename);
	                            this.propertyMap[inputName] = localName;
	                            break;
	                        case '&':
	                            this.outputs.push(outputName);
	                            this.outputsRename.push(outputNameRename);
	                            this.propertyMap[outputName] = localName;
	                            break;
	                        default:
	                            var json = JSON.stringify(context);
	                            throw new Error("Unexpected mapping '" + type + "' in '" + json + "' in '" + this.name + "' directive.");
	                    }
	                }
	            }
	        }
	    };
	    UpgradeNg1ComponentAdapterBuilder.prototype.compileTemplate = function (compile, templateCache, httpBackend) {
	        var _this = this;
	        if (this.directive.template !== undefined) {
	            this.linkFn = compileHtml(this.directive.template);
	        }
	        else if (this.directive.templateUrl) {
	            var url = this.directive.templateUrl;
	            var html = templateCache.get(url);
	            if (html !== undefined) {
	                this.linkFn = compileHtml(html);
	            }
	            else {
	                return new Promise(function (resolve, err) {
	                    httpBackend('GET', url, null, function (status, response) {
	                        if (status == 200) {
	                            resolve(_this.linkFn = compileHtml(templateCache.put(url, response)));
	                        }
	                        else {
	                            err("GET " + url + " returned " + status + ": " + response);
	                        }
	                    });
	                });
	            }
	        }
	        else {
	            throw new Error("Directive '" + this.name + "' is not a component, it is missing template.");
	        }
	        return null;
	        function compileHtml(html) {
	            var div = document.createElement('div');
	            div.innerHTML = html;
	            return compile(div.childNodes);
	        }
	    };
	    UpgradeNg1ComponentAdapterBuilder.resolve = function (exportedComponents, injector) {
	        var promises = [];
	        var compile = injector.get(constants_1.NG1_COMPILE);
	        var templateCache = injector.get(constants_1.NG1_TEMPLATE_CACHE);
	        var httpBackend = injector.get(constants_1.NG1_HTTP_BACKEND);
	        var $controller = injector.get(constants_1.NG1_CONTROLLER);
	        for (var name in exportedComponents) {
	            if (exportedComponents.hasOwnProperty(name)) {
	                var exportedComponent = exportedComponents[name];
	                exportedComponent.directive = exportedComponent.extractDirective(injector);
	                exportedComponent.$controller = $controller;
	                exportedComponent.extractBindings();
	                var promise = exportedComponent.compileTemplate(compile, templateCache, httpBackend);
	                if (promise)
	                    promises.push(promise);
	            }
	        }
	        return Promise.all(promises);
	    };
	    return UpgradeNg1ComponentAdapterBuilder;
	}());
	exports.UpgradeNg1ComponentAdapterBuilder = UpgradeNg1ComponentAdapterBuilder;
	var UpgradeNg1ComponentAdapter = (function () {
	    function UpgradeNg1ComponentAdapter(linkFn, scope, directive, elementRef, $controller, inputs, outputs, propOuts, checkProperties, propertyMap) {
	        this.linkFn = linkFn;
	        this.directive = directive;
	        this.inputs = inputs;
	        this.outputs = outputs;
	        this.propOuts = propOuts;
	        this.checkProperties = checkProperties;
	        this.propertyMap = propertyMap;
	        this.destinationObj = null;
	        this.checkLastValues = [];
	        this.element = elementRef.nativeElement;
	        this.componentScope = scope.$new(!!directive.scope);
	        var $element = angular.element(this.element);
	        var controllerType = directive.controller;
	        var controller = null;
	        if (controllerType) {
	            var locals = { $scope: this.componentScope, $element: $element };
	            controller = $controller(controllerType, locals, null, directive.controllerAs);
	            $element.data(util_1.controllerKey(directive.name), controller);
	        }
	        var link = directive.link;
	        if (typeof link == 'object')
	            link = link.pre;
	        if (link) {
	            var attrs = NOT_SUPPORTED;
	            var transcludeFn = NOT_SUPPORTED;
	            var linkController = this.resolveRequired($element, directive.require);
	            directive.link(this.componentScope, $element, attrs, linkController, transcludeFn);
	        }
	        this.destinationObj =
	            directive.bindToController && controller ? controller : this.componentScope;
	        for (var i = 0; i < inputs.length; i++) {
	            this[inputs[i]] = null;
	        }
	        for (var j = 0; j < outputs.length; j++) {
	            var emitter = this[outputs[j]] = new core_1.EventEmitter();
	            this.setComponentProperty(outputs[j], (function (emitter) { return function (value) { return emitter.emit(value); }; })(emitter));
	        }
	        for (var k = 0; k < propOuts.length; k++) {
	            this[propOuts[k]] = new core_1.EventEmitter();
	            this.checkLastValues.push(INITIAL_VALUE);
	        }
	    }
	    UpgradeNg1ComponentAdapter.prototype.ngOnInit = function () {
	        var _this = this;
	        var childNodes = [];
	        var childNode;
	        while (childNode = this.element.firstChild) {
	            this.element.removeChild(childNode);
	            childNodes.push(childNode);
	        }
	        this.linkFn(this.componentScope, function (clonedElement, scope) {
	            for (var i = 0, ii = clonedElement.length; i < ii; i++) {
	                _this.element.appendChild(clonedElement[i]);
	            }
	        }, { parentBoundTranscludeFn: function (scope, cloneAttach) { cloneAttach(childNodes); } });
	        if (this.destinationObj.$onInit) {
	            this.destinationObj.$onInit();
	        }
	    };
	    UpgradeNg1ComponentAdapter.prototype.ngOnChanges = function (changes) {
	        for (var name in changes) {
	            if (changes.hasOwnProperty(name)) {
	                var change = changes[name];
	                this.setComponentProperty(name, change.currentValue);
	            }
	        }
	    };
	    UpgradeNg1ComponentAdapter.prototype.ngDoCheck = function () {
	        var count = 0;
	        var destinationObj = this.destinationObj;
	        var lastValues = this.checkLastValues;
	        var checkProperties = this.checkProperties;
	        for (var i = 0; i < checkProperties.length; i++) {
	            var value = destinationObj[checkProperties[i]];
	            var last = lastValues[i];
	            if (value !== last) {
	                if (typeof value == 'number' && isNaN(value) && typeof last == 'number' && isNaN(last)) {
	                }
	                else {
	                    var eventEmitter = this[this.propOuts[i]];
	                    eventEmitter.emit(lastValues[i] = value);
	                }
	            }
	        }
	        return count;
	    };
	    UpgradeNg1ComponentAdapter.prototype.setComponentProperty = function (name, value) {
	        this.destinationObj[this.propertyMap[name]] = value;
	    };
	    UpgradeNg1ComponentAdapter.prototype.resolveRequired = function ($element, require) {
	        if (!require) {
	            return undefined;
	        }
	        else if (typeof require == 'string') {
	            var name = require;
	            var isOptional = false;
	            var startParent = false;
	            var searchParents = false;
	            var ch;
	            if (name.charAt(0) == '?') {
	                isOptional = true;
	                name = name.substr(1);
	            }
	            if (name.charAt(0) == '^') {
	                searchParents = true;
	                name = name.substr(1);
	            }
	            if (name.charAt(0) == '^') {
	                startParent = true;
	                name = name.substr(1);
	            }
	            var key = util_1.controllerKey(name);
	            if (startParent)
	                $element = $element.parent();
	            var dep = searchParents ? $element.inheritedData(key) : $element.data(key);
	            if (!dep && !isOptional) {
	                throw new Error("Can not locate '" + require + "' in '" + this.directive.name + "'.");
	            }
	            return dep;
	        }
	        else if (require instanceof Array) {
	            var deps = [];
	            for (var i = 0; i < require.length; i++) {
	                deps.push(this.resolveRequired($element, require[i]));
	            }
	            return deps;
	        }
	        throw new Error("Directive '" + this.directive.name + "' require syntax unrecognized: " + this.directive.require);
	    };
	    return UpgradeNg1ComponentAdapter;
	}());


/***/ },
/* 290 */
/***/ function(module, exports) {

	"use strict";
	function noNg() {
	    throw new Error('AngularJS v1.x is not loaded!');
	}
	var angular = {
	    bootstrap: noNg,
	    module: noNg,
	    element: noNg,
	    version: noNg,
	    resumeBootstrap: noNg,
	    getTestability: noNg
	};
	try {
	    if (window.hasOwnProperty('angular')) {
	        angular = window.angular;
	    }
	}
	catch (e) {
	}
	exports.bootstrap = angular.bootstrap;
	exports.module = angular.module;
	exports.element = angular.element;
	exports.version = angular.version;
	exports.resumeBootstrap = angular.resumeBootstrap;
	exports.getTestability = angular.getTestability;


/***/ }
/******/ ])
});
;