webpackJsonp([0],{

/***/ 0:
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var core_1 = __webpack_require__(1);
	var browser_1 = __webpack_require__(113);
	var store_1 = __webpack_require__(226);
	var notification_1 = __webpack_require__(241);
	var app_ts_1 = __webpack_require__(243);
	var ENV_PROVIDERS = [];
	// depending on the env mode, enable prod mode or add debugging modules
	if (false) {
	    core_1.enableProdMode();
	}
	else {
	    ENV_PROVIDERS.push(browser_1.ELEMENT_PROBE_PROVIDERS);
	}
	document.addEventListener('DOMContentLoaded', function () {
	    return browser_1.bootstrap(app_ts_1.App, ENV_PROVIDERS.concat([
	        store_1.provideStore({ notifications: notification_1.showupReducer }, { notifications: [
	                { type: 'error', message: 'This is an error', id: '1' },
	                { type: 'alert', message: 'This is a message', id: '2' }
	            ] })
	    ]))
	        .catch(function (err) { return console.error(err); });
	});


/***/ },

/***/ 226:
/***/ 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__(227));
	__export(__webpack_require__(233));
	__export(__webpack_require__(234));
	__export(__webpack_require__(235));
	__export(__webpack_require__(240));


/***/ },

/***/ 227:
/***/ 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 BehaviorSubject_1 = __webpack_require__(228);
	__webpack_require__(229);
	__webpack_require__(231);
	var Store = (function (_super) {
	    __extends(Store, _super);
	    function Store(_dispatcher, _backend, initialState) {
	        var _this = this;
	        _super.call(this, initialState);
	        this._dispatcher = _dispatcher;
	        this._backend = _backend;
	        _backend.connect(function (state) { return _super.prototype.next.call(_this, state); });
	    }
	    Store.prototype.select = function (keyOrSelector) {
	        if (typeof keyOrSelector === 'string' ||
	            typeof keyOrSelector === 'number' ||
	            typeof keyOrSelector === 'symbol') {
	            return this.map(function (state) { return state[keyOrSelector]; }).distinctUntilChanged();
	        }
	        else if (typeof keyOrSelector === 'function') {
	            return this.map(keyOrSelector).distinctUntilChanged();
	        }
	        else {
	            throw new TypeError("Store@select Unknown Parameter Type: "
	                + ("Expected type of function or valid key type, got " + typeof keyOrSelector));
	        }
	    };
	    Store.prototype.getState = function () {
	        return this.value;
	    };
	    Store.prototype.dispatch = function (action) {
	        this._dispatcher.dispatch(action);
	    };
	    Store.prototype.next = function (action) {
	        this._dispatcher.next(action);
	    };
	    Store.prototype.error = function (error) {
	        this._dispatcher.error(error);
	    };
	    Store.prototype.replaceReducer = function (reducer) {
	        this._backend.replaceReducer(reducer);
	    };
	    return Store;
	}(BehaviorSubject_1.BehaviorSubject));
	exports.Store = Store;


/***/ },

/***/ 228:
/***/ 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 Subject_1 = __webpack_require__(48);
	var throwError_1 = __webpack_require__(64);
	var ObjectUnsubscribedError_1 = __webpack_require__(65);
	/**
	 * @class BehaviorSubject<T>
	 */
	var BehaviorSubject = (function (_super) {
	    __extends(BehaviorSubject, _super);
	    function BehaviorSubject(_value) {
	        _super.call(this);
	        this._value = _value;
	    }
	    BehaviorSubject.prototype.getValue = function () {
	        if (this.hasErrored) {
	            throwError_1.throwError(this.errorValue);
	        }
	        else if (this.isUnsubscribed) {
	            throwError_1.throwError(new ObjectUnsubscribedError_1.ObjectUnsubscribedError());
	        }
	        else {
	            return this._value;
	        }
	    };
	    Object.defineProperty(BehaviorSubject.prototype, "value", {
	        get: function () {
	            return this.getValue();
	        },
	        enumerable: true,
	        configurable: true
	    });
	    BehaviorSubject.prototype._subscribe = function (subscriber) {
	        var subscription = _super.prototype._subscribe.call(this, subscriber);
	        if (subscription && !subscription.isUnsubscribed) {
	            subscriber.next(this._value);
	        }
	        return subscription;
	    };
	    BehaviorSubject.prototype._next = function (value) {
	        _super.prototype._next.call(this, this._value = value);
	    };
	    BehaviorSubject.prototype._error = function (err) {
	        this.hasErrored = true;
	        _super.prototype._error.call(this, this.errorValue = err);
	    };
	    return BehaviorSubject;
	}(Subject_1.Subject));
	exports.BehaviorSubject = BehaviorSubject;
	//# sourceMappingURL=BehaviorSubject.js.map

/***/ },

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

	"use strict";
	var Observable_1 = __webpack_require__(49);
	var map_1 = __webpack_require__(230);
	Observable_1.Observable.prototype.map = map_1.map;
	//# sourceMappingURL=map.js.map

/***/ },

/***/ 230:
/***/ 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 Subscriber_1 = __webpack_require__(54);
	/**
	 * Similar to the well known `Array.prototype.map` function, this operator
	 * applies a projection to each value and emits that projection in the returned observable
	 *
	 * <img src="./img/map.png" width="100%">
	 *
	 * @param {Function} project the function to create projection
	 * @param {any} [thisArg] an optional argument to define what `this` is in the project function
	 * @return {Observable} a observable of projected values
	 * @method map
	 * @owner Observable
	 */
	function map(project, thisArg) {
	    if (typeof project !== 'function') {
	        throw new TypeError('argument is not a function. Are you looking for `mapTo()`?');
	    }
	    return this.lift(new MapOperator(project, thisArg));
	}
	exports.map = map;
	var MapOperator = (function () {
	    function MapOperator(project, thisArg) {
	        this.project = project;
	        this.thisArg = thisArg;
	    }
	    MapOperator.prototype.call = function (subscriber) {
	        return new MapSubscriber(subscriber, this.project, this.thisArg);
	    };
	    return MapOperator;
	}());
	var MapSubscriber = (function (_super) {
	    __extends(MapSubscriber, _super);
	    function MapSubscriber(destination, project, thisArg) {
	        _super.call(this, destination);
	        this.project = project;
	        this.count = 0;
	        this.thisArg = thisArg || this;
	    }
	    // NOTE: This looks unoptimized, but it's actually purposefully NOT
	    // using try/catch optimizations.
	    MapSubscriber.prototype._next = function (value) {
	        var result;
	        try {
	            result = this.project.call(this.thisArg, value, this.count++);
	        }
	        catch (err) {
	            this.destination.error(err);
	            return;
	        }
	        this.destination.next(result);
	    };
	    return MapSubscriber;
	}(Subscriber_1.Subscriber));
	//# sourceMappingURL=map.js.map

/***/ },

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

	"use strict";
	var Observable_1 = __webpack_require__(49);
	var distinctUntilChanged_1 = __webpack_require__(232);
	Observable_1.Observable.prototype.distinctUntilChanged = distinctUntilChanged_1.distinctUntilChanged;
	//# sourceMappingURL=distinctUntilChanged.js.map

/***/ },

/***/ 232:
/***/ 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 Subscriber_1 = __webpack_require__(54);
	var tryCatch_1 = __webpack_require__(59);
	var errorObject_1 = __webpack_require__(60);
	/**
	 * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from the previous item.
	 * If a comparator function is provided, then it will be called for each item to test for whether or not that value should be emitted.
	 * If a comparator function is not provided, an equality check is used by default.
	 * @param {function} [compare] optional comparison function called to test if an item is distinct from the previous item in the source.
	 * @return {Observable} an Observable that emits items from the source Observable with distinct values.
	 * @method distinctUntilChanged
	 * @owner Observable
	 */
	function distinctUntilChanged(compare, keySelector) {
	    return this.lift(new DistinctUntilChangedOperator(compare, keySelector));
	}
	exports.distinctUntilChanged = distinctUntilChanged;
	var DistinctUntilChangedOperator = (function () {
	    function DistinctUntilChangedOperator(compare, keySelector) {
	        this.compare = compare;
	        this.keySelector = keySelector;
	    }
	    DistinctUntilChangedOperator.prototype.call = function (subscriber) {
	        return new DistinctUntilChangedSubscriber(subscriber, this.compare, this.keySelector);
	    };
	    return DistinctUntilChangedOperator;
	}());
	var DistinctUntilChangedSubscriber = (function (_super) {
	    __extends(DistinctUntilChangedSubscriber, _super);
	    function DistinctUntilChangedSubscriber(destination, compare, keySelector) {
	        _super.call(this, destination);
	        this.keySelector = keySelector;
	        this.hasKey = false;
	        if (typeof compare === 'function') {
	            this.compare = compare;
	        }
	    }
	    DistinctUntilChangedSubscriber.prototype.compare = function (x, y) {
	        return x === y;
	    };
	    DistinctUntilChangedSubscriber.prototype._next = function (value) {
	        var keySelector = this.keySelector;
	        var key = value;
	        if (keySelector) {
	            key = tryCatch_1.tryCatch(this.keySelector)(value);
	            if (key === errorObject_1.errorObject) {
	                return this.destination.error(errorObject_1.errorObject.e);
	            }
	        }
	        var result = false;
	        if (this.hasKey) {
	            result = tryCatch_1.tryCatch(this.compare)(this.key, key);
	            if (result === errorObject_1.errorObject) {
	                return this.destination.error(errorObject_1.errorObject.e);
	            }
	        }
	        else {
	            this.hasKey = true;
	        }
	        if (Boolean(result) === false) {
	            this.key = key;
	            this.destination.next(value);
	        }
	    };
	    return DistinctUntilChangedSubscriber;
	}(Subscriber_1.Subscriber));
	//# sourceMappingURL=distinctUntilChanged.js.map

/***/ },

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

	"use strict";
	function combineReducers(reducers) {
	    var reducerKeys = Object.keys(reducers);
	    var finalReducers = {};
	    for (var i = 0; i < reducerKeys.length; i++) {
	        var key = reducerKeys[i];
	        if (typeof reducers[key] === 'function') {
	            finalReducers[key] = reducers[key];
	        }
	    }
	    var finalReducerKeys = Object.keys(finalReducers);
	    return function combination(state, action) {
	        if (state === void 0) { state = {}; }
	        var hasChanged = false;
	        var nextState = {};
	        for (var i = 0; i < finalReducerKeys.length; i++) {
	            var key = finalReducerKeys[i];
	            var reducer = finalReducers[key];
	            var previousStateForKey = state[key];
	            var nextStateForKey = reducer(previousStateForKey, action);
	            nextState[key] = nextStateForKey;
	            hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
	        }
	        return hasChanged ? nextState : state;
	    };
	}
	exports.combineReducers = combineReducers;
	exports.compose = function () {
	    var funcs = [];
	    for (var _i = 0; _i < arguments.length; _i++) {
	        funcs[_i - 0] = arguments[_i];
	    }
	    return function () {
	        var args = [];
	        for (var _i = 0; _i < arguments.length; _i++) {
	            args[_i - 0] = arguments[_i];
	        }
	        if (funcs.length === 0) {
	            return args[0];
	        }
	        var last = funcs[funcs.length - 1];
	        var rest = funcs.slice(0, -1);
	        return rest.reduceRight(function (composed, f) { return f(composed); }, last.apply(void 0, args));
	    };
	};


/***/ },

/***/ 234:
/***/ 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 Subject_1 = __webpack_require__(48);
	var Dispatcher = (function (_super) {
	    __extends(Dispatcher, _super);
	    function Dispatcher() {
	        _super.apply(this, arguments);
	    }
	    Dispatcher.prototype.dispatch = function (action) {
	        this.next(action);
	    };
	    return Dispatcher;
	}(Subject_1.Subject));
	exports.Dispatcher = Dispatcher;


/***/ },

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

	"use strict";
	__webpack_require__(236);
	__webpack_require__(238);
	exports.ActionTypes = {
	    INIT: '@@ngrx/INIT'
	};
	var StoreBackend = (function () {
	    function StoreBackend(_dispatcher, _reducer, _initialState, _preMiddleware, _postMiddleware) {
	        if (_preMiddleware === void 0) { _preMiddleware = function (t) { return t; }; }
	        if (_postMiddleware === void 0) { _postMiddleware = function (t) { return t; }; }
	        this._dispatcher = _dispatcher;
	        this._reducer = _reducer;
	        this._initialState = _initialState;
	        this._preMiddleware = _preMiddleware;
	        this._postMiddleware = _postMiddleware;
	    }
	    StoreBackend.prototype._init = function () {
	        this._dispatcher.dispatch({ type: exports.ActionTypes.INIT });
	    };
	    StoreBackend.prototype.connect = function (nextCallbackFn) {
	        var _this = this;
	        this._dispatcher
	            .let(this._preMiddleware)
	            .scan(function (state, action) { return _this._reducer(state, action); }, this._initialState)
	            .let(this._postMiddleware)
	            .subscribe(nextCallbackFn);
	        this._init();
	    };
	    StoreBackend.prototype.replaceReducer = function (reducer) {
	        this._reducer = reducer;
	        this._init();
	    };
	    return StoreBackend;
	}());
	exports.StoreBackend = StoreBackend;


/***/ },

/***/ 236:
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var Observable_1 = __webpack_require__(49);
	var let_1 = __webpack_require__(237);
	Observable_1.Observable.prototype.let = let_1.letProto;
	Observable_1.Observable.prototype.letBind = let_1.letProto;
	//# sourceMappingURL=let.js.map

/***/ },

/***/ 237:
/***/ function(module, exports) {

	"use strict";
	/**
	 * @param func
	 * @return {Observable<R>}
	 * @method let
	 * @owner Observable
	 */
	function letProto(func) {
	    return func(this);
	}
	exports.letProto = letProto;
	//# sourceMappingURL=let.js.map

/***/ },

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

	"use strict";
	var Observable_1 = __webpack_require__(49);
	var scan_1 = __webpack_require__(239);
	Observable_1.Observable.prototype.scan = scan_1.scan;
	//# sourceMappingURL=scan.js.map

/***/ },

/***/ 239:
/***/ 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 Subscriber_1 = __webpack_require__(54);
	/**
	 * Returns an Observable that applies a specified accumulator function to each item emitted by the source Observable.
	 * If a seed value is specified, then that value will be used as the initial value for the accumulator.
	 * If no seed value is specified, the first item of the source is used as the seed.
	 * @param {function} accumulator The accumulator function called on each item.
	 *
	 * <img src="./img/scan.png" width="100%">
	 *
	 * @param {any} [seed] The initial accumulator value.
	 * @return {Obervable} An observable of the accumulated values.
	 * @method scan
	 * @owner Observable
	 */
	function scan(accumulator, seed) {
	    return this.lift(new ScanOperator(accumulator, seed));
	}
	exports.scan = scan;
	var ScanOperator = (function () {
	    function ScanOperator(accumulator, seed) {
	        this.accumulator = accumulator;
	        this.seed = seed;
	    }
	    ScanOperator.prototype.call = function (subscriber) {
	        return new ScanSubscriber(subscriber, this.accumulator, this.seed);
	    };
	    return ScanOperator;
	}());
	var ScanSubscriber = (function (_super) {
	    __extends(ScanSubscriber, _super);
	    function ScanSubscriber(destination, accumulator, seed) {
	        _super.call(this, destination);
	        this.accumulator = accumulator;
	        this.accumulatorSet = false;
	        this.seed = seed;
	        this.accumulator = accumulator;
	        this.accumulatorSet = typeof seed !== 'undefined';
	    }
	    Object.defineProperty(ScanSubscriber.prototype, "seed", {
	        get: function () {
	            return this._seed;
	        },
	        set: function (value) {
	            this.accumulatorSet = true;
	            this._seed = value;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    ScanSubscriber.prototype._next = function (value) {
	        if (!this.accumulatorSet) {
	            this.seed = value;
	            this.destination.next(value);
	        }
	        else {
	            return this._tryNext(value);
	        }
	    };
	    ScanSubscriber.prototype._tryNext = function (value) {
	        var result;
	        try {
	            result = this.accumulator(this.seed, value);
	        }
	        catch (err) {
	            this.destination.error(err);
	        }
	        this.seed = result;
	        this.destination.next(result);
	    };
	    return ScanSubscriber;
	}(Subscriber_1.Subscriber));
	//# sourceMappingURL=scan.js.map

/***/ },

/***/ 240:
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var core_1 = __webpack_require__(1);
	var dispatcher_1 = __webpack_require__(234);
	var store_1 = __webpack_require__(227);
	var store_backend_1 = __webpack_require__(235);
	var utils_1 = __webpack_require__(233);
	exports.PRE_MIDDLEWARE = new core_1.OpaqueToken('ngrx/store/pre-middleware');
	exports.POST_MIDDLEWARE = new core_1.OpaqueToken('ngrx/store/post-middleware');
	exports.RESOLVED_PRE_MIDDLEWARE = new core_1.OpaqueToken('ngrx/store/resolved-pre-middleware');
	exports.RESOLVED_POST_MIDDLEWARE = new core_1.OpaqueToken('ngrx/store/resolved-post-middleware');
	exports.REDUCER = new core_1.OpaqueToken('ngrx/store/reducer');
	exports.INITIAL_STATE = new core_1.OpaqueToken('ngrx/store/initial-state');
	var dispatcherProvider = core_1.provide(dispatcher_1.Dispatcher, {
	    useFactory: function () {
	        return new dispatcher_1.Dispatcher();
	    }
	});
	var storeProvider = core_1.provide(store_1.Store, {
	    deps: [dispatcher_1.Dispatcher, store_backend_1.StoreBackend, exports.INITIAL_STATE],
	    useFactory: function (dispatcher, backend, initialState) {
	        return new store_1.Store(dispatcher, backend, initialState);
	    }
	});
	var storeBackendProvider = core_1.provide(store_backend_1.StoreBackend, {
	    deps: [dispatcher_1.Dispatcher, exports.REDUCER, exports.INITIAL_STATE, exports.RESOLVED_PRE_MIDDLEWARE, exports.RESOLVED_POST_MIDDLEWARE],
	    useFactory: function (dispatcher, reducer, initialState, preMiddleware, postMiddleware) {
	        return new store_backend_1.StoreBackend(dispatcher, reducer, initialState, preMiddleware, postMiddleware);
	    }
	});
	var resolvedPreMiddlewareProvider = core_1.provide(exports.RESOLVED_PRE_MIDDLEWARE, {
	    deps: [exports.PRE_MIDDLEWARE],
	    useFactory: function (middleware) {
	        return utils_1.compose.apply(void 0, middleware);
	    }
	});
	var resolvedPostMiddlewareProvider = core_1.provide(exports.RESOLVED_POST_MIDDLEWARE, {
	    deps: [exports.POST_MIDDLEWARE],
	    useFactory: function (middleware) {
	        return utils_1.compose.apply(void 0, middleware);
	    }
	});
	function provideStore(reducer, initialState) {
	    return [
	        core_1.provide(exports.REDUCER, {
	            useFactory: function () {
	                if (typeof reducer === 'function') {
	                    return reducer;
	                }
	                return utils_1.combineReducers(reducer);
	            }
	        }),
	        core_1.provide(exports.INITIAL_STATE, {
	            deps: [exports.REDUCER],
	            useFactory: function (reducer) {
	                if (initialState === undefined) {
	                    return reducer(undefined, { type: store_backend_1.ActionTypes.INIT });
	                }
	                return initialState;
	            }
	        }),
	        core_1.provide(exports.PRE_MIDDLEWARE, { multi: true, useValue: (function (T) { return T; }) }),
	        core_1.provide(exports.POST_MIDDLEWARE, { multi: true, useValue: (function (T) { return T; }) }),
	        dispatcherProvider,
	        storeProvider,
	        storeBackendProvider,
	        resolvedPreMiddlewareProvider,
	        resolvedPostMiddlewareProvider
	    ];
	}
	exports.provideStore = provideStore;
	function usePreMiddleware() {
	    var middleware = [];
	    for (var _i = 0; _i < arguments.length; _i++) {
	        middleware[_i - 0] = arguments[_i];
	    }
	    return provideMiddlewareForToken(exports.PRE_MIDDLEWARE, middleware);
	}
	exports.usePreMiddleware = usePreMiddleware;
	function usePostMiddleware() {
	    var middleware = [];
	    for (var _i = 0; _i < arguments.length; _i++) {
	        middleware[_i - 0] = arguments[_i];
	    }
	    return provideMiddlewareForToken(exports.POST_MIDDLEWARE, middleware);
	}
	exports.usePostMiddleware = usePostMiddleware;
	function createMiddleware(useFactory, deps) {
	    return core_1.provide(new core_1.OpaqueToken('@ngrx/store middleware'), {
	        deps: deps,
	        useFactory: useFactory
	    });
	}
	exports.createMiddleware = createMiddleware;
	function provideMiddlewareForToken(token, _middleware) {
	    function isProvider(t) {
	        return t instanceof core_1.Provider;
	    }
	    var provider = core_1.provide(token, {
	        multi: true,
	        deps: [core_1.Injector],
	        useFactory: function (injector) {
	            var middleware = _middleware.map(function (m) {
	                if (isProvider(m)) {
	                    return injector.get(m.token);
	                }
	                return m;
	            });
	            return utils_1.compose.apply(void 0, middleware);
	        }
	    });
	    return _middleware.filter(isProvider).concat([provider]);
	}
	exports.provideMiddlewareForToken = provideMiddlewareForToken;


/***/ },

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

	"use strict";
	var actionTypes_1 = __webpack_require__(242);
	var genId = function () {
	    return Math.random().toString(36).slice(-10);
	};
	var createNotification = function (state, _a) {
	    var type = _a.type, message = _a.message;
	    var id = genId();
	    return [{
	        id: id,
	        type: type,
	        message: message
	    }].concat(state);
	};
	exports.showupReducer = function (state, action) {
	    if (state === void 0) { state = []; }
	    switch (action.type) {
	        case actionTypes_1.ADD_ALERT_NOTIFICATION:
	            return createNotification(state, { type: 'alert', message: action.payload });
	        case actionTypes_1.ADD_ERROR_NOTIFICATION:
	            return createNotification(state, { type: 'error', message: action.payload });
	        case actionTypes_1.CLEAR_NOTIFICATION:
	            return state.filter(function (noti) { return noti.id !== action.payload; });
	        default:
	            return state;
	    }
	};


/***/ },

/***/ 242:
/***/ function(module, exports) {

	"use strict";
	var PREFIX = '@SHOWUP/';
	exports.ADD_ALERT_NOTIFICATION = PREFIX + "ADD_ALERT_NOTIFICATION";
	exports.ADD_ERROR_NOTIFICATION = PREFIX + "ADD_ERROR_NOTIFICATION";
	exports.CLEAR_NOTIFICATION = PREFIX + "CLEAR_NOTIFICATION";


/***/ },

/***/ 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 core_1 = __webpack_require__(1);
	var notification_1 = __webpack_require__(244);
	var App = (function () {
	    function App() {
	        this.notificationRemoveDelay = 8000;
	    }
	    App.prototype.onRemove = function (notification) {
	        console.log('Remove', notification);
	    };
	    App = __decorate([
	        core_1.Component({
	            selector: 'app',
	            directives: [notification_1.Notifications],
	            template: "\n    <div class=\"app\">\n      <hx-notify\n        [removeDelay]=\"notificationRemoveDelay\"\n        (onRemove)=\"onRemove($event)\">\n      </hx-notify>\n    </div>\n  "
	        }), 
	        __metadata('design:paramtypes', [])
	    ], App);
	    return App;
	}());
	exports.App = App;


/***/ },

/***/ 244:
/***/ 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__(1);
	var store_1 = __webpack_require__(226);
	var actions_1 = __webpack_require__(245);
	__webpack_require__(!(function webpackMissingModule() { var e = new Error("Cannot find module \"./notificationStyles.styl\""); e.code = 'MODULE_NOT_FOUND'; throw e; }()));
	__webpack_require__(246);
	var Notifications = (function () {
	    function Notifications(store, actions) {
	        this.store = store;
	        this.actions = actions;
	        this.onRemove = new core_1.EventEmitter();
	        this.notifications = store.select('notifications');
	    }
	    Notifications.prototype.ngAfterViewInit = function () {
	        var _this = this;
	        this.notifications
	            .subscribe(function (notifications) {
	            _this.autoRemoveNotifications(notifications);
	        });
	    };
	    Notifications.prototype.autoRemoveNotifications = function (notifications) {
	        var _this = this;
	        if (notifications === void 0) { notifications = []; }
	        if (!notifications.length) {
	            return;
	        }
	        setTimeout(function () {
	            notifications.forEach(function (notification) {
	                _this.removeNotification(notification.id);
	                _this.onRemove.next(notification);
	            });
	        }, this.removeDelay);
	    };
	    Notifications.prototype.removeNotification = function (id) {
	        this.actions.clearNotification(id);
	    };
	    __decorate([
	        core_1.Input(), 
	        __metadata('design:type', Number)
	    ], Notifications.prototype, "removeDelay", void 0);
	    __decorate([
	        core_1.Input(), 
	        __metadata('design:type', String)
	    ], Notifications.prototype, "location", void 0);
	    __decorate([
	        core_1.Output(), 
	        __metadata('design:type', Object)
	    ], Notifications.prototype, "onRemove", void 0);
	    Notifications = __decorate([
	        core_1.Component({
	            selector: 'hx-notify',
	            styles: ["\n    .notifications {\n      position: fixed;\n      z-index: 10;\n      bottom: 0;\n    }\n    .notification {\n      width: 100%;\n      height: 30px;\n      border-radius: 3px;\n      padding: 15px;\n      text-align: center;\n      color: white;\n      position: relative;\n      color: white;\n      margin-top: 5px;\n    }\n    .alert{\n      background-color: green;\n    }\n    .error{\n      background-color: red;\n    }\n    .message {\n      font-size: 18px;\n    }\n  "],
	            template: "\n    <div class=\"notifications\">\n      <div class=\"notification {{ notification.type }}\" *ngFor=\"#notification of notifications | async \">\n        <span class=\"message\">{{ notification.message }}</span>\n      </div>\n    </div>\n  ",
	            providers: [actions_1.NotificationActions]
	        }), 
	        __metadata('design:paramtypes', [store_1.Store, actions_1.NotificationActions])
	    ], Notifications);
	    return Notifications;
	}());
	exports.Notifications = Notifications;


/***/ },

/***/ 245:
/***/ 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 actionTypes_1 = __webpack_require__(242);
	var store_1 = __webpack_require__(226);
	var core_1 = __webpack_require__(1);
	var NotificationActions = (function () {
	    function NotificationActions(store) {
	        this.store = store;
	    }
	    NotificationActions.prototype.addAlert = function (message) {
	        this.store.dispatch({ type: actionTypes_1.ADD_ALERT_NOTIFICATION, payload: message });
	    };
	    NotificationActions.prototype.addError = function (message) {
	        this.store.dispatch({ type: actionTypes_1.ADD_ERROR_NOTIFICATION, payload: message });
	    };
	    NotificationActions.prototype.clearNotification = function (id) {
	        this.store.dispatch({ type: actionTypes_1.CLEAR_NOTIFICATION, payload: id });
	    };
	    NotificationActions = __decorate([
	        core_1.Injectable(), 
	        __metadata('design:paramtypes', [store_1.Store])
	    ], NotificationActions);
	    return NotificationActions;
	}());
	exports.NotificationActions = NotificationActions;


/***/ },

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

	"use strict";
	var Observable_1 = __webpack_require__(49);
	var do_1 = __webpack_require__(247);
	Observable_1.Observable.prototype.do = do_1._do;
	//# sourceMappingURL=do.js.map

/***/ },

/***/ 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 Subscriber_1 = __webpack_require__(54);
	/**
	 * Returns a mirrored Observable of the source Observable, but modified so that the provided Observer is called
	 * for every item emitted by the source.
	 * This operator is useful for debugging your observables for the correct values or performing other side effects.
	 * @param {Observer|function} [nextOrObserver] a normal observer callback or callback for onNext.
	 * @param {function} [error] callback for errors in the source.
	 * @param {function} [complete] callback for the completion of the source.
	 * @reurns {Observable} a mirrored Observable with the specified Observer or callback attached for each item.
	 * @method do
	 * @owner Observable
	 */
	function _do(nextOrObserver, error, complete) {
	    return this.lift(new DoOperator(nextOrObserver, error, complete));
	}
	exports._do = _do;
	var DoOperator = (function () {
	    function DoOperator(nextOrObserver, error, complete) {
	        this.nextOrObserver = nextOrObserver;
	        this.error = error;
	        this.complete = complete;
	    }
	    DoOperator.prototype.call = function (subscriber) {
	        return new DoSubscriber(subscriber, this.nextOrObserver, this.error, this.complete);
	    };
	    return DoOperator;
	}());
	var DoSubscriber = (function (_super) {
	    __extends(DoSubscriber, _super);
	    function DoSubscriber(destination, nextOrObserver, error, complete) {
	        _super.call(this, destination);
	        var safeSubscriber = new Subscriber_1.Subscriber(nextOrObserver, error, complete);
	        safeSubscriber.syncErrorThrowable = true;
	        this.add(safeSubscriber);
	        this.safeSubscriber = safeSubscriber;
	    }
	    DoSubscriber.prototype._next = function (value) {
	        var safeSubscriber = this.safeSubscriber;
	        safeSubscriber.next(value);
	        if (safeSubscriber.syncErrorThrown) {
	            this.destination.error(safeSubscriber.syncErrorValue);
	        }
	        else {
	            this.destination.next(value);
	        }
	    };
	    DoSubscriber.prototype._error = function (err) {
	        var safeSubscriber = this.safeSubscriber;
	        safeSubscriber.error(err);
	        if (safeSubscriber.syncErrorThrown) {
	            this.destination.error(safeSubscriber.syncErrorValue);
	        }
	        else {
	            this.destination.error(err);
	        }
	    };
	    DoSubscriber.prototype._complete = function () {
	        var safeSubscriber = this.safeSubscriber;
	        safeSubscriber.complete();
	        if (safeSubscriber.syncErrorThrown) {
	            this.destination.error(safeSubscriber.syncErrorValue);
	        }
	        else {
	            this.destination.complete();
	        }
	    };
	    return DoSubscriber;
	}(Subscriber_1.Subscriber));
	//# sourceMappingURL=do.js.map

/***/ }

});
//# sourceMappingURL=app.js.map