text: /******/ (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) {
  
  	'use strict';
  	(function () {
  	    var NEWLINE = '\n';
  	    var SEP = '  -------------  ';
  	    var IGNORE_FRAMES = [];
  	    var creationTrace = '__creationTrace__';
  	    var LongStackTrace = (function () {
  	        function LongStackTrace() {
  	            this.error = getStacktrace();
  	            this.timestamp = new Date();
  	        }
  	        return LongStackTrace;
  	    }());
  	    function getStacktraceWithUncaughtError() {
  	        return new Error('STACKTRACE TRACKING');
  	    }
  	    function getStacktraceWithCaughtError() {
  	        try {
  	            throw getStacktraceWithUncaughtError();
  	        }
  	        catch (e) {
  	            return e;
  	        }
  	    }
  	    // Some implementations of exception handling don't create a stack trace if the exception
  	    // isn't thrown, however it's faster not to actually throw the exception.
  	    var error = getStacktraceWithUncaughtError();
  	    var coughtError = getStacktraceWithCaughtError();
  	    var getStacktrace = error.stack
  	        ? getStacktraceWithUncaughtError
  	        : (coughtError.stack ? getStacktraceWithCaughtError : getStacktraceWithUncaughtError);
  	    function getFrames(error) {
  	        return error.stack ? error.stack.split(NEWLINE) : [];
  	    }
  	    function addErrorStack(lines, error) {
  	        var trace = getFrames(error);
  	        for (var i = 0; i < trace.length; i++) {
  	            var frame = trace[i];
  	            // Filter out the Frames which are part of stack capturing.
  	            if (!(i < IGNORE_FRAMES.length && IGNORE_FRAMES[i] === frame)) {
  	                lines.push(trace[i]);
  	            }
  	        }
  	    }
  	    function renderLongStackTrace(frames, stack) {
  	        var longTrace = [stack];
  	        if (frames) {
  	            var timestamp = new Date().getTime();
  	            for (var i = 0; i < frames.length; i++) {
  	                var traceFrames = frames[i];
  	                var lastTime = traceFrames.timestamp;
  	                longTrace.push(SEP + " Elapsed: " + (timestamp - lastTime.getTime()) + " ms; At: " + lastTime + " " + SEP);
  	                addErrorStack(longTrace, traceFrames.error);
  	                timestamp = lastTime.getTime();
  	            }
  	        }
  	        return longTrace.join(NEWLINE);
  	    }
  	    Zone['longStackTraceZoneSpec'] = {
  	        name: 'long-stack-trace',
  	        longStackTraceLimit: 10,
  	        onScheduleTask: function (parentZoneDelegate, currentZone, targetZone, task) {
  	            var currentTask = Zone.currentTask;
  	            var trace = currentTask && currentTask.data && currentTask.data[creationTrace] || [];
  	            trace = [new LongStackTrace()].concat(trace);
  	            if (trace.length > this.longStackTraceLimit) {
  	                trace.length = this.longStackTraceLimit;
  	            }
  	            if (!task.data)
  	                task.data = {};
  	            task.data[creationTrace] = trace;
  	            return parentZoneDelegate.scheduleTask(targetZone, task);
  	        },
  	        onHandleError: function (parentZoneDelegate, currentZone, targetZone, error) {
  	            var parentTask = Zone.currentTask;
  	            if (error instanceof Error && parentTask) {
  	                var descriptor = Object.getOwnPropertyDescriptor(error, 'stack');
  	                if (descriptor) {
  	                    var delegateGet_1 = descriptor.get;
  	                    var value_1 = descriptor.value;
  	                    descriptor = {
  	                        get: function () {
  	                            return renderLongStackTrace(parentTask.data && parentTask.data[creationTrace], delegateGet_1 ? delegateGet_1.apply(this) : value_1);
  	                        }
  	                    };
  	                    Object.defineProperty(error, 'stack', descriptor);
  	                }
  	                else {
  	                    error.stack = renderLongStackTrace(parentTask.data && parentTask.data[creationTrace], error.stack);
  	                }
  	            }
  	            return parentZoneDelegate.handleError(targetZone, error);
  	        }
  	    };
  	    function captureStackTraces(stackTraces, count) {
  	        if (count > 0) {
  	            stackTraces.push(getFrames((new LongStackTrace()).error));
  	            captureStackTraces(stackTraces, count - 1);
  	        }
  	    }
  	    function computeIgnoreFrames() {
  	        var frames = [];
  	        captureStackTraces(frames, 2);
  	        var frames1 = frames[0];
  	        var frames2 = frames[1];
  	        for (var i = 0; i < frames1.length; i++) {
  	            var frame1 = frames1[i];
  	            var frame2 = frames2[i];
  	            if (frame1 === frame2) {
  	                IGNORE_FRAMES.push(frame1);
  	            }
  	            else {
  	                break;
  	            }
  	        }
  	    }
  	    computeIgnoreFrames();
  	})();
  
  
  /***/ }
  /******/ ]);