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__) {
  
  	__webpack_require__(17);
  	module.exports = __webpack_require__(17);
  
  
  /***/ }),
  
  /***/ 3:
  /***/ (function(module, exports) {
  
  	module.exports = function() { throw new Error("define cannot be used indirect"); };
  
  
  /***/ }),
  
  /***/ 17:
  /***/ (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__(18) ], __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(){
  
  	(function ($, undefined) {
  	    var nameSpecialCharRegExp = /("|\%|'|\[|\]|\$|\.|\,|\:|\;|\+|\*|\&|\!|\#|\(|\)|<|>|\=|\?|\@|\^|\{|\}|\~|\/|\||`)/g;
  	    var SWITCHSELECTOR = ".k-switch";
  
  	    function generateMessages() {
  	        var name,
  	            messages = {};
  
  	        for (name in validationRules) {
  	            messages["mvc" + name] = createMessage(name);
  	        }
  	        return messages;
  	    }
  
  	    function generateRules() {
  	         var name,
  	             rules = {};
  
  	         for (name in validationRules) {
  	             rules["mvc" + name] = createRule(name);
  	        }
  	        return rules;
  	    }
  
  	    function extractParams(input, ruleName) {
  	        var params = {},
  	            index,
  	            data = input.data(),
  	            length = ruleName.length,
  	            rule,
  	            key,
  	            start;
  
  	        for (key in data) {
  	            rule = key.toLowerCase();
  	            index = rule.indexOf(ruleName);
  	            if (index > -1) {
  	                start = rule === "valserver" ? index : index + length;
  	                rule = rule.substring(start, key.length);
  
  	                if (rule) {
  	                    params[rule] = data[key];
  	                }
  	            }
  	        }
  	        return params;
  	    }
  
  	    function rulesFromData(metadata) {
  	        var idx,
  	            length,
  	            fields = metadata.Fields || [],
  	            rules = {};
  
  	        for (idx = 0, length = fields.length; idx < length; idx++) {
  	            $.extend(true, rules, rulesForField(fields[idx]));
  	        }
  	        return rules;
  	    }
  
  	    function rulesForField(field) {
  	        var rules = {},
  	            messages = {},
  	            fieldName = field.FieldName,
  	            fieldRules = field.ValidationRules,
  	            validationType,
  	            validationParams,
  	            idx,
  	            length;
  
  	        for (idx = 0, length = fieldRules.length; idx < length; idx++) {
  	            validationType = fieldRules[idx].ValidationType;
  	            validationParams = fieldRules[idx].ValidationParameters;
  
  	            rules[fieldName + validationType] = createMetaRule(fieldName, validationType, validationParams);
  
  	            messages[fieldName + validationType] = createMetaMessage(fieldRules[idx].ErrorMessage);
  	        }
  
  	        return { rules: rules, messages: messages };
  	    }
  
  	    function createMessage(rule) {
  	        return function (input) {
  	            if(input.filter("[data-rule-" + rule + "]").length) {
  	                return input.attr("data-msg-" + rule);
  	            } else {
  	                return input.attr("data-val-" + rule);
  	            }
  	        };
  	    }
  
  	    function createRule(ruleName) {
  	        return function (input) {
  	            if (input.filter("[data-val-" + ruleName + "]").length) {
  	                return validationRules[ruleName](input, extractParams(input, ruleName));
  	            } else if (input.filter("[data-rule-" + ruleName + "]").length) {
  	                return validationRules[ruleName](input, extractParams(input, ruleName));
  	            }
  	            return true;
  	        };
  	    }
  
  	    function createMetaMessage(message) {
  	        return function() { return message; };
  	    }
  
  	    function createMetaRule(fieldName, type, params) {
  	        return function (input) {
  	            if (input.filter("[name=" + fieldName + "]").length) {
  	                return validationRules[type](input, params);
  	            }
  	            return true;
  	        };
  	    }
  
  	    function patternMatcher(value, pattern) {
  	        if (typeof pattern === "string") {
  	            pattern = new RegExp('^(?:' + pattern + ')$');
  	        }
  	        return pattern.test(value);
  	    }
  
  	    var validationRules = {
  	        required: function (input) {
  	            var value = input.val(),
  	                checkbox = input.filter("[type=checkbox]"),
  	                radio = input.filter("[type=radio]"),
  	                name;
  
  	            if (checkbox.length) {
  	                name = checkbox[0].name.replace(nameSpecialCharRegExp, "\\$1");
  	                var hiddenSelector = "input:hidden[name='" + name + "']";
  	                var checkboxGroupMembers = input.closest(".k-checkbox-list").find("input[name='" + name + "']");
  
  	                if (checkbox.closest(SWITCHSELECTOR).length) {
  	                    checkbox = checkbox.closest(SWITCHSELECTOR);
  	                }
  
  	                var hidden = checkbox.next(hiddenSelector);
  
  	                if (!hidden.length) {
  	                    hidden = checkbox.next("label.k-checkbox-label").next(hiddenSelector);
  	                }
  
  	                if (hidden.length) {
  	                    value = hidden.val();
  	                } else {
  	                    value = input.prop("checked") === true;
  	                }
  
  	                if(checkboxGroupMembers.length) {
  	                    value = checkboxGroupMembers.is(":checked");
  	                }
  	            } else if(radio.length) {
  	                value = input.closest(".k-radio-list").find("input[name='" + input.attr("name") + "']:checked").length > 0;
  	            }
  
  	            return !(value === "" || !value || value.length === 0);
  	        },
  	        number: function (input) {
  	            /* jshint eqnull:true */
  	            return input.val() === "" || input.val() == null || kendo.parseFloat(input.val()) !== null;
  	        },
  	        regex: function (input, params) {
  	            if (input.val() !== "") {
  	                return patternMatcher(input.val(), params.pattern);
  	            }
  	            return true;
  	        },
  	        range: function(input, params) {
  	            if (input.val() !== "") {
  	                return this.min(input, params) && this.max(input, params);
  	            }
  	            return true;
  	        },
  	        min: function(input, params) {
  	            var min = parseFloat(params.min) || 0,
  	                val = kendo.parseFloat(input.val());
  
  	            return min <= val;
  	        },
  	        max: function(input, params) {
  	            var max = parseFloat(params.max) || 0,
  	                val = kendo.parseFloat(input.val());
  
  	            return val <= max;
  	        },
  	        date: function(input) {
  	            return input.val() === "" || kendo.parseDate(input.val()) !== null;
  	        },
  	        length: function(input, params) {
  	            if (input.val() !== "") {
  	                var len = kendo.trim(input.val()).length;
  	                return (!params.min || len >= (params.min || 0)) && (!params.max || len <= (params.max || 0));
  	            }
  	            return true;
  	        },
  	        server: function(input, params) {
  	            if (params.server) {
  	                return false;
  	            }
  
  	            return true;
  	        }
  	    };
  
  	    $.extend(true, kendo.ui.validator, {
  	        rules: generateRules(),
  	        messages: generateMessages(),
  	        messageLocators: {
  	            mvcLocator: {
  	                locate: function (element, fieldName) {
  	                    fieldName = fieldName.replace(nameSpecialCharRegExp, "\\$1");
  	                    return element.find(".field-validation-valid[data-valmsg-for='" + fieldName + "'], .field-validation-error[data-valmsg-for='" + fieldName + "']");
  	                },
  	                decorate: function (message, fieldName) {
  	                    message.addClass("field-validation-error").attr("data-valmsg-for", fieldName || "");
  	                }
  	            },
  	            mvcMetadataLocator: {
  	                locate: function (element, fieldName) {
  	                    fieldName = fieldName.replace(nameSpecialCharRegExp, "\\$1");
  	                    return element.find("#" + fieldName + "_validationMessage.field-validation-valid");
  	                },
  	                decorate: function (message, fieldName) {
  	                    message.addClass("field-validation-error").attr("id", fieldName + "_validationMessage");
  	                }
  	            }
  	        },
  	        ruleResolvers: {
  	            mvcMetaDataResolver: {
  	                resolve: function (element) {
  	                    var metadata = window.mvcClientValidationMetadata || [];
  
  	                    if (metadata.length) {
  	                        element = $(element);
  	                        for (var idx = 0; idx < metadata.length; idx++) {
  	                            if (metadata[idx].FormId == element.attr("id")) {
  	                                return rulesFromData(metadata[idx]);
  	                            }
  	                        }
  	                    }
  	                    return {};
  	                }
  	            }
  	        },
  	        validateOnInit: function(element) {
  	            return !!element.find("input[data-val-server]").length;
  	        },
  	        allowSubmit: function(element, errors) {
  	            return !!errors && errors.length === element.find("input[data-val-server]").length;
  	        }
  	    });
  	})(window.kendo.jQuery);
  
  	}, __webpack_require__(3));
  
  
  /***/ }),
  
  /***/ 18:
  /***/ (function(module, exports) {
  
  	module.exports = require("./kendo.imagebrowser.aspnetmvc");
  
  /***/ })
  
  /******/ });