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