tech(systemjs): almost all tests are passing

karma.conf.js

@@ -9,14 +9,13 @@ module.exports = function(config) {
     // list of files / patterns to load in the browser
     files: [
       'vendor/npm/es5-shim/es5-shim.js',
+      'vendor/npm/es5-shim/es5-sham.js',
       'vendor/npm/es6-shim/es6-shim.js',
       'vendor/npm/es6-promise/dist/es6-promise.js',
       'vendor/npm/systemjs/dist/system.src.js',
       'test/test-main.js',
 
-      {pattern: 'app/**/*.js', included: false},
+      {pattern: '**/*.js', included: false},
-      {pattern: 'vendor/**/*.js', included: false},
-      {pattern: 'test/**/*.js', included: false}
     ],
 
     // list of files to exclude
@@ -28,7 +27,7 @@ module.exports = function(config) {
     logLevel: config.LOG_INFO,
     autoWatch: true,
     browsers: ['PhantomJS'],
-    captureTimeout: 60000,
+    captureTimeout: 2000,
     singleRun: true,
     autoWatchBatchDelay: 1000,
 

package.json

@@ -18,43 +18,36 @@
     "grunt": "~0.4.0",
     "grunt-angular-templates": "^0.5.5",
     "grunt-cli": "~0.1.13",
-    "grunt-contrib-clean": "~0.5.0",
+    "grunt-contrib-clean": "~0.7.0",
-    "grunt-contrib-compress": "~0.13.0",
+    "grunt-contrib-compress": "~0.14.0",
-    "grunt-contrib-concat": "^0.4.0",
+    "grunt-contrib-concat": "^0.5.1",
-    "grunt-contrib-connect": "~0.5.0",
+    "grunt-contrib-copy": "~0.8.2",
-    "grunt-contrib-copy": "~0.5.0",
+    "grunt-contrib-cssmin": "~0.14.0",
-    "grunt-contrib-cssmin": "~0.6.1",
     "grunt-contrib-htmlmin": "~0.6.0",
-    "grunt-contrib-jshint": "~0.10.0",
+    "grunt-contrib-jshint": "~0.11.3",
     "grunt-contrib-less": "~0.7.0",
-    "grunt-contrib-requirejs": "~0.4.4",
+    "grunt-contrib-uglify": "~0.11.0",
-    "grunt-contrib-uglify": "~0.8.0",
     "grunt-contrib-watch": "^0.6.1",
     "grunt-filerev": "^0.2.1",
     "grunt-git-describe": "~2.3.2",
-    "grunt-karma": "~0.8.3",
+    "grunt-karma": "~0.12.1",
-    "grunt-ng-annotate": "^0.9.2",
+    "grunt-ng-annotate": "^1.0.1",
-    "grunt-string-replace": "~0.2.4",
+    "grunt-string-replace": "~1.2.1",
     "grunt-systemjs-builder": "^0.2.5",
     "grunt-tslint": "^2.5.0",
     "grunt-typescript": "^0.8.0",
     "grunt-usemin": "3.0.0",
     "jshint-stylish": "~0.1.5",
-    "karma": "~0.12.31",
+    "karma": "~0.13.15",
-    "karma-chrome-launcher": "~0.1.4",
+    "karma-chrome-launcher": "~0.2.2",
-    "karma-coffee-preprocessor": "~0.1.2",
+    "karma-coverage": "0.5.3",
-    "karma-coverage": "0.3.1",
+    "karma-coveralls": "1.1.2",
-    "karma-coveralls": "0.1.5",
     "karma-expect": "~1.1.0",
-    "karma-mocha": "~0.1.10",
+    "karma-mocha": "~0.2.1",
-    "karma-phantomjs-launcher": "0.1.4",
+    "karma-phantomjs-launcher": "0.2.1",
-    "karma-requirejs": "0.2.2",
+    "load-grunt-tasks": "3.4.0",
-    "karma-script-launcher": "0.1.0",
+    "mocha": "2.3.4",
-    "load-grunt-tasks": "0.2.0",
-    "mocha": "2.2.4",
     "reflect-metadata": "0.1.2",
-    "requirejs": "2.1.17",
-    "rjs-build-analysis": "0.0.3",
     "rxjs": "5.0.0-beta.0",
     "systemjs": "0.19.6",
     "zone.js": "0.5.10"

public/app/app.js

@@ -3,6 +3,5 @@ define([
 ], function(app) {
   'use strict';
   // backward compatability hack;
-  console.log(app);
   return app.default;
 });

public/app/grafana.ts

@@ -25,6 +25,12 @@ export class GrafanaApp {
   ngModuleDependencies: any[];
   preBootModules: any[];
 
+  constructor() {
+    this.preBootModules = [];
+    this.registerFunctions = {};
+    this.ngModuleDependencies = [];
+  }
+
   useModule(module) {
     if (this.preBootModules) {
       this.preBootModules.push(module);
@@ -36,9 +42,6 @@ export class GrafanaApp {
   }
 
   init() {
-    this.registerFunctions = {};
-    this.preBootModules = [];
-
     var app = angular.module('grafana', []);
     app.constant('grafanaVersion', "@grafanaVersion@");
 

public/app/plugins/datasource/cloudwatch/specs/datasource_specs.ts

@@ -1,10 +1,8 @@
-///<amd-dependency path="app/plugins/datasource/cloudwatch/datasource" />
-///<amd-dependency path="test/specs/helpers" name="helpers" />
 
+import "../datasource";
 import {describe, beforeEach, it, sinon, expect, angularMocks} from 'test/lib/common';
-import moment = require('moment');
+import moment from 'moment';
-
+import helpers from 'test/specs/helpers';
-declare var helpers: any;
 
 describe('CloudWatchDatasource', function() {
   var ctx = new helpers.ServiceTestContext();

public/app/plugins/datasource/elasticsearch/elastic_response.d.ts

@@ -0,0 +1,2 @@
+declare var test: any;
+export default test;

public/app/plugins/datasource/elasticsearch/index_pattern.d.ts

@@ -0,0 +1,2 @@
+declare var test: any;
+export default test;

public/app/plugins/datasource/elasticsearch/query_builder.d.ts

@@ -0,0 +1,2 @@
+declare var test: any;
+export default test;

public/app/plugins/datasource/elasticsearch/query_def.d.ts

@@ -0,0 +1,2 @@
+declare var test: any;
+export default test;

public/app/plugins/datasource/elasticsearch/specs/datasource_specs.ts

@@ -1,11 +1,9 @@
-///<amd-dependency path="../datasource" />
-///<amd-dependency path="test/specs/helpers" name="helpers" />
 
+import "../datasource";
 import {describe, beforeEach, it, sinon, expect, angularMocks} from 'test/lib/common';
-import moment  = require('moment');
+import moment from 'moment';
-import angular = require('angular');
+import angular from 'angular';
-
+import helpers from 'test/specs/helpers';
-declare var helpers: any;
 
 describe('ElasticDatasource', function() {
   var ctx = new helpers.ServiceTestContext();

public/app/plugins/datasource/elasticsearch/specs/elastic_response_specs.ts

@@ -1,8 +1,6 @@
-///<amd-dependency path="../elastic_response" name="ElasticResponse"/>
 
 import {describe, beforeEach, it, sinon, expect} from 'test/lib/common';
-
+import ElasticResponse from '../elastic_response';
-declare var ElasticResponse: any;
 
 describe('ElasticResponse', function() {
   var targets;

public/app/plugins/datasource/elasticsearch/specs/index_pattern_specs.ts

@@ -1,10 +1,8 @@
-///<amd-dependency path="../index_pattern" name="IndexPattern"/>
 ///<amd-dependency path="test/specs/helpers" name="helpers" />
 
 import {describe, beforeEach, it, sinon, expect} from 'test/lib/common';
-import moment  = require('moment');
+import moment from 'moment';
-
+import IndexPattern from '../index_pattern';
-declare var IndexPattern: any;
 
 describe('IndexPattern', function() {
 

public/app/plugins/datasource/elasticsearch/specs/query_builder_specs.ts

@@ -1,8 +1,6 @@
-///<amd-dependency path="../query_builder" name="ElasticQueryBuilder"/>
 
 import {describe, beforeEach, it, sinon, expect} from 'test/lib/common';
-
+import ElasticQueryBuilder from '../query_builder';
-declare var ElasticQueryBuilder: any;
 
 describe('ElasticQueryBuilder', function() {
   var builder;

public/app/plugins/datasource/elasticsearch/specs/query_ctrl_specs.ts

@@ -3,8 +3,7 @@
 ///<amd-dependency path="test/specs/helpers" name="helpers" />
 
 import {describe, beforeEach, it, sinon, expect, angularMocks} from 'test/lib/common';
-
+import helpers from 'test/specs/helpers';
-declare var helpers: any;
 
 describe('ElasticQueryCtrl', function() {
   var ctx = new helpers.ControllerTestContext();

public/app/plugins/datasource/elasticsearch/specs/query_def_specs.ts

@@ -1,16 +1,13 @@
-///<amd-dependency path="../query_def" name="QueryDef" />
-///<amd-dependency path="test/specs/helpers" name="helpers" />
 
 import {describe, beforeEach, it, sinon, expect, angularMocks} from 'test/lib/common';
 
-declare var helpers: any;
+import * as queryDef from '../query_def';
-declare var QueryDef: any;
 
 describe('ElasticQueryDef', function() {
 
   describe('getPipelineAggOptions', function() {
     describe('with zero targets', function() {
-      var response = QueryDef.getPipelineAggOptions([]);
+      var response = queryDef.getPipelineAggOptions([]);
 
       it('should return zero', function() {
         expect(response.length).to.be(0);
@@ -25,7 +22,7 @@ describe('ElasticQueryDef', function() {
         ]
       };
 
-      var response = QueryDef.getPipelineAggOptions(targets);
+      var response = queryDef.getPipelineAggOptions(targets);
 
       it('should return zero', function() {
         expect(response.length).to.be(2);
@@ -40,7 +37,7 @@ describe('ElasticQueryDef', function() {
         ]
       };
 
-      var response = QueryDef.getPipelineAggOptions(targets);
+      var response = queryDef.getPipelineAggOptions(targets);
 
       it('should return one', function() {
         expect(response.length).to.be(1);
@@ -54,7 +51,7 @@ describe('ElasticQueryDef', function() {
         ]
       };
 
-      var response = QueryDef.getPipelineAggOptions(targets);
+      var response = queryDef.getPipelineAggOptions(targets);
 
       it('should return zero', function() {
         expect(response.length).to.be(0);
@@ -64,7 +61,7 @@ describe('ElasticQueryDef', function() {
 
   describe('isPipelineMetric', function() {
     describe('moving_avg', function() {
-      var result = QueryDef.isPipelineAgg('moving_avg');
+      var result = queryDef.isPipelineAgg('moving_avg');
 
       it('is pipe line metric', function() {
         expect(result).to.be(true);
@@ -72,7 +69,7 @@ describe('ElasticQueryDef', function() {
     });
 
     describe('count', function() {
-      var result = QueryDef.isPipelineAgg('count');
+      var result = queryDef.isPipelineAgg('count');
 
       it('is not pipe line metric', function() {
         expect(result).to.be(false);
@@ -83,19 +80,19 @@ describe('ElasticQueryDef', function() {
   describe('pipeline aggs depending on esverison', function() {
       describe('using esversion undefined', function() {
           it('should not get pipeline aggs', function() {
-              expect(QueryDef.getMetricAggTypes(undefined).length).to.be(9);
+              expect(queryDef.getMetricAggTypes(undefined).length).to.be(9);
           });
       });
 
       describe('using esversion 1', function() {
           it('should not get pipeline aggs', function() {
-              expect(QueryDef.getMetricAggTypes(1).length).to.be(9);
+              expect(queryDef.getMetricAggTypes(1).length).to.be(9);
           });
       });
 
       describe('using esversion 2', function() {
           it('should get pipeline aggs', function() {
-              expect(QueryDef.getMetricAggTypes(2).length).to.be(11);
+              expect(queryDef.getMetricAggTypes(2).length).to.be(11);
           });
       });
   });

public/app/plugins/datasource/graphite/gfunc.d.ts

@@ -0,0 +1,2 @@
+declare var test: any;
+export default test;

public/app/plugins/datasource/graphite/specs/datasource_specs.ts

@@ -1,8 +1,7 @@
-///<amd-dependency path="app/plugins/datasource/graphite/datasource" />
-///<amd-dependency path="test/specs/helpers" name="helpers" />
 
+import "../datasource";
 import {describe, beforeEach, it, sinon, expect, angularMocks} from 'test/lib/common';
-declare var helpers: any;
+import helpers from 'test/specs/helpers';
 
 describe('graphiteDatasource', function() {
   var ctx = new helpers.ServiceTestContext();

public/app/plugins/datasource/graphite/specs/gfunc_specs.ts

@@ -1,8 +1,7 @@
 ///<amd-dependency path="app/plugins/datasource/graphite/gfunc" name="gfunc" />
 
 import {describe, beforeEach, it, sinon, expect} from 'test/lib/common';
-
+import gfunc from '../gfunc';
-declare var gfunc: any;
 
 describe('when creating func instance from func names', function() {
   it('should return func instance', function() {

public/app/plugins/datasource/graphite/specs/query_ctrl_specs.ts

@@ -1,12 +1,10 @@
-///<amd-dependency path="app/plugins/datasource/graphite/gfunc" name="gfunc"/>
-///<amd-dependency path="app/plugins/datasource/graphite/query_ctrl" />
-///<amd-dependency path="app/core/services/segment_srv" />
-///<amd-dependency path="test/specs/helpers" name="helpers" />
 
+import '../query_ctrl';
+import 'app/core/services/segment_srv';
 import {describe, beforeEach, it, sinon, expect, angularMocks} from 'test/lib/common';
 
-declare var gfunc: any;
+import * as gfunc from '../gfunc';
-declare var helpers: any;
+import helpers from 'test/specs/helpers';
 
 describe('GraphiteQueryCtrl', function() {
   var ctx = new helpers.ControllerTestContext();

public/app/plugins/datasource/influxdb/influx_series.d.ts

@@ -0,0 +1,2 @@
+declare var test: any;
+export default test;

public/app/plugins/datasource/influxdb/query_builder.d.ts

@@ -0,0 +1,2 @@
+declare var test: any;
+export default test;

public/app/plugins/datasource/influxdb/query_ctrl.js

@@ -11,6 +11,9 @@ function (angular, _, InfluxQueryBuilder, InfluxQuery, queryPart) {
 
   var module = angular.module('grafana.controllers');
 
+  InfluxQuery = InfluxQuery.default;
+  queryPart = queryPart.default;
+
   module.controller('InfluxQueryCtrl', function($scope, templateSrv, $q, uiSegmentSrv) {
 
     $scope.init = function() {

public/app/plugins/datasource/influxdb/specs/influx_query_specs.ts

@@ -1,6 +1,6 @@
 import {describe, beforeEach, it, sinon, expect} from 'test/lib/common';
 
-import InfluxQuery = require('../influx_query');
+import InfluxQuery from '../influx_query';
 
 describe('InfluxQuery', function() {
 

public/app/plugins/datasource/influxdb/specs/influx_series_specs.ts

@@ -1,8 +1,5 @@
-///<amd-dependency path="app/plugins/datasource/influxdb/influx_series" name="InfluxSeries"/>
-
 import {describe, beforeEach, it, sinon, expect} from 'test/lib/common';
-
+import InfluxSeries from '../influx_series';
-declare var InfluxSeries: any;
 
 describe('when generating timeseries from influxdb response', function() {
 

public/app/plugins/datasource/influxdb/specs/query_builder_specs.ts

@@ -1,8 +1,5 @@
-///<amd-dependency path="app/plugins/datasource/influxdb/query_builder" name="InfluxQueryBuilder"/>
-
 import {describe, beforeEach, it, sinon, expect} from 'test/lib/common';
-
+import InfluxQueryBuilder from '../query_builder';
-declare var InfluxQueryBuilder: any;
 
 describe('InfluxQueryBuilder', function() {
 

public/app/plugins/datasource/influxdb/specs/query_ctrl_specs.ts

@@ -1,10 +1,7 @@
-///<amd-dependency path="app/plugins/datasource/influxdb/query_ctrl"/>
+import '../query_ctrl';
-///<amd-dependency path="app/core/services/segment_srv" />
+import 'app/core/services/segment_srv';
-///<amd-dependency path="test/specs/helpers" name="helpers" />
-
 import {describe, beforeEach, it, sinon, expect, angularMocks} from 'test/lib/common';
-
+import helpers from 'test/specs/helpers';
-declare var helpers: any;
 
 describe('InfluxDBQueryCtrl', function() {
   var ctx = new helpers.ControllerTestContext();

public/app/plugins/datasource/influxdb/specs/query_part_specs.ts

@@ -1,7 +1,7 @@
 
 import {describe, beforeEach, it, sinon, expect} from 'test/lib/common';
 
-import queryPart = require('../query_part');
+import queryPart from '../query_part';
 
 describe('InfluxQueryPart', () => {
 

public/app/plugins/datasource/prometheus/specs/datasource_specs.ts

@@ -1,9 +1,7 @@
-///<amd-dependency path="app/plugins/datasource/prometheus/datasource" />
+import '../datasource';
-///<amd-dependency path="test/specs/helpers" name="helpers" />
-
 import {describe, beforeEach, it, sinon, expect, angularMocks} from 'test/lib/common';
-import moment  = require('moment');
+import moment from 'moment';
-declare var helpers: any;
+import helpers from 'test/specs/helpers';
 
 describe('PrometheusDatasource', function() {
 

public/app/plugins/panels/table/specs/renderer_specs.ts

@@ -1,6 +1,6 @@
 import {describe, beforeEach, it, sinon, expect} from 'test/lib/common';
 
-import TableModel = require('app/core/table_model');
+import TableModel from 'app/core/table_model';
 import {TableRenderer} from '../renderer';
 
 describe('when rendering table', () => {

public/app/plugins/panels/table/specs/table_model_specs.ts

@@ -1 +0,0 @@
-

public/app/system.conf.js

@@ -46,5 +46,4 @@ System.config({
       exports: 'angular',
     },
   }
-
 });

public/test/specs/helpers.d.ts

@@ -0,0 +1,6 @@
+declare module "test/specs/helpers" {
+  let helpers: any;
+  export default helpers;
+}
+
+

public/test/specs/row-ctrl-specs.js

@@ -1,18 +0,0 @@
-define([
-  './helpers',
-  'app/features/dashboard/rowCtrl'
-], function(helpers) {
-  'use strict';
-
-  describe('RowCtrl', function() {
-    var ctx = new helpers.ControllerTestContext();
-
-    beforeEach(module('grafana.controllers'));
-
-    beforeEach(ctx.providePhase());
-    beforeEach(ctx.createControllerPhase('RowCtrl'));
-
-  });
-
-});
-

public/test/test-main.js

@@ -1,6 +1,11 @@
 (function() {
   "use strict";
 
+  // Tun on full stack traces in errors to help debugging
+  Error.stackTraceLimit=Infinity;
+
+  window.__karma__.loaded = function() {};
+
   System.config({
     baseURL: '/base/',
     defaultJSExtensions: true,
@@ -49,7 +54,7 @@
         deps: ['jquery'],
         exports: 'angular',
       },
-      'vendor/angular/angular-mocks.js': {
+      'vendor/angular-mocks/angular-mocks.js': {
         format: 'global',
         deps: ['angular'],
       }
@@ -63,23 +68,24 @@
   }
 
   function onlySpecFiles(path) {
-    return /_specs\.js$/.test(path);
+    return /specs.*/.test(path);
   }
 
   window.grafanaBootData = {settings: {}};
 
-  var modules = ['lodash', 'angular', 'angular-mocks', 'app/app'];
+  var modules = ['angular', 'angular-mocks', 'app/app'];
+  var promises = modules.map(function(name) {
+    return System.import(name);
+  });
 
-  Promise.all(
+  Promise.all(promises).then(function(deps) {
-    modules.map(function(moduleName) {
+    var angular = deps[0];
-      return System.import(moduleName);
-    })
-  ).then(function(deps) {
-    var angular = deps[1];
 
     angular.module('grafana', ['ngRoute']);
     angular.module('grafana.services', ['ngRoute', '$strap.directives']);
     angular.module('grafana.panels', []);
+    angular.module('grafana.controllers', []);
+    angular.module('grafana.directives', []);
     angular.module('grafana.filters', []);
     angular.module('grafana.routes', ['ngRoute']);
 
@@ -89,12 +95,15 @@
       .filter(onlySpecFiles)
       .map(file2moduleName)
       .map(function(path) {
+        console.log(path);
         return System.import(path);
       }));
   }).then(function()  {
     window.__karma__.start();
   }, function(error) {
     window.__karma__.error(error.stack || error);
+  }).catch(function(error) {
+    window.__karma__.error(error.stack || error);
   });
 
 })();

public/vendor/npm/angular2/manual_typings/globals-es6.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Declarations angular depends on for compilation to ES6.
+ * This file is also used to propagate our transitive typings
+ * to users.
+ */
+
+/// <reference path="../typings/zone/zone.d.ts"/>
+/// <reference path="../typings/hammerjs/hammerjs.d.ts"/>
+/// <reference path="../typings/jasmine/jasmine.d.ts"/>
+/// <reference path="../typings/angular-protractor/angular-protractor.d.ts"/>
+
+// TODO: ideally the node.d.ts reference should be scoped only for files that need and not to all
+//       the code including client code
+/// <reference path="../typings/node/node.d.ts" />
+
+declare var assert: any;
+
+
+interface BrowserNodeGlobal {
+  Object: typeof Object;
+  Array: typeof Array;
+  Map: typeof Map;
+  Set: typeof Set;
+  Date: typeof Date;
+  RegExp: typeof RegExp;
+  JSON: typeof JSON;
+  Math: typeof Math;
+  assert(condition: any): void;
+  Reflect: any;
+  zone: Zone;
+  getAngularTestability: Function;
+  getAllAngularTestabilities: Function;
+  setTimeout: Function;
+  clearTimeout: Function;
+  setInterval: Function;
+  clearInterval: Function;
+}

public/vendor/npm/angular2/manual_typings/globals.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Declarations angular depends on for compilation to ES6.
+ * This file is also used to propagate our transitive typings
+ * to users.
+ */
+/// <reference path="../typings/es6-shim/es6-shim.d.ts"/>
+/// <reference path="./globals-es6.d.ts"/>

public/vendor/npm/angular2/typings/es6-shim/es6-shim.d.ts

@@ -0,0 +1,668 @@
+// Type definitions for es6-shim v0.31.2
+// Project: https://github.com/paulmillr/es6-shim
+// Definitions by: Ron Buckton <http://github.com/rbuckton>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare type PropertyKey = string | number | symbol;
+
+interface IteratorResult<T> {
+    done: boolean;
+    value?: T;
+}
+
+interface IterableShim<T> {
+    /**
+      * Shim for an ES6 iterable. Not intended for direct use by user code.
+      */
+    "_es6-shim iterator_"(): Iterator<T>;
+}
+
+interface Iterator<T> {
+    next(value?: any): IteratorResult<T>;
+    return?(value?: any): IteratorResult<T>;
+    throw?(e?: any): IteratorResult<T>;
+}
+
+interface IterableIteratorShim<T> extends IterableShim<T>, Iterator<T> {
+    /**
+      * Shim for an ES6 iterable iterator. Not intended for direct use by user code.
+      */
+    "_es6-shim iterator_"(): IterableIteratorShim<T>;
+}
+
+interface StringConstructor {
+    /**
+      * Return the String value whose elements are, in order, the elements in the List elements.
+      * If length is 0, the empty string is returned.
+      */
+    fromCodePoint(...codePoints: number[]): string;
+
+    /**
+      * String.raw is intended for use as a tag function of a Tagged Template String. When called
+      * as such the first argument will be a well formed template call site object and the rest
+      * parameter will contain the substitution values.
+      * @param template A well-formed template string call site representation.
+      * @param substitutions A set of substitution values.
+      */
+    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
+}
+
+interface String {
+    /**
+      * Returns a nonnegative integer Number less than 1114112 (0x110000) that is the code point
+      * value of the UTF-16 encoded code point starting at the string element at position pos in
+      * the String resulting from converting this object to a String.
+      * If there is no element at that position, the result is undefined.
+      * If a valid UTF-16 surrogate pair does not begin at pos, the result is the code unit at pos.
+      */
+    codePointAt(pos: number): number;
+
+    /**
+      * Returns true if searchString appears as a substring of the result of converting this
+      * object to a String, at one or more positions that are
+      * greater than or equal to position; otherwise, returns false.
+      * @param searchString search string
+      * @param position If position is undefined, 0 is assumed, so as to search all of the String.
+      */
+    includes(searchString: string, position?: number): boolean;
+
+    /**
+      * Returns true if the sequence of elements of searchString converted to a String is the
+      * same as the corresponding elements of this object (converted to a String) starting at
+      * endPosition – length(this). Otherwise returns false.
+      */
+    endsWith(searchString: string, endPosition?: number): boolean;
+
+    /**
+      * Returns a String value that is made from count copies appended together. If count is 0,
+      * T is the empty String is returned.
+      * @param count number of copies to append
+      */
+    repeat(count: number): string;
+
+    /**
+      * Returns true if the sequence of elements of searchString converted to a String is the
+      * same as the corresponding elements of this object (converted to a String) starting at
+      * position. Otherwise returns false.
+      */
+    startsWith(searchString: string, position?: number): boolean;
+
+    /**
+      * Returns an <a> HTML anchor element and sets the name attribute to the text value
+      * @param name
+      */
+    anchor(name: string): string;
+
+    /** Returns a <big> HTML element */
+    big(): string;
+
+    /** Returns a <blink> HTML element */
+    blink(): string;
+
+    /** Returns a <b> HTML element */
+    bold(): string;
+
+    /** Returns a <tt> HTML element */
+    fixed(): string
+
+    /** Returns a <font> HTML element and sets the color attribute value */
+    fontcolor(color: string): string
+
+    /** Returns a <font> HTML element and sets the size attribute value */
+    fontsize(size: number): string;
+
+    /** Returns a <font> HTML element and sets the size attribute value */
+    fontsize(size: string): string;
+
+    /** Returns an <i> HTML element */
+    italics(): string;
+
+    /** Returns an <a> HTML element and sets the href attribute value */
+    link(url: string): string;
+
+    /** Returns a <small> HTML element */
+    small(): string;
+
+    /** Returns a <strike> HTML element */
+    strike(): string;
+
+    /** Returns a <sub> HTML element */
+    sub(): string;
+
+    /** Returns a <sup> HTML element */
+    sup(): string;
+
+    /**
+      * Shim for an ES6 iterable. Not intended for direct use by user code.
+      */
+    "_es6-shim iterator_"(): IterableIteratorShim<string>;
+}
+
+interface ArrayConstructor {
+    /**
+      * Creates an array from an array-like object.
+      * @param arrayLike An array-like object to convert to an array.
+      * @param mapfn A mapping function to call on every element of the array.
+      * @param thisArg Value of 'this' used to invoke the mapfn.
+      */
+    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): Array<U>;
+
+    /**
+      * Creates an array from an iterable object.
+      * @param iterable An iterable object to convert to an array.
+      * @param mapfn A mapping function to call on every element of the array.
+      * @param thisArg Value of 'this' used to invoke the mapfn.
+      */
+    from<T, U>(iterable: IterableShim<T>, mapfn: (v: T, k: number) => U, thisArg?: any): Array<U>;
+
+    /**
+      * Creates an array from an array-like object.
+      * @param arrayLike An array-like object to convert to an array.
+      */
+    from<T>(arrayLike: ArrayLike<T>): Array<T>;
+
+    /**
+      * Creates an array from an iterable object.
+      * @param iterable An iterable object to convert to an array.
+      */
+    from<T>(iterable: IterableShim<T>): Array<T>;
+
+    /**
+      * Returns a new array from a set of elements.
+      * @param items A set of elements to include in the new array object.
+      */
+    of<T>(...items: T[]): Array<T>;
+}
+
+interface Array<T> {
+    /**
+      * Returns the value of the first element in the array where predicate is true, and undefined
+      * otherwise.
+      * @param predicate find calls predicate once for each element of the array, in ascending
+      * order, until it finds one where predicate returns true. If such an element is found, find
+      * immediately returns that element value. Otherwise, find returns undefined.
+      * @param thisArg If provided, it will be used as the this value for each invocation of
+      * predicate. If it is not provided, undefined is used instead.
+      */
+    find(predicate: (value: T, index: number, obj: Array<T>) => boolean, thisArg?: any): T;
+
+    /**
+      * Returns the index of the first element in the array where predicate is true, and undefined
+      * otherwise.
+      * @param predicate find calls predicate once for each element of the array, in ascending
+      * order, until it finds one where predicate returns true. If such an element is found, find
+      * immediately returns that element value. Otherwise, find returns undefined.
+      * @param thisArg If provided, it will be used as the this value for each invocation of
+      * predicate. If it is not provided, undefined is used instead.
+      */
+    findIndex(predicate: (value: T) => boolean, thisArg?: any): number;
+
+    /**
+      * Returns the this object after filling the section identified by start and end with value
+      * @param value value to fill array section with
+      * @param start index to start filling the array at. If start is negative, it is treated as
+      * length+start where length is the length of the array.
+      * @param end index to stop filling the array at. If end is negative, it is treated as
+      * length+end.
+      */
+    fill(value: T, start?: number, end?: number): T[];
+
+    /**
+      * Returns the this object after copying a section of the array identified by start and end
+      * to the same array starting at position target
+      * @param target If target is negative, it is treated as length+target where length is the
+      * length of the array.
+      * @param start If start is negative, it is treated as length+start. If end is negative, it
+      * is treated as length+end.
+      * @param end If not specified, length of the this object is used as its default value.
+      */
+    copyWithin(target: number, start: number, end?: number): T[];
+
+    /**
+      * Returns an array of key, value pairs for every entry in the array
+      */
+    entries(): IterableIteratorShim<[number, T]>;
+
+    /**
+      * Returns an list of keys in the array
+      */
+    keys(): IterableIteratorShim<number>;
+
+    /**
+      * Returns an list of values in the array
+      */
+    values(): IterableIteratorShim<T>;
+
+    /**
+      * Shim for an ES6 iterable. Not intended for direct use by user code.
+      */
+    "_es6-shim iterator_"(): IterableIteratorShim<T>;
+}
+
+interface NumberConstructor {
+    /**
+      * The value of Number.EPSILON is the difference between 1 and the smallest value greater than 1
+      * that is representable as a Number value, which is approximately:
+      * 2.2204460492503130808472633361816 x 10‍−‍16.
+      */
+    EPSILON: number;
+
+    /**
+      * Returns true if passed value is finite.
+      * Unlike the global isFininte, Number.isFinite doesn't forcibly convert the parameter to a
+      * number. Only finite values of the type number, result in true.
+      * @param number A numeric value.
+      */
+    isFinite(number: number): boolean;
+
+    /**
+      * Returns true if the value passed is an integer, false otherwise.
+      * @param number A numeric value.
+      */
+    isInteger(number: number): boolean;
+
+    /**
+      * Returns a Boolean value that indicates whether a value is the reserved value NaN (not a
+      * number). Unlike the global isNaN(), Number.isNaN() doesn't forcefully convert the parameter
+      * to a number. Only values of the type number, that are also NaN, result in true.
+      * @param number A numeric value.
+      */
+    isNaN(number: number): boolean;
+
+    /**
+      * Returns true if the value passed is a safe integer.
+      * @param number A numeric value.
+      */
+    isSafeInteger(number: number): boolean;
+
+    /**
+      * The value of the largest integer n such that n and n + 1 are both exactly representable as
+      * a Number value.
+      * The value of Number.MIN_SAFE_INTEGER is 9007199254740991 2^53 − 1.
+      */
+    MAX_SAFE_INTEGER: number;
+
+    /**
+      * The value of the smallest integer n such that n and n − 1 are both exactly representable as
+      * a Number value.
+      * The value of Number.MIN_SAFE_INTEGER is −9007199254740991 (−(2^53 − 1)).
+      */
+    MIN_SAFE_INTEGER: number;
+
+    /**
+      * Converts a string to a floating-point number.
+      * @param string A string that contains a floating-point number.
+      */
+    parseFloat(string: string): number;
+
+    /**
+      * Converts A string to an integer.
+      * @param s A string to convert into a number.
+      * @param radix A value between 2 and 36 that specifies the base of the number in numString.
+      * If this argument is not supplied, strings with a prefix of '0x' are considered hexadecimal.
+      * All other strings are considered decimal.
+      */
+    parseInt(string: string, radix?: number): number;
+}
+
+interface ObjectConstructor {
+    /**
+      * Copy the values of all of the enumerable own properties from one or more source objects to a
+      * target object. Returns the target object.
+      * @param target The target object to copy to.
+      * @param sources One or more source objects to copy properties from.
+      */
+    assign(target: any, ...sources: any[]): any;
+
+    /**
+      * Returns true if the values are the same value, false otherwise.
+      * @param value1 The first value.
+      * @param value2 The second value.
+      */
+    is(value1: any, value2: any): boolean;
+
+    /**
+      * Sets the prototype of a specified object o to  object proto or null. Returns the object o.
+      * @param o The object to change its prototype.
+      * @param proto The value of the new prototype or null.
+      * @remarks Requires `__proto__` support.
+      */
+    setPrototypeOf(o: any, proto: any): any;
+}
+
+interface RegExp {
+    /**
+      * Returns a string indicating the flags of the regular expression in question. This field is read-only.
+      * The characters in this string are sequenced and concatenated in the following order:
+      *
+      *    - "g" for global
+      *    - "i" for ignoreCase
+      *    - "m" for multiline
+      *    - "u" for unicode
+      *    - "y" for sticky
+      *
+      * If no flags are set, the value is the empty string.
+      */
+    flags: string;
+}
+
+interface Math {
+    /**
+      * Returns the number of leading zero bits in the 32-bit binary representation of a number.
+      * @param x A numeric expression.
+      */
+    clz32(x: number): number;
+
+    /**
+      * Returns the result of 32-bit multiplication of two numbers.
+      * @param x First number
+      * @param y Second number
+      */
+    imul(x: number, y: number): number;
+
+    /**
+      * Returns the sign of the x, indicating whether x is positive, negative or zero.
+      * @param x The numeric expression to test
+      */
+    sign(x: number): number;
+
+    /**
+      * Returns the base 10 logarithm of a number.
+      * @param x A numeric expression.
+      */
+    log10(x: number): number;
+
+    /**
+      * Returns the base 2 logarithm of a number.
+      * @param x A numeric expression.
+      */
+    log2(x: number): number;
+
+    /**
+      * Returns the natural logarithm of 1 + x.
+      * @param x A numeric expression.
+      */
+    log1p(x: number): number;
+
+    /**
+      * Returns the result of (e^x - 1) of x (e raised to the power of x, where e is the base of
+      * the natural logarithms).
+      * @param x A numeric expression.
+      */
+    expm1(x: number): number;
+
+    /**
+      * Returns the hyperbolic cosine of a number.
+      * @param x A numeric expression that contains an angle measured in radians.
+      */
+    cosh(x: number): number;
+
+    /**
+      * Returns the hyperbolic sine of a number.
+      * @param x A numeric expression that contains an angle measured in radians.
+      */
+    sinh(x: number): number;
+
+    /**
+      * Returns the hyperbolic tangent of a number.
+      * @param x A numeric expression that contains an angle measured in radians.
+      */
+    tanh(x: number): number;
+
+    /**
+      * Returns the inverse hyperbolic cosine of a number.
+      * @param x A numeric expression that contains an angle measured in radians.
+      */
+    acosh(x: number): number;
+
+    /**
+      * Returns the inverse hyperbolic sine of a number.
+      * @param x A numeric expression that contains an angle measured in radians.
+      */
+    asinh(x: number): number;
+
+    /**
+      * Returns the inverse hyperbolic tangent of a number.
+      * @param x A numeric expression that contains an angle measured in radians.
+      */
+    atanh(x: number): number;
+
+    /**
+      * Returns the square root of the sum of squares of its arguments.
+      * @param values Values to compute the square root for.
+      *     If no arguments are passed, the result is +0.
+      *     If there is only one argument, the result is the absolute value.
+      *     If any argument is +Infinity or -Infinity, the result is +Infinity.
+      *     If any argument is NaN, the result is NaN.
+      *     If all arguments are either +0 or −0, the result is +0.
+      */
+    hypot(...values: number[]): number;
+
+    /**
+      * Returns the integral part of the a numeric expression, x, removing any fractional digits.
+      * If x is already an integer, the result is x.
+      * @param x A numeric expression.
+      */
+    trunc(x: number): number;
+
+    /**
+      * Returns the nearest single precision float representation of a number.
+      * @param x A numeric expression.
+      */
+    fround(x: number): number;
+
+    /**
+      * Returns an implementation-dependent approximation to the cube root of number.
+      * @param x A numeric expression.
+      */
+    cbrt(x: number): number;
+}
+
+interface PromiseLike<T> {
+    /**
+    * Attaches callbacks for the resolution and/or rejection of the Promise.
+    * @param onfulfilled The callback to execute when the Promise is resolved.
+    * @param onrejected The callback to execute when the Promise is rejected.
+    * @returns A Promise for the completion of which ever callback is executed.
+    */
+    then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): PromiseLike<TResult>;
+    then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => void): PromiseLike<TResult>;
+}
+
+/**
+ * Represents the completion of an asynchronous operation
+ */
+interface Promise<T> {
+    /**
+    * Attaches callbacks for the resolution and/or rejection of the Promise.
+    * @param onfulfilled The callback to execute when the Promise is resolved.
+    * @param onrejected The callback to execute when the Promise is rejected.
+    * @returns A Promise for the completion of which ever callback is executed.
+    */
+    then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>;
+    then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => void): Promise<TResult>;
+
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of the callback.
+     */
+    catch(onrejected?: (reason: any) => T | PromiseLike<T>): Promise<T>;
+    catch(onrejected?: (reason: any) => void): Promise<T>;
+}
+
+interface PromiseConstructor {
+    /**
+      * A reference to the prototype.
+      */
+    prototype: Promise<any>;
+
+    /**
+     * Creates a new Promise.
+     * @param executor A callback used to initialize the promise. This callback is passed two arguments:
+     * a resolve callback used resolve the promise with a value or the result of another promise,
+     * and a reject callback used to reject the promise with a provided reason or error.
+     */
+    new <T>(executor: (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
+
+    /**
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
+     * resolve, or rejected when any Promise is rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    all<T>(values: IterableShim<T | PromiseLike<T>>): Promise<T[]>;
+
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    race<T>(values: IterableShim<T | PromiseLike<T>>): Promise<T>;
+
+    /**
+     * Creates a new rejected promise for the provided reason.
+     * @param reason The reason the promise was rejected.
+     * @returns A new rejected Promise.
+     */
+    reject(reason: any): Promise<void>;
+
+    /**
+     * Creates a new rejected promise for the provided reason.
+     * @param reason The reason the promise was rejected.
+     * @returns A new rejected Promise.
+     */
+    reject<T>(reason: any): Promise<T>;
+
+    /**
+      * Creates a new resolved promise for the provided value.
+      * @param value A promise.
+      * @returns A promise whose internal state matches the provided promise.
+      */
+    resolve<T>(value: T | PromiseLike<T>): Promise<T>;
+
+    /**
+     * Creates a new resolved promise .
+     * @returns A resolved promise.
+     */
+    resolve(): Promise<void>;
+}
+
+declare var Promise: PromiseConstructor;
+
+interface Map<K, V> {
+    clear(): void;
+    delete(key: K): boolean;
+    forEach(callbackfn: (value: V, index: K, map: Map<K, V>) => void, thisArg?: any): void;
+    get(key: K): V;
+    has(key: K): boolean;
+    set(key: K, value?: V): Map<K, V>;
+    size: number;
+    entries(): IterableIteratorShim<[K, V]>;
+    keys(): IterableIteratorShim<K>;
+    values(): IterableIteratorShim<V>;
+}
+
+interface MapConstructor {
+    new <K, V>(): Map<K, V>;
+    new <K, V>(iterable: IterableShim<[K, V]>): Map<K, V>;
+    prototype: Map<any, any>;
+}
+
+declare var Map: MapConstructor;
+
+interface Set<T> {
+    add(value: T): Set<T>;
+    clear(): void;
+    delete(value: T): boolean;
+    forEach(callbackfn: (value: T, index: T, set: Set<T>) => void, thisArg?: any): void;
+    has(value: T): boolean;
+    size: number;
+    entries(): IterableIteratorShim<[T, T]>;
+    keys(): IterableIteratorShim<T>;
+    values(): IterableIteratorShim<T>;
+}
+
+interface SetConstructor {
+    new <T>(): Set<T>;
+    new <T>(iterable: IterableShim<T>): Set<T>;
+    prototype: Set<any>;
+}
+
+declare var Set: SetConstructor;
+
+interface WeakMap<K, V> {
+    delete(key: K): boolean;
+    get(key: K): V;
+    has(key: K): boolean;
+    set(key: K, value?: V): WeakMap<K, V>;
+}
+
+interface WeakMapConstructor {
+    new <K, V>(): WeakMap<K, V>;
+    new <K, V>(iterable: IterableShim<[K, V]>): WeakMap<K, V>;
+    prototype: WeakMap<any, any>;
+}
+
+declare var WeakMap: WeakMapConstructor;
+
+interface WeakSet<T> {
+    add(value: T): WeakSet<T>;
+    delete(value: T): boolean;
+    has(value: T): boolean;
+}
+
+interface WeakSetConstructor {
+    new <T>(): WeakSet<T>;
+    new <T>(iterable: IterableShim<T>): WeakSet<T>;
+    prototype: WeakSet<any>;
+}
+
+declare var WeakSet: WeakSetConstructor;
+
+declare module Reflect {
+    function apply(target: Function, thisArgument: any, argumentsList: ArrayLike<any>): any;
+    function construct(target: Function, argumentsList: ArrayLike<any>): any;
+    function defineProperty(target: any, propertyKey: PropertyKey, attributes: PropertyDescriptor): boolean;
+    function deleteProperty(target: any, propertyKey: PropertyKey): boolean;
+    function enumerate(target: any): IterableIteratorShim<any>;
+    function get(target: any, propertyKey: PropertyKey, receiver?: any): any;
+    function getOwnPropertyDescriptor(target: any, propertyKey: PropertyKey): PropertyDescriptor;
+    function getPrototypeOf(target: any): any;
+    function has(target: any, propertyKey: PropertyKey): boolean;
+    function isExtensible(target: any): boolean;
+    function ownKeys(target: any): Array<PropertyKey>;
+    function preventExtensions(target: any): boolean;
+    function set(target: any, propertyKey: PropertyKey, value: any, receiver?: any): boolean;
+    function setPrototypeOf(target: any, proto: any): boolean;
+}
+
+declare module "es6-shim" {
+    var String: StringConstructor;
+    var Array: ArrayConstructor;
+    var Number: NumberConstructor;
+    var Math: Math;
+    var Object: ObjectConstructor;
+    var Map: MapConstructor;
+    var Set: SetConstructor;
+    var WeakMap: WeakMapConstructor;
+    var WeakSet: WeakSetConstructor;
+    var Promise: PromiseConstructor;
+    module Reflect {
+        function apply(target: Function, thisArgument: any, argumentsList: ArrayLike<any>): any;
+        function construct(target: Function, argumentsList: ArrayLike<any>): any;
+        function defineProperty(target: any, propertyKey: PropertyKey, attributes: PropertyDescriptor): boolean;
+        function deleteProperty(target: any, propertyKey: PropertyKey): boolean;
+        function enumerate(target: any): Iterator<any>;
+        function get(target: any, propertyKey: PropertyKey, receiver?: any): any;
+        function getOwnPropertyDescriptor(target: any, propertyKey: PropertyKey): PropertyDescriptor;
+        function getPrototypeOf(target: any): any;
+        function has(target: any, propertyKey: PropertyKey): boolean;
+        function isExtensible(target: any): boolean;
+        function ownKeys(target: any): Array<PropertyKey>;
+        function preventExtensions(target: any): boolean;
+        function set(target: any, propertyKey: PropertyKey, value: any, receiver?: any): boolean;
+        function setPrototypeOf(target: any, proto: any): boolean;
+    }
+}

public/vendor/npm/angular2/typings/hammerjs/hammerjs.d.ts

@@ -0,0 +1,331 @@
+// Type definitions for Hammer.js 2.0.4
+// Project: http://hammerjs.github.io/
+// Definitions by: Philip Bulley <https://github.com/milkisevil/>, Han Lin Yap <https://github.com/codler>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare var Hammer:HammerStatic;
+
+declare module "Hammer" {
+    export = Hammer;
+}
+
+interface HammerStatic
+{
+  new( element:HTMLElement, options?:any ): HammerManager;
+
+  defaults:HammerDefaults;
+
+  VERSION: number;
+
+  INPUT_START:  number;
+  INPUT_MOVE:   number;
+  INPUT_END:    number;
+  INPUT_CANCEL: number;
+
+  STATE_POSSIBLE:   number;
+  STATE_BEGAN:      number;
+  STATE_CHANGED:    number;
+  STATE_ENDED:      number;
+  STATE_RECOGNIZED: number;
+  STATE_CANCELLED:  number;
+  STATE_FAILED:     number;
+
+  DIRECTION_NONE:       number;
+  DIRECTION_LEFT:       number;
+  DIRECTION_RIGHT:      number;
+  DIRECTION_UP:         number;
+  DIRECTION_DOWN:       number;
+  DIRECTION_HORIZONTAL: number;
+  DIRECTION_VERTICAL:   number;
+  DIRECTION_ALL:        number;
+
+  Manager:     HammerManager;
+  Input:       HammerInput;
+  TouchAction: TouchAction;
+
+  TouchInput:        TouchInput;
+  MouseInput:        MouseInput;
+  PointerEventInput: PointerEventInput;
+  TouchMouseInput:   TouchMouseInput;
+  SingleTouchInput:  SingleTouchInput;
+
+  Recognizer:     RecognizerStatic;
+  AttrRecognizer: AttrRecognizerStatic;
+  Tap:            TapRecognizerStatic;
+  Pan:            PanRecognizerStatic;
+  Swipe:          SwipeRecognizerStatic;
+  Pinch:          PinchRecognizerStatic;
+  Rotate:         RotateRecognizerStatic;
+  Press:          PressRecognizerStatic;
+
+  on( target:EventTarget, types:string, handler:Function ):void;
+  off( target:EventTarget, types:string, handler:Function ):void;
+  each( obj:any, iterator:Function, context:any ):     void;
+  merge( dest:any, src:any ):    any;
+  extend( dest:any, src:any, merge:boolean ):   any;
+  inherit( child:Function, base:Function, properties:any ):any;
+  bindFn( fn:Function, context:any ):Function;
+  prefixed( obj:any, property:string ):string;
+}
+
+interface HammerDefaults
+{
+  domEvents:boolean;
+  enable:boolean;
+  preset:any[];
+  touchAction:string;
+  cssProps:CssProps;
+
+  inputClass():void;
+  inputTarget():void;
+}
+
+interface CssProps
+{
+  contentZooming:string;
+  tapHighlightColor:string;
+  touchCallout:string;
+  touchSelect:string;
+  userDrag:string;
+  userSelect:string;
+}
+
+interface HammerOptions extends HammerDefaults
+{
+
+}
+
+interface HammerManager
+{
+  new( element:HTMLElement, options?:any ):HammerManager;
+
+  add( recogniser:Recognizer ):Recognizer;
+  add( recogniser:Recognizer ):HammerManager;
+  add( recogniser:Recognizer[] ):Recognizer;
+  add( recogniser:Recognizer[] ):HammerManager;
+  destroy():void;
+  emit( event:string, data:any ):void;
+  get( recogniser:Recognizer ):Recognizer;
+  get( recogniser:string ):Recognizer;
+  off( events:string, handler:( event:HammerInput ) => void ):void;
+  on( events:string, handler:( event:HammerInput ) => void ):void;
+  recognize( inputData:any ):void;
+  remove( recogniser:Recognizer ):HammerManager;
+  remove( recogniser:string ):HammerManager;
+  set( options:HammerOptions ):HammerManager;
+  stop( force:boolean ):void;
+}
+
+declare class HammerInput
+{
+  constructor( manager:HammerManager, callback:Function );
+
+  destroy():void;
+  handler():void;
+  init():void;
+
+  /** Name of the event. Like panstart. */
+  type:string;
+
+  /** Movement of the X axis. */
+  deltaX:number;
+
+  /** Movement of the Y axis. */
+  deltaY:number;
+
+  /** Total time in ms since the first input. */
+  deltaTime:number;
+
+  /** Distance moved. */
+  distance:number;
+
+  /** Angle moved. */
+  angle:number;
+
+  /** Velocity on the X axis, in px/ms. */
+  velocityX:number;
+
+  /** Velocity on the Y axis, in px/ms */
+  velocityY:number;
+
+  /** Highest velocityX/Y value. */
+  velocity:number;
+
+  /** Direction moved. Matches the DIRECTION constants. */
+  direction:number;
+
+  /** Direction moved from it's starting point. Matches the DIRECTION constants. */
+  offsetDirection:string;
+
+  /** Scaling that has been done when multi-touch. 1 on a single touch. */
+  scale:number;
+
+  /** Rotation that has been done when multi-touch. 0 on a single touch. */
+  rotation:number;
+
+  /** Center position for multi-touch, or just the single pointer. */
+  center:HammerPoint;
+
+  /** Source event object, type TouchEvent, MouseEvent or PointerEvent. */
+  srcEvent:TouchEvent | MouseEvent | PointerEvent;
+
+  /** Target that received the event. */
+  target:HTMLElement;
+
+  /** Primary pointer type, could be touch, mouse, pen or kinect. */
+  pointerType:string;
+
+  /** Event type, matches the INPUT constants. */
+  eventType:string;
+
+  /** true when the first input. */
+  isFirst:boolean;
+
+  /** true when the final (last) input. */
+  isFinal:boolean;
+
+  /** Array with all pointers, including the ended pointers (touchend, mouseup). */
+  pointers:any[];
+
+  /** Array with all new/moved/lost pointers. */
+  changedPointers:any[];
+
+  /** Reference to the srcEvent.preventDefault() method. Only for experts! */
+  preventDefault:Function;
+}
+
+declare class MouseInput extends HammerInput
+{
+  constructor( manager:HammerManager, callback:Function );
+}
+
+declare class PointerEventInput extends HammerInput
+{
+  constructor( manager:HammerManager, callback:Function );
+}
+
+declare class SingleTouchInput extends HammerInput
+{
+  constructor( manager:HammerManager, callback:Function );
+}
+
+declare class TouchInput extends HammerInput
+{
+  constructor( manager:HammerManager, callback:Function );
+}
+
+declare class TouchMouseInput extends HammerInput
+{
+  constructor( manager:HammerManager, callback:Function );
+}
+
+interface RecognizerStatic
+{
+  new( options?:any ):Recognizer;
+}
+
+interface Recognizer
+{
+  defaults:any;
+
+  canEmit():boolean;
+  canRecognizeWith( otherRecognizer:Recognizer ):boolean;
+  dropRecognizeWith( otherRecognizer:Recognizer ):Recognizer;
+  dropRecognizeWith( otherRecognizer:string ):Recognizer;
+  dropRequireFailure( otherRecognizer:Recognizer ):Recognizer;
+  dropRequireFailure( otherRecognizer:string ):Recognizer;
+  emit( input:HammerInput ):void;
+  getTouchAction():any[];
+  hasRequireFailures():boolean;
+  process( inputData:HammerInput ):string;
+  recognize( inputData:HammerInput ):void;
+  recognizeWith( otherRecognizer:Recognizer ):Recognizer;
+  recognizeWith( otherRecognizer:string ):Recognizer;
+  requireFailure( otherRecognizer:Recognizer ):Recognizer;
+  requireFailure( otherRecognizer:string ):Recognizer;
+  reset():void;
+  set( options?:any ):Recognizer;
+  tryEmit( input:HammerInput ):void;
+}
+
+interface AttrRecognizerStatic
+{
+  attrTest( input:HammerInput ):boolean;
+  process( input:HammerInput ):any;
+}
+
+interface AttrRecognizer extends Recognizer
+{
+  new( options?:any ):AttrRecognizer;
+}
+
+interface PanRecognizerStatic
+{
+  new( options?:any ):PanRecognizer;
+}
+
+interface PanRecognizer extends AttrRecognizer
+{
+}
+
+interface PinchRecognizerStatic
+{
+  new( options?:any ):PinchRecognizer;
+}
+
+interface PinchRecognizer extends AttrRecognizer
+{
+}
+
+interface PressRecognizerStatic
+{
+  new( options?:any ):PressRecognizer;
+}
+
+interface PressRecognizer extends AttrRecognizer
+{
+}
+
+interface RotateRecognizerStatic
+{
+  new( options?:any ):RotateRecognizer;
+}
+
+interface RotateRecognizer extends AttrRecognizer
+{
+}
+
+interface SwipeRecognizerStatic
+{
+  new( options?:any ):SwipeRecognizer;
+}
+
+interface SwipeRecognizer
+{
+}
+
+interface TapRecognizerStatic
+{
+  new( options?:any ):TapRecognizer;
+}
+
+interface TapRecognizer extends AttrRecognizer
+{
+}
+
+declare class TouchAction
+{
+  constructor( manager:HammerManager, value:string );
+
+  compute():string;
+  preventDefaults( input:HammerInput ):void;
+  preventSrc( srcEvent:any ):void;
+  set( value:string ):void;
+  update():void;
+}
+
+interface HammerPoint
+{
+  x: number;
+  y: number;
+}

public/vendor/npm/angular2/typings/jasmine/jasmine.d.ts

@@ -0,0 +1,534 @@
+// Type definitions for Jasmine 2.2
+// Project: http://jasmine.github.io/
+// Definitions by: Boris Yankov <https://github.com/borisyankov/>, Theodore Brown <https://github.com/theodorejb>, David Pärsson <https://github.com/davidparsson/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+
+// For ddescribe / iit use : https://github.com/borisyankov/DefinitelyTyped/blob/master/karma-jasmine/karma-jasmine.d.ts
+
+declare function describe(description: string, specDefinitions: () => void): void;
+declare function fdescribe(description: string, specDefinitions: () => void): void;
+declare function xdescribe(description: string, specDefinitions: () => void): void;
+
+declare function it(expectation: string, assertion?: () => void, timeout?: number): void;
+declare function it(expectation: string, assertion?: (done: () => void) => void, timeout?: number): void;
+declare function fit(expectation: string, assertion?: () => void, timeout?: number): void;
+declare function fit(expectation: string, assertion?: (done: () => void) => void, timeout?: number): void;
+declare function xit(expectation: string, assertion?: () => void, timeout?: number): void;
+declare function xit(expectation: string, assertion?: (done: () => void) => void, timeout?: number): void;
+
+/** If you call the function pending anywhere in the spec body, no matter the expectations, the spec will be marked pending. */
+declare function pending(reason?: string): void;
+
+declare function beforeEach(action: () => void, timeout?: number): void;
+declare function beforeEach(action: (done: () => void) => void, timeout?: number): void;
+declare function afterEach(action: () => void, timeout?: number): void;
+declare function afterEach(action: (done: () => void) => void, timeout?: number): void;
+
+declare function beforeAll(action: () => void, timeout?: number): void;
+declare function beforeAll(action: (done: () => void) => void, timeout?: number): void;
+declare function afterAll(action: () => void, timeout?: number): void;
+declare function afterAll(action: (done: () => void) => void, timeout?: number): void;
+
+declare function expect(spy: Function): jasmine.Matchers;
+declare function expect(actual: any): jasmine.Matchers;
+
+declare function fail(e?: any): void;
+
+declare function spyOn(object: any, method: string): jasmine.Spy;
+
+declare function runs(asyncMethod: Function): void;
+declare function waitsFor(latchMethod: () => boolean, failureMessage?: string, timeout?: number): void;
+declare function waits(timeout?: number): void;
+
+declare module jasmine {
+
+    var clock: () => Clock;
+
+    function any(aclass: any): Any;
+    function anything(): Any;
+    function arrayContaining(sample: any[]): ArrayContaining;
+    function objectContaining(sample: any): ObjectContaining;
+    function createSpy(name: string, originalFn?: Function): Spy;
+    function createSpyObj(baseName: string, methodNames: any[]): any;
+    function createSpyObj<T>(baseName: string, methodNames: any[]): T;
+    function pp(value: any): string;
+    function getEnv(): Env;
+    function addCustomEqualityTester(equalityTester: CustomEqualityTester): void;
+    function addMatchers(matchers: CustomMatcherFactories): void;
+    function stringMatching(str: string): Any;
+    function stringMatching(str: RegExp): Any;
+
+    interface Any {
+
+        new (expectedClass: any): any;
+
+        jasmineMatches(other: any): boolean;
+        jasmineToString(): string;
+    }
+
+    // taken from TypeScript lib.core.es6.d.ts, applicable to CustomMatchers.contains()
+    interface ArrayLike<T> {
+        length: number;
+        [n: number]: T;
+    }
+
+    interface ArrayContaining {
+        new (sample: any[]): any;
+
+        asymmetricMatch(other: any): boolean;
+        jasmineToString(): string;
+    }
+
+    interface ObjectContaining {
+        new (sample: any): any;
+
+        jasmineMatches(other: any, mismatchKeys: any[], mismatchValues: any[]): boolean;
+        jasmineToString(): string;
+    }
+
+    interface Block {
+
+        new (env: Env, func: SpecFunction, spec: Spec): any;
+
+        execute(onComplete: () => void): void;
+    }
+
+    interface WaitsBlock extends Block {
+        new (env: Env, timeout: number, spec: Spec): any;
+    }
+
+    interface WaitsForBlock extends Block {
+        new (env: Env, timeout: number, latchFunction: SpecFunction, message: string, spec: Spec): any;
+    }
+
+    interface Clock {
+        install(): void;
+        uninstall(): void;
+        /** Calls to any registered callback are triggered when the clock is ticked forward via the jasmine.clock().tick function, which takes a number of milliseconds. */
+        tick(ms: number): void;
+        mockDate(date?: Date): void;
+    }
+
+    interface CustomEqualityTester {
+        (first: any, second: any): boolean;
+    }
+
+    interface CustomMatcher {
+        compare<T>(actual: T, expected: T): CustomMatcherResult;
+        compare(actual: any, expected: any): CustomMatcherResult;
+    }
+
+    interface CustomMatcherFactory {
+        (util: MatchersUtil, customEqualityTesters: Array<CustomEqualityTester>): CustomMatcher;
+    }
+
+    interface CustomMatcherFactories {
+        [index: string]: CustomMatcherFactory;
+    }
+
+    interface CustomMatcherResult {
+        pass: boolean;
+        message?: string;
+    }
+
+    interface MatchersUtil {
+        equals(a: any, b: any, customTesters?: Array<CustomEqualityTester>): boolean;
+        contains<T>(haystack: ArrayLike<T> | string, needle: any, customTesters?: Array<CustomEqualityTester>): boolean;
+        buildFailureMessage(matcherName: string, isNot: boolean, actual: any, ...expected: Array<any>): string;
+    }
+
+    interface Env {
+        setTimeout: any;
+        clearTimeout: void;
+        setInterval: any;
+        clearInterval: void;
+        updateInterval: number;
+
+        currentSpec: Spec;
+
+        matchersClass: Matchers;
+
+        version(): any;
+        versionString(): string;
+        nextSpecId(): number;
+        addReporter(reporter: Reporter): void;
+        execute(): void;
+        describe(description: string, specDefinitions: () => void): Suite;
+        // ddescribe(description: string, specDefinitions: () => void): Suite; Not a part of jasmine. Angular team adds these
+        beforeEach(beforeEachFunction: () => void): void;
+        beforeAll(beforeAllFunction: () => void): void;
+        currentRunner(): Runner;
+        afterEach(afterEachFunction: () => void): void;
+        afterAll(afterAllFunction: () => void): void;
+        xdescribe(desc: string, specDefinitions: () => void): XSuite;
+        it(description: string, func: () => void): Spec;
+        // iit(description: string, func: () => void): Spec; Not a part of jasmine. Angular team adds these
+        xit(desc: string, func: () => void): XSpec;
+        compareRegExps_(a: RegExp, b: RegExp, mismatchKeys: string[], mismatchValues: string[]): boolean;
+        compareObjects_(a: any, b: any, mismatchKeys: string[], mismatchValues: string[]): boolean;
+        equals_(a: any, b: any, mismatchKeys: string[], mismatchValues: string[]): boolean;
+        contains_(haystack: any, needle: any): boolean;
+        addCustomEqualityTester(equalityTester: CustomEqualityTester): void;
+        addMatchers(matchers: CustomMatcherFactories): void;
+        specFilter(spec: Spec): boolean;
+    }
+
+    interface FakeTimer {
+
+        new (): any;
+
+        reset(): void;
+        tick(millis: number): void;
+        runFunctionsWithinRange(oldMillis: number, nowMillis: number): void;
+        scheduleFunction(timeoutKey: any, funcToCall: () => void, millis: number, recurring: boolean): void;
+    }
+
+    interface HtmlReporter {
+        new (): any;
+    }
+
+    interface HtmlSpecFilter {
+        new (): any;
+    }
+
+    interface Result {
+        type: string;
+    }
+
+    interface NestedResults extends Result {
+        description: string;
+
+        totalCount: number;
+        passedCount: number;
+        failedCount: number;
+
+        skipped: boolean;
+
+        rollupCounts(result: NestedResults): void;
+        log(values: any): void;
+        getItems(): Result[];
+        addResult(result: Result): void;
+        passed(): boolean;
+    }
+
+    interface MessageResult extends Result  {
+        values: any;
+        trace: Trace;
+    }
+
+    interface ExpectationResult extends Result  {
+        matcherName: string;
+        passed(): boolean;
+        expected: any;
+        actual: any;
+        message: string;
+        trace: Trace;
+    }
+
+    interface Trace {
+        name: string;
+        message: string;
+        stack: any;
+    }
+
+    interface PrettyPrinter {
+
+        new (): any;
+
+        format(value: any): void;
+        iterateObject(obj: any, fn: (property: string, isGetter: boolean) => void): void;
+        emitScalar(value: any): void;
+        emitString(value: string): void;
+        emitArray(array: any[]): void;
+        emitObject(obj: any): void;
+        append(value: any): void;
+    }
+
+    interface StringPrettyPrinter extends PrettyPrinter {
+    }
+
+    interface Queue {
+
+        new (env: any): any;
+
+        env: Env;
+        ensured: boolean[];
+        blocks: Block[];
+        running: boolean;
+        index: number;
+        offset: number;
+        abort: boolean;
+
+        addBefore(block: Block, ensure?: boolean): void;
+        add(block: any, ensure?: boolean): void;
+        insertNext(block: any, ensure?: boolean): void;
+        start(onComplete?: () => void): void;
+        isRunning(): boolean;
+        next_(): void;
+        results(): NestedResults;
+    }
+
+    interface Matchers {
+
+        new (env: Env, actual: any, spec: Env, isNot?: boolean): any;
+
+        env: Env;
+        actual: any;
+        spec: Env;
+        isNot?: boolean;
+        message(): any;
+
+        (expected: any): boolean;
+        toBe(expected: any, expectationFailOutput?: any): boolean;
+        toEqual(expected: any, expectationFailOutput?: any): boolean;
+        toMatch(expected: any, expectationFailOutput?: any): boolean;
+        toBeDefined(expectationFailOutput?: any): boolean;
+        toBeUndefined(expectationFailOutput?: any): boolean;
+        toBeNull(expectationFailOutput?: any): boolean;
+        toBeNaN(): boolean;
+        toBeTruthy(expectationFailOutput?: any): boolean;
+        toBeFalsy(expectationFailOutput?: any): boolean;
+        toHaveBeenCalled(): boolean;
+        toHaveBeenCalledWith(...params: any[]): boolean;
+        toContain(expected: any, expectationFailOutput?: any): boolean;
+        toBeLessThan(expected: any, expectationFailOutput?: any): boolean;
+        toBeGreaterThan(expected: any, expectationFailOutput?: any): boolean;
+        toBeCloseTo(expected: any, precision: any, expectationFailOutput?: any): boolean;
+        toContainHtml(expected: string): boolean;
+        toContainText(expected: string): boolean;
+        toThrow(expected?: any): boolean;
+        toThrowError(expected?: any, message?: string): boolean;
+        not: Matchers;
+
+        Any: Any;
+    }
+
+    interface Reporter {
+        reportRunnerStarting(runner: Runner): void;
+        reportRunnerResults(runner: Runner): void;
+        reportSuiteResults(suite: Suite): void;
+        reportSpecStarting(spec: Spec): void;
+        reportSpecResults(spec: Spec): void;
+        log(str: string): void;
+    }
+
+    interface MultiReporter extends Reporter {
+        addReporter(reporter: Reporter): void;
+    }
+
+    interface Runner {
+
+        new (env: Env): any;
+
+        execute(): void;
+        beforeEach(beforeEachFunction: SpecFunction): void;
+        afterEach(afterEachFunction: SpecFunction): void;
+        beforeAll(beforeAllFunction: SpecFunction): void;
+        afterAll(afterAllFunction: SpecFunction): void;
+        finishCallback(): void;
+        addSuite(suite: Suite): void;
+        add(block: Block): void;
+        specs(): Spec[];
+        suites(): Suite[];
+        topLevelSuites(): Suite[];
+        results(): NestedResults;
+    }
+
+    interface SpecFunction {
+        (spec?: Spec): void;
+    }
+
+    interface SuiteOrSpec {
+        id: number;
+        env: Env;
+        description: string;
+        queue: Queue;
+    }
+
+    interface Spec extends SuiteOrSpec {
+
+        new (env: Env, suite: Suite, description: string): any;
+
+        suite: Suite;
+
+        afterCallbacks: SpecFunction[];
+        spies_: Spy[];
+
+        results_: NestedResults;
+        matchersClass: Matchers;
+
+        getFullName(): string;
+        results(): NestedResults;
+        log(arguments: any): any;
+        runs(func: SpecFunction): Spec;
+        addToQueue(block: Block): void;
+        addMatcherResult(result: Result): void;
+        expect(actual: any): any;
+        waits(timeout: number): Spec;
+        waitsFor(latchFunction: SpecFunction, timeoutMessage?: string, timeout?: number): Spec;
+        fail(e?: any): void;
+        getMatchersClass_(): Matchers;
+        addMatchers(matchersPrototype: CustomMatcherFactories): void;
+        finishCallback(): void;
+        finish(onComplete?: () => void): void;
+        after(doAfter: SpecFunction): void;
+        execute(onComplete?: () => void): any;
+        addBeforesAndAftersToQueue(): void;
+        explodes(): void;
+        spyOn(obj: any, methodName: string, ignoreMethodDoesntExist: boolean): Spy;
+        removeAllSpies(): void;
+    }
+
+    interface XSpec {
+        id: number;
+        runs(): void;
+    }
+
+    interface Suite extends SuiteOrSpec {
+
+        new (env: Env, description: string, specDefinitions: () => void, parentSuite: Suite): any;
+
+        parentSuite: Suite;
+
+        getFullName(): string;
+        finish(onComplete?: () => void): void;
+        beforeEach(beforeEachFunction: SpecFunction): void;
+        afterEach(afterEachFunction: SpecFunction): void;
+        beforeAll(beforeAllFunction: SpecFunction): void;
+        afterAll(afterAllFunction: SpecFunction): void;
+        results(): NestedResults;
+        add(suiteOrSpec: SuiteOrSpec): void;
+        specs(): Spec[];
+        suites(): Suite[];
+        children(): any[];
+        execute(onComplete?: () => void): void;
+    }
+
+    interface XSuite {
+        execute(): void;
+    }
+
+    interface Spy {
+        (...params: any[]): any;
+
+        identity: string;
+        and: SpyAnd;
+        calls: Calls;
+        mostRecentCall: { args: any[]; };
+        argsForCall: any[];
+        wasCalled: boolean;
+        callCount: number;
+    }
+
+    interface SpyAnd {
+        /** By chaining the spy with and.callThrough, the spy will still track all calls to it but in addition it will delegate to the actual implementation. */
+        callThrough(): Spy;
+        /** By chaining the spy with and.returnValue, all calls to the function will return a specific value. */
+        returnValue(val: any): void;
+        /** By chaining the spy with and.callFake, all calls to the spy will delegate to the supplied function. */
+        callFake(fn: Function): Spy;
+        /** By chaining the spy with and.throwError, all calls to the spy will throw the specified value. */
+        throwError(msg: string): void;
+        /** When a calling strategy is used for a spy, the original stubbing behavior can be returned at any time with and.stub. */
+        stub(): Spy;
+    }
+
+    interface Calls {
+        /** By chaining the spy with calls.any(), will return false if the spy has not been called at all, and then true once at least one call happens. **/
+        any(): boolean;
+        /** By chaining the spy with calls.count(), will return the number of times the spy was called **/
+        count(): number;
+        /** By chaining the spy with calls.argsFor(), will return the arguments passed to call number index **/
+        argsFor(index: number): any[];
+        /** By chaining the spy with calls.allArgs(), will return the arguments to all calls **/
+        allArgs(): any[];
+        /** By chaining the spy with calls.all(), will return the context (the this) and arguments passed all calls **/
+        all(): CallInfo[];
+        /** By chaining the spy with calls.mostRecent(), will return the context (the this) and arguments for the most recent call **/
+        mostRecent(): CallInfo;
+        /** By chaining the spy with calls.first(), will return the context (the this) and arguments for the first call **/
+        first(): CallInfo;
+        /** By chaining the spy with calls.reset(), will clears all tracking for a spy **/
+        reset(): void;
+    }
+
+    interface CallInfo {
+        /** The context (the this) for the call */
+        object: any;
+        /** All arguments passed to the call */
+        args: any[];
+    }
+
+    interface Util {
+        inherit(childClass: Function, parentClass: Function): any;
+        formatException(e: any): any;
+        htmlEscape(str: string): string;
+        argsToArray(args: any): any;
+        extend(destination: any, source: any): any;
+    }
+
+    interface JsApiReporter extends Reporter {
+
+        started: boolean;
+        finished: boolean;
+        result: any;
+        messages: any;
+
+        new (): any;
+
+        suites(): Suite[];
+        summarize_(suiteOrSpec: SuiteOrSpec): any;
+        results(): any;
+        resultsForSpec(specId: any): any;
+        log(str: any): any;
+        resultsForSpecs(specIds: any): any;
+        summarizeResult_(result: any): any;
+    }
+
+    interface Jasmine {
+        Spec: Spec;
+        clock: Clock;
+        util: Util;
+    }
+
+    export var HtmlReporter: HtmlReporter;
+    export var HtmlSpecFilter: HtmlSpecFilter;
+    export var DEFAULT_TIMEOUT_INTERVAL: number;
+
+    export interface GlobalPolluter {
+        describe(description: string, specDefinitions: () => void): void;
+        fdescribe(description: string, specDefinitions: () => void): void;
+        xdescribe(description: string, specDefinitions: () => void): void;
+
+        it(expectation: string, assertion?: () => void): void;
+        it(expectation: string, assertion?: (done: () => void) => void): void;
+        fit(expectation: string, assertion?: () => void): void;
+        fit(expectation: string, assertion?: (done: () => void) => void): void;
+        xit(expectation: string, assertion?: () => void): void;
+        xit(expectation: string, assertion?: (done: () => void) => void): void;
+
+        pending(): void;
+
+        beforeEach(action: () => void): void;
+        beforeEach(action: (done: () => void) => void): void;
+        afterEach(action: () => void): void;
+        afterEach(action: (done: () => void) => void): void;
+
+        beforeAll(action: () => void): void;
+        beforeAll(action: (done: () => void) => void): void;
+        afterAll(action: () => void): void;
+        afterAll(action: (done: () => void) => void): void;
+
+        expect(spy: Function): jasmine.Matchers;
+        expect(actual: any): jasmine.Matchers;
+
+        fail(e?: any): void;
+
+        spyOn(object: any, method: string): jasmine.Spy;
+
+        runs(asyncMethod: Function): void;
+        waitsFor(latchMethod: () => boolean, failureMessage?: string, timeout?: number): void;
+        waits(timeout?: number): void;
+    }
+}

public/vendor/npm/angular2/typings/tsd.d.ts

@@ -0,0 +1,7 @@
+/// <reference path="angular-protractor/angular-protractor.d.ts" />
+/// <reference path="es6-shim/es6-shim.d.ts" />
+/// <reference path="hammerjs/hammerjs.d.ts" />
+/// <reference path="jasmine/jasmine.d.ts" />
+/// <reference path="node/node.d.ts" />
+/// <reference path="selenium-webdriver/selenium-webdriver.d.ts" />
+/// <reference path="zone/zone.d.ts" />

public/vendor/npm/angular2/typings/zone/zone.d.ts

@@ -0,0 +1,15 @@
+/// <reference path="../es6-shim/es6-shim.d.ts" />
+
+declare class Zone {
+    constructor(parentZone: Zone, data: any);
+
+    fork(locals: {[key: string]: any}): Zone;
+    bind(fn: Function, skipEnqueue?: boolean): void;
+    bindOnce(fn: Function): any;
+    run(fn: Function, applyTo?: any, applyWith?: any): void;
+    isRootZone(): boolean;
+
+    static bindPromiseFn<T extends () => Promise<any>>(fn: T): T;
+
+    static longStackTraceZone: {[key: string]: any};
+}

tasks/options/copy.js

@@ -21,6 +21,8 @@ module.exports = function(config) {
       src: [
         'angular2/bundles/*.js',
         'angular2/*.d.ts',
+        'angular2/typings/**/*',
+        'angular2/manual_typings/**/*',
         'systemjs/dist/*.js',
         'es6-promise/**/*',
         'es5-shim/*.js',

tasks/options/karma.js

@@ -6,14 +6,17 @@ module.exports = function(config) {
       configFile: 'karma.conf.js',
       singleRun: false,
     },
+
     debug: {
       configFile: 'karma.conf.js',
       singleRun: false,
       browsers: ['Chrome']
     },
+
     test: {
       configFile: 'karma.conf.js',
     },
+
     coveralls: {
       configFile: 'karma.conf.js',
       reporters: ['dots','coverage','coveralls'],

tasks/options/typescript.js

@@ -3,7 +3,7 @@ module.exports = function() {
 
   return {
     build: {
-      src: ['public/app/**/*.ts', "!public/vendor/**/*", "!**/*_specs.ts", "!**/*.d.ts"],
+      src: ['public/app/**/*.ts', "!public/vendor/**/*", "!**/*.d.ts"],
       dest: 'public_gen/',
       options: {
         module: 'system', //or commonjs