text: module.exports =
  /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId])
  /******/ 			return installedModules[moduleId].exports;
  
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			exports: {},
  /******/ 			id: moduleId,
  /******/ 			loaded: false
  /******/ 		};
  
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  
  /******/ 		// Flag the module as loaded
  /******/ 		module.loaded = true;
  
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  
  
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(0);
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ 0:
  /***/ (function(module, exports, __webpack_require__) {
  
  	module.exports = __webpack_require__(1393);
  
  
  /***/ }),
  
  /***/ 3:
  /***/ (function(module, exports) {
  
  	module.exports = function() { throw new Error("define cannot be used indirect"); };
  
  
  /***/ }),
  
  /***/ 1050:
  /***/ (function(module, exports) {
  
  	module.exports = require("./kendo.core");
  
  /***/ }),
  
  /***/ 1393:
  /***/ (function(module, exports, __webpack_require__) {
  
  	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function(f, define){
  	    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ __webpack_require__(1050) ], __WEBPACK_AMD_DEFINE_FACTORY__ = (f), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  	})(function(){
  
  	var __meta__ = { // jshint ignore:line
  	    id: "router",
  	    name: "Router",
  	    category: "framework",
  	    description: "The Router class is responsible for tracking the application state and navigating between the application states.",
  	    depends: [ "core" ],
  	    hidden: false
  	};
  
  	(function($, undefined) {
  	    var kendo = window.kendo,
  	        CHANGE = "change",
  	        BACK = "back",
  	        SAME = "same",
  	        support = kendo.support,
  	        location = window.location,
  	        history = window.history,
  	        CHECK_URL_INTERVAL = 50,
  	        BROKEN_BACK_NAV = kendo.support.browser.msie,
  	        hashStrip = /^#*/,
  	        document = window.document;
  
  	    function absoluteURL(path, pathPrefix) {
  	        if (!pathPrefix) {
  	            return path;
  	        }
  
  	        if (path + "/" === pathPrefix) {
  	            path = pathPrefix;
  	        }
  
  	        var regEx = new RegExp("^" + pathPrefix, "i");
  
  	        if (!regEx.test(path)) {
  	            path = pathPrefix + "/" + path;
  	        }
  
  	        return location.protocol + '//' + (location.host + "/" + path).replace(/\/\/+/g, '/');
  	    }
  
  	    function hashDelimiter(bang) {
  	        return bang ? "#!" : "#";
  	    }
  
  	    function locationHash(hashDelimiter) {
  	        var href = location.href;
  
  	        // ignore normal anchors if in hashbang mode - however, still return "" if no hash present
  	        if (hashDelimiter === "#!" && href.indexOf("#") > -1 && href.indexOf("#!") < 0) {
  	            return null;
  	        }
  
  	        return href.split(hashDelimiter)[1] || "";
  	    }
  
  	    function stripRoot(root, url) {
  	        if (url.indexOf(root) === 0) {
  	            return (url.substr(root.length)).replace(/\/\//g, '/');
  	        } else {
  	            return url;
  	        }
  	    }
  
  	    var HistoryAdapter = kendo.Class.extend({
  	        back: function() {
  	            if (BROKEN_BACK_NAV) {
  	                setTimeout(function() { history.back(); });
  	            } else {
  	                history.back();
  	            }
  	        },
  
  	        forward: function() {
  	            if (BROKEN_BACK_NAV) {
  	                setTimeout(function() { history.forward(); });
  	            } else {
  	                history.forward();
  	            }
  	        },
  
  	        length: function() {
  	            return history.length;
  	        },
  
  	        replaceLocation: function(url) {
  	            location.replace(url);
  	        }
  	    });
  
  	    var PushStateAdapter = HistoryAdapter.extend({
  	        init: function(root) {
  	            this.root = root;
  	        },
  
  	        navigate: function(to) {
  	            history.pushState({}, document.title, absoluteURL(to, this.root));
  	        },
  
  	        replace: function(to) {
  	            history.replaceState({}, document.title, absoluteURL(to, this.root));
  	        },
  
  	        normalize: function(url) {
  	            return stripRoot(this.root, url);
  	        },
  
  	        current: function() {
  	            var current = location.pathname;
  
  	            if (location.search) {
  	                current += location.search;
  	            }
  
  	            return stripRoot(this.root, current);
  	        },
  
  	        change: function(callback) {
  	            $(window).bind("popstate.kendo", callback);
  	        },
  
  	        stop: function() {
  	            $(window).unbind("popstate.kendo");
  	        },
  
  	        normalizeCurrent: function(options) {
  	            var fixedUrl,
  	                root = options.root,
  	                pathname = location.pathname,
  	                hash = locationHash(hashDelimiter(options.hashBang));
  
  	            if (root === pathname + "/") {
  	                fixedUrl = root;
  	            }
  
  	            if (root === pathname && hash) {
  	                fixedUrl = absoluteURL(hash.replace(hashStrip, ''), root);
  	            }
  
  	            if (fixedUrl) {
  	                history.pushState({}, document.title, fixedUrl);
  	            }
  	        }
  	    });
  
  	    function fixHash(url) {
  	        return url.replace(/^(#)?/, "#");
  	    }
  
  	    function fixBang(url) {
  	        return url.replace(/^(#(!)?)?/, "#!");
  	    }
  
  	    var HashAdapter = HistoryAdapter.extend({
  	        init: function(bang) {
  	            this._id = kendo.guid();
  	            this.prefix = hashDelimiter(bang);
  	            this.fix = bang ? fixBang : fixHash;
  	        },
  
  	        navigate: function(to) {
  	            location.hash = this.fix(to);
  	        },
  
  	        replace: function(to) {
  	            this.replaceLocation(this.fix(to));
  	        },
  
  	        normalize: function(url) {
  	            if (url.indexOf(this.prefix) < 0) {
  	               return url;
  	            } else {
  	                return url.split(this.prefix)[1];
  	            }
  	        },
  
  	        change: function(callback) {
  	            if (support.hashChange) {
  	                $(window).on("hashchange." + this._id, callback);
  	            } else {
  	                this._interval = setInterval(callback, CHECK_URL_INTERVAL);
  	            }
  	        },
  
  	        stop: function() {
  	            $(window).off("hashchange." + this._id);
  	            clearInterval(this._interval);
  	        },
  
  	        current: function() {
  	            return locationHash(this.prefix);
  	        },
  
  	        normalizeCurrent: function(options) {
  	            var pathname = location.pathname,
  	                root = options.root;
  
  	            if (options.pushState && root !== pathname) {
  	                this.replaceLocation(root + this.prefix + stripRoot(root, pathname));
  	                return true; // browser will reload at this point.
  	            }
  
  	            return false;
  	        }
  	    });
  
  	    var History = kendo.Observable.extend({
  	        start: function(options) {
  	            options = options || {};
  
  	            this.bind([CHANGE, BACK, SAME], options);
  
  	            if (this._started) {
  	                return;
  	            }
  
  	            this._started = true;
  
  	            options.root = options.root || "/";
  
  	            var adapter = this.createAdapter(options),
  	                current;
  
  	            // adapter may reload the document
  	            if (adapter.normalizeCurrent(options)) {
  	                return;
  	            }
  
  	            current = adapter.current();
  
  	            $.extend(this, {
  	                adapter: adapter,
  	                root: options.root,
  	                historyLength: adapter.length(),
  	                current: current,
  	                locations: [current]
  	            });
  
  	            adapter.change($.proxy(this, "_checkUrl"));
  	        },
  
  	        createAdapter:function(options) {
  	           return support.pushState && options.pushState ? new PushStateAdapter(options.root) : new HashAdapter(options.hashBang);
  	        },
  
  	        stop: function() {
  	            if (!this._started) {
  	                return;
  	            }
  	            this.adapter.stop();
  	            this.unbind(CHANGE);
  	            this._started = false;
  	        },
  
  	        change: function(callback) {
  	            this.bind(CHANGE, callback);
  	        },
  
  	        replace: function(to, silent) {
  
  	            this._navigate(to, silent, function(adapter) {
  	                adapter.replace(to);
  	                this.locations[this.locations.length - 1] = this.current;
  	            });
  	        },
  
  	        navigate: function(to, silent) {
  	            if (to === "#:back") {
  	                this.backCalled = true;
  	                this.adapter.back();
  	                return;
  	            }
  
  	            this._navigate(to, silent, function(adapter) {
  	                adapter.navigate(to);
  	                this.locations.push(this.current);
  	            });
  	        },
  
  	        _navigate: function(to, silent, callback) {
  	            var adapter = this.adapter;
  
  	            to = adapter.normalize(to);
  
  	            if (this.current === to || this.current === decodeURIComponent(to)) {
  	                this.trigger(SAME);
  	                return;
  	            }
  
  	            if (!silent) {
  	                if (this.trigger(CHANGE, { url: to, decode: false })) {
  	                    return;
  	                }
  	            }
  
  	            this.current = to;
  
  	            callback.call(this, adapter);
  
  	            this.historyLength = adapter.length();
  	        },
  
  	        _checkUrl: function() {
  	            var adapter = this.adapter,
  	                current = adapter.current(),
  	                newLength = adapter.length(),
  	                navigatingInExisting = this.historyLength === newLength,
  	                back = current === this.locations[this.locations.length - 2] && navigatingInExisting,
  	                backCalled = this.backCalled,
  	                prev = this.current;
  
  	            if (current === null || this.current === current || this.current === decodeURIComponent(current)) {
  	                return true;
  	            }
  
  	            this.historyLength = newLength;
  	            this.backCalled = false;
  
  	            this.current = current;
  
  	            if (back && this.trigger("back", { url: prev, to: current })) {
  	                adapter.forward();
  	                this.current = prev;
  	                return;
  	            }
  
  	            if (this.trigger(CHANGE, { url: current, backButtonPressed: !backCalled })) {
  	                if (back) {
  	                    adapter.forward();
  	                } else {
  	                    adapter.back();
  	                    this.historyLength --;
  	                }
  	                this.current = prev;
  	                return;
  	            }
  
  	            if (back) {
  	                this.locations.pop();
  	            } else {
  	                this.locations.push(current);
  	            }
  	        }
  	    });
  
  	    kendo.History = History;
  	    kendo.History.HistoryAdapter = HistoryAdapter;
  	    kendo.History.HashAdapter = HashAdapter;
  	    kendo.History.PushStateAdapter = PushStateAdapter;
  	    kendo.absoluteURL = absoluteURL;
  	    kendo.history = new History();
  	})(window.kendo.jQuery);
  
  	(function() {
  	    var kendo = window.kendo,
  	        history = kendo.history,
  	        Observable = kendo.Observable,
  	        INIT = "init",
  	        ROUTE_MISSING = "routeMissing",
  	        CHANGE = "change",
  	        BACK = "back",
  	        SAME = "same",
  	        optionalParam = /\((.*?)\)/g,
  	        namedParam = /(\(\?)?:\w+/g,
  	        splatParam = /\*\w+/g,
  	        escapeRegExp = /[\-{}\[\]+?.,\\\^$|#\s]/g;
  
  	    function namedParamReplace(match, optional) {
  	        return optional ? match : '([^\/]+)';
  	    }
  
  	    function routeToRegExp(route, ignoreCase) {
  	        return new RegExp('^' + route
  	            .replace(escapeRegExp, '\\$&')
  	            .replace(optionalParam, '(?:$1)?')
  	            .replace(namedParam, namedParamReplace)
  	            .replace(splatParam, '(.*?)') + '$', ignoreCase ? "i" : "");
  	    }
  
  	    function stripUrl(url) {
  	        return url.replace(/(\?.*)|(#.*)/g, "");
  	    }
  
  	    var Route = kendo.Class.extend({
  	        init: function(route, callback, ignoreCase) {
  	            if (!(route instanceof RegExp)) {
  	                route = routeToRegExp(route, ignoreCase);
  	            }
  
  	            this.route = route;
  	            this._callback = callback;
  	        },
  
  	        callback: function(url, back, decode) {
  	            var params,
  	                idx = 0,
  	                length,
  	                queryStringParams = kendo.parseQueryStringParams(url);
  	                queryStringParams._back = back;
  
  	            url = stripUrl(url);
  	            params = this.route.exec(url).slice(1);
  	            length = params.length;
  
  	            if (decode) {
  	                for (; idx < length; idx ++) {
  	                    if (typeof params[idx] !== 'undefined') {
  	                        params[idx] = decodeURIComponent(params[idx]);
  	                    }
  	                }
  	            }
  
  	            params.push(queryStringParams);
  
  	            this._callback.apply(null, params);
  	        },
  
  	        worksWith: function(url, back, decode) {
  	            if (this.route.test(stripUrl(url))) {
  	                this.callback(url, back, decode);
  	                return true;
  	            } else {
  	                return false;
  	            }
  	        }
  	    });
  
  	    var Router = Observable.extend({
  	        init: function(options) {
  	            if (!options) {
  	                options = {};
  	            }
  
  	            Observable.fn.init.call(this);
  
  	            this.routes = [];
  	            this.pushState = options.pushState;
  	            this.hashBang = options.hashBang;
  	            this.root = options.root;
  	            this.ignoreCase = options.ignoreCase !== false;
  
  	            this.bind([INIT, ROUTE_MISSING, CHANGE, SAME, BACK], options);
  	        },
  
  	        destroy: function() {
  	            history.unbind(CHANGE, this._urlChangedProxy);
  	            history.unbind(SAME, this._sameProxy);
  	            history.unbind(BACK, this._backProxy);
  	            this.unbind();
  	        },
  
  	        start: function() {
  	            var that = this,
  	                sameProxy = function() { that._same(); },
  	                backProxy = function(e) { that._back(e); },
  	                urlChangedProxy = function(e) { that._urlChanged(e); };
  
  	            history.start({
  	                same: sameProxy,
  	                change: urlChangedProxy,
  	                back: backProxy,
  	                pushState: that.pushState,
  	                hashBang: that.hashBang,
  	                root: that.root
  	            });
  
  	            var initEventObject = { url: history.current || "/", preventDefault: $.noop };
  
  	            if (!that.trigger(INIT, initEventObject)) {
  	                that._urlChanged(initEventObject);
  	            }
  
  	            this._urlChangedProxy = urlChangedProxy;
  	            this._backProxy = backProxy;
  	        },
  
  	        route: function(route, callback) {
  	            this.routes.push(new Route(route, callback, this.ignoreCase));
  	        },
  
  	        navigate: function(url, silent) {
  	            kendo.history.navigate(url, silent);
  	        },
  
  	        replace: function(url, silent) {
  	            kendo.history.replace(url, silent);
  	        },
  
  	        _back: function(e) {
  	            if (this.trigger(BACK, { url: e.url, to: e.to })) {
  	                e.preventDefault();
  	            }
  	        },
  
  	        _same: function() {
  	            this.trigger(SAME);
  	        },
  
  	        _urlChanged: function(e) {
  	            var url = e.url;
  	            var decode = !!e.decode;
  	            var back = e.backButtonPressed;
  
  	            if (!url) {
  	                url = "/";
  	            }
  
  	            if (this.trigger(CHANGE, { url: e.url, params: kendo.parseQueryStringParams(e.url), backButtonPressed: back })) {
  	                e.preventDefault();
  	                return;
  	            }
  
  	            var idx = 0,
  	                routes = this.routes,
  	                route,
  	                length = routes.length;
  
  	            for (; idx < length; idx ++) {
  	                 route = routes[idx];
  
  	                 if (route.worksWith(url, back, decode)) {
  	                    return;
  	                 }
  	            }
  
  	            if (this.trigger(ROUTE_MISSING, { url: url, params: kendo.parseQueryStringParams(url), backButtonPressed: back })) {
  	                e.preventDefault();
  	            }
  	        }
  	    });
  
  	    kendo.Router = Router;
  	})();
  
  	return window.kendo;
  
  	}, __webpack_require__(3));
  
  
  /***/ })
  
  /******/ });