trying to update the form editor

angular_app/index.html

@@ -6,6 +6,7 @@
         <meta http-equiv="X-UA-Compatible" content="IE=edge">
         <meta name="viewport" content="width=device-width, initial-scale=1">
         <script type="text/javascript" src="/static/js/jquery-3.2.0.min.js"></script>
+        <script type="text/javascript" src="/static/js/api-check.min.js"></script>
         <script type="text/javascript" src="/static/js/angular.min.js"></script>
         <script type="text/javascript" src="/static/js/bootstrap.min.js"></script>
         <script type="text/javascript" src="/static/js/ui-bootstrap-tpls-0.14.3.min.js"></script>
@@ -16,8 +17,13 @@
         <script type="text/javascript" src="/static/js/angular-file-upload.min.js"></script>
         <script type="text/javascript" src="/static/js/angular-ui-router.min.js"></script>
         <script type="text/javascript" src="/static/js/angular-websocket.min.js"></script>
+        <script type="text/javascript" src="/static/js/angular-strap.min.js"></script>
+        <script type="text/javascript" src="/static/js/angular-strap.tpl.min.js"></script>
         <script type="text/javascript" src="/static/js/angular-translate.min.js"></script>
         <script type="text/javascript" src="/static/js/angular-translate-loader-static-files.min.js"></script>
+
+        <script type="text/javascript" src="/static/js/angular-formly-templates-bootstrap.min.js"></script>
+        <script type="text/javascript" src="/static/js/formly.min.js"></script>
         <script type="text/javascript" src="/static/js/nya-bs-select.min.js"></script>
         <script type="text/javascript" src="/static/js/eda.stepway.min.js"></script>
         <script type="text/javascript" src="/static/js/eda.easyFormViewer.min.js"></script>
@@ -26,9 +32,6 @@
         <script type="text/javascript" src="/static/js/textAngular.min.js"></script>
         <script type="text/javascript" src="/static/js/lodash.min.js"></script>
         <script type="text/javascript" src="/static/js/toaster.min.js"></script>
-        <script type="text/javascript" src="/static/js/api-check.min.js"></script>
-        <script type="text/javascript" src="/static/js/formly.min.js"></script>
-        <script type="text/javascript" src="/static/js/angular-formly-templates-bootstrap.min.js"></script>
 
         <script type="text/javascript" src="/static/js/eventman.js"></script>
         <script type="text/javascript" src="/js/app.js"></script>

static/js/angular-formly-templates-bootstrap.js

@@ -0,0 +1,611 @@
+//! angular-formly-templates-bootstrap version 0.0.0-semantically-released.0 built with ♥ by Astrism <astrisms@gmail.com>, Kent C. Dodds <kent@doddsfamily.us> (ó ì_í)=óò=(ì_í ò)
+
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("angular"), require("angular-formly"), require("api-check"));
+	else if(typeof define === 'function' && define.amd)
+		define(["angular", "angular-formly", "api-check"], factory);
+	else if(typeof exports === 'object')
+		exports["ngFormlyTemplatesBootstrap"] = factory(require("angular"), require("angular-formly"), require("api-check"));
+	else
+		root["ngFormlyTemplatesBootstrap"] = factory(root["angular"], root["ngFormly"], root["apiCheck"]);
+})(this, function(__WEBPACK_EXTERNAL_MODULE_3__, __WEBPACK_EXTERNAL_MODULE_4__, __WEBPACK_EXTERNAL_MODULE_5__) {
+return /******/ (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__) {
+
+	'use strict';
+
+	module.exports = __webpack_require__(1);
+
+/***/ },
+/* 1 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+	var ngModuleName = 'formlyBootstrap';
+	var angular = __webpack_require__(2);
+	var ngModule = angular.module(ngModuleName, [__webpack_require__(4)]);
+	ngModule.constant('formlyBootstrapApiCheck', __webpack_require__(5)({
+	  output: {
+	    prefix: 'angular-formly-bootstrap'
+	  }
+	}));
+	ngModule.constant('formlyBootstrapVersion', ("0.0.0-semantically-released.0"));
+
+	__webpack_require__(6)(ngModule);
+	__webpack_require__(9)(ngModule);
+	__webpack_require__(19)(ngModule);
+
+	exports['default'] = ngModuleName;
+	module.exports = exports['default'];
+
+/***/ },
+/* 2 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// some versions of angular don't export the angular module properly,
+	// so we get it from window in this case.
+	'use strict';
+
+	var angular = __webpack_require__(3);
+	if (!angular.version) {
+	  angular = window.angular;
+	}
+	module.exports = angular;
+
+/***/ },
+/* 3 */
+/***/ function(module, exports) {
+
+	module.exports = __WEBPACK_EXTERNAL_MODULE_3__;
+
+/***/ },
+/* 4 */
+/***/ function(module, exports) {
+
+	module.exports = __WEBPACK_EXTERNAL_MODULE_4__;
+
+/***/ },
+/* 5 */
+/***/ function(module, exports) {
+
+	module.exports = __WEBPACK_EXTERNAL_MODULE_5__;
+
+/***/ },
+/* 6 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	exports['default'] = function (ngModule) {
+	  ngModule.config(addWrappers);
+
+	  function addWrappers(formlyConfigProvider) {
+	    formlyConfigProvider.setWrapper([{
+	      name: 'bootstrapLabel',
+	      template: __webpack_require__(7),
+	      apiCheck: function apiCheck(check) {
+	        return {
+	          templateOptions: {
+	            label: check.string.optional,
+	            required: check.bool.optional,
+	            labelSrOnly: check.bool.optional
+	          }
+	        };
+	      }
+	    }, { name: 'bootstrapHasError', template: __webpack_require__(8) }]);
+	  }
+	  addWrappers.$inject = ["formlyConfigProvider"];
+	};
+
+	module.exports = exports['default'];
+
+/***/ },
+/* 7 */
+/***/ function(module, exports) {
+
+	module.exports = "<div>\n  <label for=\"{{id}}\" class=\"control-label {{to.labelSrOnly ? 'sr-only' : ''}}\" ng-if=\"to.label\">\n    {{to.label}}\n    {{to.required ? '*' : ''}}\n  </label>\n  <formly-transclude></formly-transclude>\n</div>\n"
+
+/***/ },
+/* 8 */
+/***/ function(module, exports) {
+
+	module.exports = "<div class=\"form-group\" ng-class=\"{'has-error': showError}\">\n  <formly-transclude></formly-transclude>\n</div>\n"
+
+/***/ },
+/* 9 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	exports['default'] = function (ngModule) {
+	  __webpack_require__(10)(ngModule);
+	  __webpack_require__(12)(ngModule);
+	  __webpack_require__(14)(ngModule);
+	  __webpack_require__(15)(ngModule);
+	  __webpack_require__(17)(ngModule);
+	  __webpack_require__(18)(ngModule);
+	};
+
+	module.exports = exports['default'];
+
+/***/ },
+/* 10 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	exports['default'] = function (ngModule) {
+	  ngModule.config(addCheckboxType);
+
+	  function addCheckboxType(formlyConfigProvider) {
+	    formlyConfigProvider.setType({
+	      name: 'checkbox',
+	      template: __webpack_require__(11),
+	      wrapper: ['bootstrapHasError'],
+	      apiCheck: function apiCheck(check) {
+	        return {
+	          templateOptions: {
+	            label: check.string
+	          }
+	        };
+	      }
+	    });
+	  }
+	  addCheckboxType.$inject = ["formlyConfigProvider"];
+	};
+
+	module.exports = exports['default'];
+
+/***/ },
+/* 11 */
+/***/ function(module, exports) {
+
+	module.exports = "<div class=\"checkbox\">\n\t<label>\n\t\t<input type=\"checkbox\"\n           class=\"formly-field-checkbox\"\n\t\t       ng-model=\"model[options.key]\">\n\t\t{{to.label}}\n\t\t{{to.required ? '*' : ''}}\n\t</label>\n</div>\n"
+
+/***/ },
+/* 12 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	exports['default'] = function (ngModule) {
+	  ngModule.config(addCheckboxType);
+
+	  function addCheckboxType(formlyConfigProvider) {
+	    formlyConfigProvider.setType({
+	      name: 'multiCheckbox',
+	      template: __webpack_require__(13),
+	      wrapper: ['bootstrapLabel', 'bootstrapHasError'],
+	      apiCheck: function apiCheck(check) {
+	        return {
+	          templateOptions: {
+	            options: check.arrayOf(check.object),
+	            labelProp: check.string.optional,
+	            valueProp: check.string.optional
+	          }
+	        };
+	      },
+	      defaultOptions: {
+	        noFormControl: false,
+	        ngModelAttrs: {
+	          required: {
+	            attribute: '',
+	            bound: ''
+	          }
+	        }
+	      },
+	      controller: /* @ngInject */["$scope", function controller($scope) {
+	        var to = $scope.to;
+	        var opts = $scope.options;
+	        $scope.multiCheckbox = {
+	          checked: [],
+	          change: setModel
+	        };
+
+	        // initialize the checkboxes check property
+	        $scope.$watch('model', function modelWatcher(newModelValue) {
+	          var modelValue, valueProp;
+
+	          if (Object.keys(newModelValue).length) {
+	            modelValue = newModelValue[opts.key];
+
+	            $scope.$watch('to.options', function optionsWatcher(newOptionsValues) {
+	              if (newOptionsValues && Array.isArray(newOptionsValues) && Array.isArray(modelValue)) {
+	                valueProp = to.valueProp || 'value';
+	                for (var index = 0; index < newOptionsValues.length; index++) {
+	                  $scope.multiCheckbox.checked[index] = modelValue.indexOf(newOptionsValues[index][valueProp]) !== -1;
+	                }
+	              }
+	            });
+	          }
+	        }, true);
+
+	        function checkValidity(expressionValue) {
+	          var valid;
+
+	          if ($scope.to.required) {
+	            valid = angular.isArray($scope.model[opts.key]) && $scope.model[opts.key].length > 0 && expressionValue;
+
+	            $scope.fc.$setValidity('required', valid);
+	          }
+	        }
+
+	        function setModel() {
+	          $scope.model[opts.key] = [];
+	          angular.forEach($scope.multiCheckbox.checked, function (checkbox, index) {
+	            if (checkbox) {
+	              $scope.model[opts.key].push(to.options[index][to.valueProp || 'value']);
+	            }
+	          });
+
+	          // Must make sure we mark as touched because only the last checkbox due to a bug in angular.
+	          $scope.fc.$setTouched();
+	          checkValidity(true);
+
+	          if ($scope.to.onChange) {
+	            $scope.to.onChange();
+	          }
+	        }
+
+	        if (opts.expressionProperties && opts.expressionProperties['templateOptions.required']) {
+	          $scope.$watch(function () {
+	            return $scope.to.required;
+	          }, function (newValue) {
+	            checkValidity(newValue);
+	          });
+	        }
+
+	        if ($scope.to.required) {
+	          var unwatchFormControl = $scope.$watch('fc', function (newValue) {
+	            if (!newValue) {
+	              return;
+	            }
+	            checkValidity(true);
+	            unwatchFormControl();
+	          });
+	        }
+	      }]
+	    });
+	  }
+	  addCheckboxType.$inject = ["formlyConfigProvider"];
+	};
+
+	module.exports = exports['default'];
+
+/***/ },
+/* 13 */
+/***/ function(module, exports) {
+
+	module.exports = "<div class=\"radio-group\">\n  <div ng-repeat=\"(key, option) in to.options\" class=\"checkbox\">\n    <label>\n      <input type=\"checkbox\"\n             id=\"{{id + '_'+ $index}}\"\n             ng-model=\"multiCheckbox.checked[$index]\"\n             ng-change=\"multiCheckbox.change()\">\n      {{option[to.labelProp || 'name']}}\n    </label>\n  </div>\n</div>\n"
+
+/***/ },
+/* 14 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	exports['default'] = function (ngModule) {
+	  ngModule.config(addInputType);
+
+	  function addInputType(formlyConfigProvider) {
+	    formlyConfigProvider.setType({
+	      name: 'input',
+	      template: '<input class="form-control" ng-model="model[options.key]">',
+	      wrapper: ['bootstrapLabel', 'bootstrapHasError']
+	    });
+	  }
+	  addInputType.$inject = ["formlyConfigProvider"];
+	};
+
+	module.exports = exports['default'];
+
+/***/ },
+/* 15 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	exports['default'] = function (ngModule) {
+	  ngModule.config(addRadioType);
+
+	  function addRadioType(formlyConfigProvider) {
+	    formlyConfigProvider.setType({
+	      name: 'radio',
+	      template: __webpack_require__(16),
+	      wrapper: ['bootstrapLabel', 'bootstrapHasError'],
+	      defaultOptions: {
+	        noFormControl: false
+	      },
+	      apiCheck: function apiCheck(check) {
+	        return {
+	          templateOptions: {
+	            options: check.arrayOf(check.object),
+	            labelProp: check.string.optional,
+	            valueProp: check.string.optional,
+	            inline: check.bool.optional
+	          }
+	        };
+	      }
+	    });
+	  }
+	  addRadioType.$inject = ["formlyConfigProvider"];
+	};
+
+	module.exports = exports['default'];
+
+/***/ },
+/* 16 */
+/***/ function(module, exports) {
+
+	module.exports = "<div class=\"radio-group\">\n  <div ng-repeat=\"(key, option) in to.options\" ng-class=\"{ 'radio': !to.inline, 'radio-inline': to.inline }\">\n    <label>\n      <input type=\"radio\"\n             id=\"{{id + '_'+ $index}}\"\n             tabindex=\"0\"\n             ng-value=\"option[to.valueProp || 'value']\"\n             ng-model=\"model[options.key]\">\n      {{option[to.labelProp || 'name']}}\n    </label>\n  </div>\n</div>\n"
+
+/***/ },
+/* 17 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+	exports['default'] = function (ngModule) {
+	  ngModule.config(addSelectType);
+
+	  var template = '<select class="form-control" ng-model="model[options.key]"></select>';
+
+	  function addSelectType(formlyConfigProvider) {
+	    formlyConfigProvider.setType({
+	      name: 'select',
+	      template: template,
+	      wrapper: ['bootstrapLabel', 'bootstrapHasError'],
+	      defaultOptions: function defaultOptions(options) {
+	        /* jshint maxlen:195 */
+	        var ngOptions = options.templateOptions.ngOptions || 'option[to.valueProp || \'value\'] as option[to.labelProp || \'name\'] group by option[to.groupProp || \'group\'] for option in to.options';
+	        return {
+	          ngModelAttrs: _defineProperty({}, ngOptions, {
+	            value: options.templateOptions.optionsAttr || 'ng-options'
+	          })
+	        };
+	      },
+	      apiCheck: function apiCheck(check) {
+	        return {
+	          templateOptions: {
+	            options: check.arrayOf(check.object),
+	            optionsAttr: check.string.optional,
+	            labelProp: check.string.optional,
+	            valueProp: check.string.optional,
+	            groupProp: check.string.optional
+	          }
+	        };
+	      }
+	    });
+	  }
+	  addSelectType.$inject = ["formlyConfigProvider"];
+	};
+
+	module.exports = exports['default'];
+
+/***/ },
+/* 18 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	exports['default'] = function (ngModule) {
+	  ngModule.config(addTextareaType);
+
+	  function addTextareaType(formlyConfigProvider) {
+	    formlyConfigProvider.setType({
+	      name: 'textarea',
+	      template: '<textarea class="form-control" ng-model="model[options.key]"></textarea>',
+	      wrapper: ['bootstrapLabel', 'bootstrapHasError'],
+	      defaultOptions: {
+	        ngModelAttrs: {
+	          rows: { attribute: 'rows' },
+	          cols: { attribute: 'cols' }
+	        }
+	      },
+	      apiCheck: function apiCheck(check) {
+	        return {
+	          templateOptions: {
+	            rows: check.number.optional,
+	            cols: check.number.optional
+	          }
+	        };
+	      }
+	    });
+	  }
+	  addTextareaType.$inject = ["formlyConfigProvider"];
+	};
+
+	module.exports = exports['default'];
+
+/***/ },
+/* 19 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+	var _addons = __webpack_require__(20);
+
+	var _addons2 = _interopRequireDefault(_addons);
+
+	var _description = __webpack_require__(22);
+
+	var _description2 = _interopRequireDefault(_description);
+
+	exports['default'] = function (ngModule) {
+	  (0, _addons2['default'])(ngModule);
+	  (0, _description2['default'])(ngModule);
+	};
+
+	module.exports = exports['default'];
+
+/***/ },
+/* 20 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	exports['default'] = function (ngModule) {
+	  ngModule.run(addAddonsManipulator);
+
+	  function addAddonsManipulator(formlyConfig, formlyBootstrapApiCheck) {
+	    var addonTemplate = __webpack_require__(21);
+	    var addonChecker = formlyBootstrapApiCheck.shape({
+	      'class': formlyBootstrapApiCheck.string.optional,
+	      text: formlyBootstrapApiCheck.string.optional,
+	      onClick: formlyBootstrapApiCheck.func.optional
+	    }).strict.optional;
+	    var api = formlyBootstrapApiCheck.shape({
+	      templateOptions: formlyBootstrapApiCheck.shape({
+	        addonLeft: addonChecker,
+	        addonRight: addonChecker
+	      })
+	    });
+	    formlyConfig.templateManipulators.preWrapper.push(function (template, options) {
+	      if (!options.templateOptions.addonLeft && !options.templateOptions.addonRight) {
+	        return template;
+	      }
+	      formlyBootstrapApiCheck.warn([api], [options]);
+	      return addonTemplate.replace('<formly-transclude></formly-transclude>', template);
+	    });
+	  }
+	  addAddonsManipulator.$inject = ["formlyConfig", "formlyBootstrapApiCheck"];
+	};
+
+	module.exports = exports['default'];
+
+/***/ },
+/* 21 */
+/***/ function(module, exports) {
+
+	module.exports = "<div ng-class=\"{'input-group': to.addonLeft || to.addonRight}\">\n    <div class=\"input-group-addon\"\n         ng-if=\"to.addonLeft\"\n         ng-style=\"{cursor: to.addonLeft.onClick ? 'pointer' : 'inherit'}\"\n         ng-click=\"to.addonLeft.onClick(options, this, $event)\">\n        <i class=\"{{to.addonLeft.class}}\" ng-if=\"to.addonLeft.class\"></i>\n        <span ng-if=\"to.addonLeft.text\">{{to.addonLeft.text}}</span>\n    </div>\n    <formly-transclude></formly-transclude>\n    <div class=\"input-group-addon\"\n         ng-if=\"to.addonRight\"\n         ng-style=\"{cursor: to.addonRight.onClick ? 'pointer' : 'inherit'}\"\n         ng-click=\"to.addonRight.onClick(options, this, $event)\">\n        <i class=\"{{to.addonRight.class}}\" ng-if=\"to.addonRight.class\"></i>\n        <span ng-if=\"to.addonRight.text\">{{to.addonRight.text}}</span>\n    </div>\n</div>\n"
+
+/***/ },
+/* 22 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	exports['default'] = function (ngModule) {
+	  ngModule.run(addDescriptionManipulator);
+
+	  function addDescriptionManipulator(formlyConfig) {
+	    formlyConfig.templateManipulators.preWrapper.push(function ariaDescribedBy(template, options, scope) {
+	      if (angular.isDefined(options.templateOptions.description)) {
+	        var el = document.createElement('div');
+	        el.appendChild(angular.element(template)[0]);
+	        el.appendChild(angular.element('<p id="' + scope.id + '_description"' + 'class="help-block"' + 'ng-if="to.description">' + '{{to.description}}' + '</p>')[0]);
+	        var modelEls = angular.element(el.querySelectorAll('[ng-model]'));
+	        if (modelEls) {
+	          modelEls.attr('aria-describedby', scope.id + '_description');
+	        }
+	        return el.innerHTML;
+	      } else {
+	        return template;
+	      }
+	    });
+	  }
+	  addDescriptionManipulator.$inject = ["formlyConfig"];
+	};
+
+	module.exports = exports['default'];
+
+/***/ }
+/******/ ])
+});
+;

static/js/api-check.js

@@ -0,0 +1,1332 @@
+//! api-check version 7.5.5 built with ♥ by Kent C. Dodds <kent@doddsfamily.us> (http://kent.doddsfamily.us) (ó ì_í)=óò=(ì_í ò)
+
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define(factory);
+	else if(typeof exports === 'object')
+		exports["apiCheck"] = factory();
+	else
+		root["apiCheck"] = factory();
+})(this, function() {
+return /******/ (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__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+	var _apiCheck = __webpack_require__(1);
+
+	var _apiCheck2 = _interopRequireDefault(_apiCheck);
+
+	exports['default'] = _apiCheck2['default'];
+	module.exports = exports['default'];
+
+/***/ },
+/* 1 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var stringify = __webpack_require__(2);
+	var apiCheckUtil = __webpack_require__(3);
+	var each = apiCheckUtil.each;
+	var isError = apiCheckUtil.isError;
+	var t = apiCheckUtil.t;
+	var arrayify = apiCheckUtil.arrayify;
+	var getCheckerDisplay = apiCheckUtil.getCheckerDisplay;
+	var typeOf = apiCheckUtil.typeOf;
+	var getError = apiCheckUtil.getError;
+
+	var checkers = __webpack_require__(4);
+	var apiCheckApis = getApiCheckApis();
+
+	module.exports = getApiCheckInstance;
+	module.exports.VERSION = ("7.5.5");
+	module.exports.utils = apiCheckUtil;
+	module.exports.globalConfig = {
+	  verbose: false,
+	  disabled: false
+	};
+
+	var apiCheckApiCheck = getApiCheckInstance({
+	  output: { prefix: 'apiCheck' }
+	});
+	module.exports.internalChecker = apiCheckApiCheck;
+
+	each(checkers, function (checker, name) {
+	  return module.exports[name] = checker;
+	});
+
+	function getApiCheckInstance() {
+	  var config = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+	  var extraCheckers = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+
+	  /* eslint complexity:[2, 6] */
+	  if (apiCheckApiCheck && arguments.length) {
+	    apiCheckApiCheck['throw'](apiCheckApis.getApiCheckInstanceCheckers, arguments, {
+	      prefix: 'creating an apiCheck instance'
+	    });
+	  }
+
+	  var additionalProperties = {
+	    'throw': getApiCheck(true),
+	    warn: getApiCheck(false),
+	    getErrorMessage: getErrorMessage,
+	    handleErrorMessage: handleErrorMessage,
+	    config: {
+	      output: config.output || {
+	        prefix: '',
+	        suffix: '',
+	        docsBaseUrl: ''
+	      },
+	      verbose: config.verbose || false,
+	      disabled: config.disabled || false
+	    },
+	    utils: apiCheckUtil
+	  };
+
+	  each(additionalProperties, function (wrapper, name) {
+	    return apiCheck[name] = wrapper;
+	  });
+
+	  var disabled = apiCheck.disabled || module.exports.globalConfig.disabled;
+	  each(checkers.getCheckers(disabled), function (checker, name) {
+	    return apiCheck[name] = checker;
+	  });
+	  each(extraCheckers, function (checker, name) {
+	    return apiCheck[name] = checker;
+	  });
+
+	  return apiCheck;
+
+	  /**
+	   * This is the instance function. Other things are attached to this see additional properties above.
+	   * @param {Array} api - the checkers to check with
+	   * @param {Array} args - the args to check
+	   * @param {Object} output - output options
+	   * @returns {Object} - if this has a failed = true property, then it failed
+	   */
+	  function apiCheck(api, args, output) {
+	    /* eslint complexity:[2, 8] */
+	    if (apiCheck.config.disabled || module.exports.globalConfig.disabled) {
+	      return {
+	        apiTypes: {}, argTypes: {},
+	        passed: true, message: '',
+	        failed: false
+	      }; // empty version of what is normally returned
+	    }
+	    checkApiCheckApi(arguments);
+	    if (!Array.isArray(api)) {
+	      api = [api];
+	      args = [args];
+	    } else {
+	      // turn arguments into an array
+	      args = Array.prototype.slice.call(args);
+	    }
+	    var messages = checkEnoughArgs(api, args);
+	    if (!messages.length) {
+	      // this is where we actually go perform the checks.
+	      messages = checkApiWithArgs(api, args);
+	    }
+
+	    var returnObject = getTypes(api, args);
+	    returnObject.args = args;
+	    if (messages.length) {
+	      returnObject.message = apiCheck.getErrorMessage(api, args, messages, output);
+	      returnObject.failed = true;
+	      returnObject.passed = false;
+	    } else {
+	      returnObject.message = '';
+	      returnObject.failed = false;
+	      returnObject.passed = true;
+	    }
+	    return returnObject;
+	  }
+
+	  /**
+	   * checkApiCheckApi, should be read like: check apiCheck api. As in, check the api for apiCheck :-)
+	   * @param {Array} checkApiArgs - args provided to apiCheck function
+	   */
+	  function checkApiCheckApi(checkApiArgs) {
+	    var api = checkApiArgs[0];
+	    var args = checkApiArgs[1];
+	    var isArrayOrArgs = Array.isArray(args) || args && typeof args === 'object' && typeof args.length === 'number';
+
+	    if (Array.isArray(api) && !isArrayOrArgs) {
+	      throw new Error(getErrorMessage(api, [args], ['If an array is provided for the api, an array must be provided for the args as well.'], { prefix: 'apiCheck' }));
+	    }
+	    // dog fooding here
+	    var errors = checkApiWithArgs(apiCheckApis.checkApiCheckApi, checkApiArgs);
+	    if (errors.length) {
+	      var message = apiCheck.getErrorMessage(apiCheckApis.checkApiCheckApi, checkApiArgs, errors, {
+	        prefix: 'apiCheck'
+	      });
+	      apiCheck.handleErrorMessage(message, true);
+	    }
+	  }
+
+	  function getApiCheck(shouldThrow) {
+	    return function apiCheckWrapper(api, args, output) {
+	      var result = apiCheck(api, args, output);
+	      apiCheck.handleErrorMessage(result.message, shouldThrow);
+	      return result; // wont get here if an error is thrown
+	    };
+	  }
+
+	  function handleErrorMessage(message, shouldThrow) {
+	    if (shouldThrow && message) {
+	      throw new Error(message);
+	    } else if (message) {
+	      /* eslint no-console:0 */
+	      console.warn(message);
+	    }
+	  }
+
+	  function getErrorMessage(api, args) {
+	    var messages = arguments.length <= 2 || arguments[2] === undefined ? [] : arguments[2];
+	    var output = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
+
+	    var gOut = apiCheck.config.output || {};
+	    var prefix = getPrefix();
+	    var suffix = getSuffix();
+	    var url = getUrl();
+	    var message = 'apiCheck failed! ' + messages.join(', ');
+	    var passedAndShouldHavePassed = '\n\n' + buildMessageFromApiAndArgs(api, args);
+	    return (prefix + ' ' + message + ' ' + suffix + ' ' + (url || '') + passedAndShouldHavePassed).trim();
+
+	    function getPrefix() {
+	      var p = output.onlyPrefix;
+	      if (!p) {
+	        p = ((gOut.prefix || '') + ' ' + (output.prefix || '')).trim();
+	      }
+	      return p;
+	    }
+
+	    function getSuffix() {
+	      var s = output.onlySuffix;
+	      if (!s) {
+	        s = ((output.suffix || '') + ' ' + (gOut.suffix || '')).trim();
+	      }
+	      return s;
+	    }
+
+	    function getUrl() {
+	      var u = output.url;
+	      if (!u) {
+	        u = gOut.docsBaseUrl && output.urlSuffix && ('' + gOut.docsBaseUrl + output.urlSuffix).trim();
+	      }
+	      return u;
+	    }
+	  }
+
+	  function buildMessageFromApiAndArgs(api, args) {
+	    var _getTypes = getTypes(api, args);
+
+	    var apiTypes = _getTypes.apiTypes;
+	    var argTypes = _getTypes.argTypes;
+
+	    var copy = Array.prototype.slice.call(args || []);
+	    var replacedItems = [];
+	    replaceFunctionWithName(copy);
+	    var passedArgs = getObjectString(copy);
+	    argTypes = getObjectString(argTypes);
+	    apiTypes = getObjectString(apiTypes);
+
+	    return generateMessage();
+
+	    // functions
+
+	    function replaceFunctionWithName(obj) {
+	      each(obj, function (val, name) {
+	        /* eslint complexity:[2, 6] */
+	        if (replacedItems.indexOf(val) === -1) {
+	          // avoid recursive problems
+	          replacedItems.push(val);
+	          if (typeof val === 'object') {
+	            replaceFunctionWithName(obj);
+	          } else if (typeof val === 'function') {
+	            obj[name] = val.displayName || val.name || 'anonymous function';
+	          }
+	        }
+	      });
+	    }
+
+	    function getObjectString(types) {
+	      if (!types || !types.length) {
+	        return 'nothing';
+	      } else if (types && types.length === 1) {
+	        types = types[0];
+	      }
+	      return stringify(types, null, 2);
+	    }
+
+	    function generateMessage() {
+	      var n = '\n';
+	      var useS = true;
+	      if (args && args.length === 1) {
+	        if (typeof args[0] === 'object' && args[0] !== null) {
+	          useS = !!Object.keys(args[0]).length;
+	        } else {
+	          useS = false;
+	        }
+	      }
+	      var types = 'type' + (useS ? 's' : '');
+	      var newLine = n + n;
+	      return 'You passed:' + n + passedArgs + newLine + ('With the ' + types + ':' + n + argTypes + newLine) + ('The API calls for:' + n + apiTypes);
+	    }
+	  }
+
+	  function getTypes(api, args) {
+	    api = arrayify(api);
+	    args = arrayify(args);
+	    var apiTypes = api.map(function (checker, index) {
+	      var specified = module.exports.globalConfig.hasOwnProperty('verbose');
+	      return getCheckerDisplay(checker, {
+	        terse: specified ? !module.exports.globalConfig.verbose : !apiCheck.config.verbose,
+	        obj: args[index],
+	        addHelpers: true
+	      });
+	    });
+	    var argTypes = args.map(function (arg) {
+	      return getArgDisplay(arg, []);
+	    });
+	    return { argTypes: argTypes, apiTypes: apiTypes };
+	  }
+	}
+
+	// STATELESS FUNCTIONS
+
+	/**
+	 * This is where the magic happens for actually checking the arguments with the api.
+	 * @param {Array} api - checkers
+	 * @param  {Array} args - and arguments object
+	 * @returns {Array} - the error messages
+	 */
+	function checkApiWithArgs(api, args) {
+	  /* eslint complexity:[2, 7] */
+	  var messages = [];
+	  var failed = false;
+	  var checkerIndex = 0;
+	  var argIndex = 0;
+	  var arg = undefined,
+	      checker = undefined,
+	      res = undefined,
+	      lastChecker = undefined,
+	      argName = undefined,
+	      argFailed = undefined,
+	      skipPreviousChecker = undefined;
+	  /* jshint -W084 */
+	  while ((checker = api[checkerIndex++]) && argIndex < args.length) {
+	    arg = args[argIndex++];
+	    argName = 'Argument ' + argIndex + (checker.isOptional ? ' (optional)' : '');
+	    res = checker(arg, 'value', argName);
+	    argFailed = isError(res);
+	    lastChecker = checkerIndex >= api.length;
+	    skipPreviousChecker = checkerIndex > 1 && api[checkerIndex - 1].isOptional;
+	    if (argFailed && lastChecker || argFailed && !lastChecker && !checker.isOptional && !skipPreviousChecker) {
+	      failed = true;
+	      messages.push(getCheckerErrorMessage(res, checker, arg));
+	    } else if (argFailed && checker.isOptional) {
+	      argIndex--;
+	    } else {
+	      messages.push(t(argName) + ' passed');
+	    }
+	  }
+	  return failed ? messages : [];
+	}
+
+	checkerTypeType.type = 'function with __apiCheckData property and `${function.type}` property';
+	function checkerTypeType(checkerType, name, location) {
+	  var apiCheckDataChecker = checkers.shape({
+	    type: checkers.string,
+	    optional: checkers.bool
+	  });
+	  var asFunc = checkers.func.withProperties({ __apiCheckData: apiCheckDataChecker });
+	  var asShape = checkers.shape({ __apiCheckData: apiCheckDataChecker });
+	  var wrongShape = checkers.oneOfType([asFunc, asShape])(checkerType, name, location);
+	  if (isError(wrongShape)) {
+	    return wrongShape;
+	  }
+	  if (typeof checkerType !== 'function' && !checkerType.hasOwnProperty(checkerType.__apiCheckData.type)) {
+	    return getError(name, location, checkerTypeType.type);
+	  }
+	}
+
+	function getCheckerErrorMessage(res, checker, val) {
+	  var checkerHelp = getCheckerHelp(checker, val);
+	  checkerHelp = checkerHelp ? ' - ' + checkerHelp : '';
+	  return res.message + checkerHelp;
+	}
+
+	function getCheckerHelp(_ref, val) {
+	  var help = _ref.help;
+
+	  if (!help) {
+	    return '';
+	  }
+	  if (typeof help === 'function') {
+	    help = help(val);
+	  }
+	  return help;
+	}
+
+	function checkEnoughArgs(api, args) {
+	  var requiredArgs = api.filter(function (a) {
+	    return !a.isOptional;
+	  });
+	  if (args.length < requiredArgs.length) {
+	    return ['Not enough arguments specified. Requires `' + requiredArgs.length + '`, you passed `' + args.length + '`'];
+	  } else {
+	    return [];
+	  }
+	}
+
+	function getArgDisplay(arg, gottenArgs) {
+	  /* eslint complexity:[2, 7] */
+	  var cName = arg && arg.constructor && arg.constructor.name;
+	  var type = typeOf(arg);
+	  if (type === 'function') {
+	    if (hasKeys()) {
+	      var properties = stringify(getDisplayIfNotGotten());
+	      return cName + ' (with properties: ' + properties + ')';
+	    }
+	    return cName;
+	  }
+
+	  if (arg === null) {
+	    return 'null';
+	  }
+
+	  if (type !== 'array' && type !== 'object') {
+	    return type;
+	  }
+
+	  if (hasKeys()) {
+	    return getDisplayIfNotGotten();
+	  }
+
+	  return cName;
+
+	  // utility functions
+	  function hasKeys() {
+	    return arg && Object.keys(arg).length;
+	  }
+
+	  function getDisplayIfNotGotten() {
+	    if (gottenArgs.indexOf(arg) !== -1) {
+	      return '[Circular]';
+	    }
+	    gottenArgs.push(arg);
+	    return getDisplay(arg, gottenArgs);
+	  }
+	}
+
+	function getDisplay(obj, gottenArgs) {
+	  var argDisplay = {};
+	  each(obj, function (v, k) {
+	    return argDisplay[k] = getArgDisplay(v, gottenArgs);
+	  });
+	  return argDisplay;
+	}
+
+	function getApiCheckApis() {
+	  var os = checkers.string.optional;
+
+	  var checkerFnChecker = checkers.func.withProperties({
+	    type: checkers.oneOfType([checkers.string, checkerTypeType]).optional,
+	    displayName: checkers.string.optional,
+	    shortType: checkers.string.optional,
+	    notOptional: checkers.bool.optional,
+	    notRequired: checkers.bool.optional
+	  });
+
+	  var getApiCheckInstanceCheckers = [checkers.shape({
+	    output: checkers.shape({
+	      prefix: checkers.string.optional,
+	      suffix: checkers.string.optional,
+	      docsBaseUrl: checkers.string.optional
+	    }).strict.optional,
+	    verbose: checkers.bool.optional,
+	    disabled: checkers.bool.optional
+	  }).strict.optional, checkers.objectOf(checkerFnChecker).optional];
+
+	  var checkApiCheckApi = [checkers.typeOrArrayOf(checkerFnChecker), checkers.any.optional, checkers.shape({
+	    prefix: os, suffix: os, urlSuffix: os, // appended case
+	    onlyPrefix: os, onlySuffix: os, url: os // override case
+	  }).strict.optional];
+
+	  return {
+	    checkerFnChecker: checkerFnChecker,
+	    getApiCheckInstanceCheckers: getApiCheckInstanceCheckers,
+	    checkApiCheckApi: checkApiCheckApi
+	  };
+	}
+
+/***/ },
+/* 2 */
+/***/ function(module, exports) {
+
+	module.exports = stringify;
+
+	function getSerialize (fn, decycle) {
+	  var seen = [], keys = [];
+	  decycle = decycle || function(key, value) {
+	    return '[Circular ' + getPath(value, seen, keys) + ']'
+	  };
+	  return function(key, value) {
+	    var ret = value;
+	    if (typeof value === 'object' && value) {
+	      if (seen.indexOf(value) !== -1)
+	        ret = decycle(key, value);
+	      else {
+	        seen.push(value);
+	        keys.push(key);
+	      }
+	    }
+	    if (fn) ret = fn(key, ret);
+	    return ret;
+	  }
+	}
+
+	function getPath (value, seen, keys) {
+	  var index = seen.indexOf(value);
+	  var path = [ keys[index] ];
+	  for (index--; index >= 0; index--) {
+	    if (seen[index][ path[0] ] === value) {
+	      value = seen[index];
+	      path.unshift(keys[index]);
+	    }
+	  }
+	  return '~' + path.join('.');
+	}
+
+	function stringify(obj, fn, spaces, decycle) {
+	  return JSON.stringify(obj, getSerialize(fn, decycle), spaces);
+	}
+
+	stringify.getSerialize = getSerialize;
+
+
+/***/ },
+/* 3 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+	var stringify = __webpack_require__(2);
+	var checkerHelpers = {
+	  addOptional: addOptional, getRequiredVersion: getRequiredVersion, setupChecker: setupChecker, addNullable: addNullable
+	};
+
+	module.exports = {
+	  each: each, copy: copy, typeOf: typeOf, arrayify: arrayify, getCheckerDisplay: getCheckerDisplay,
+	  isError: isError, list: list, getError: getError, nAtL: nAtL, t: t, undef: undef, checkerHelpers: checkerHelpers,
+	  noop: noop
+	};
+
+	function copy(obj) {
+	  var type = typeOf(obj);
+	  var daCopy = undefined;
+	  if (type === 'array') {
+	    daCopy = [];
+	  } else if (type === 'object') {
+	    daCopy = {};
+	  } else {
+	    return obj;
+	  }
+	  each(obj, function (val, key) {
+	    daCopy[key] = val; // cannot single-line this because we don't want to abort the each
+	  });
+	  return daCopy;
+	}
+
+	function typeOf(obj) {
+	  if (Array.isArray(obj)) {
+	    return 'array';
+	  } else if (obj instanceof RegExp) {
+	    return 'object';
+	  } else {
+	    return typeof obj;
+	  }
+	}
+
+	function getCheckerDisplay(checker, options) {
+	  /* eslint complexity:[2, 7] */
+	  var display = undefined;
+	  var short = options && options.short;
+	  if (short && checker.shortType) {
+	    display = checker.shortType;
+	  } else if (!short && typeof checker.type === 'object' || checker.type === 'function') {
+	    display = getCheckerType(checker, options);
+	  } else {
+	    display = getCheckerType(checker, options) || checker.displayName || checker.name;
+	  }
+	  return display;
+	}
+
+	function getCheckerType(_ref, options) {
+	  var type = _ref.type;
+
+	  if (typeof type === 'function') {
+	    var __apiCheckData = type.__apiCheckData;
+	    var typeTypes = type(options);
+	    type = _defineProperty({
+	      __apiCheckData: __apiCheckData
+	    }, __apiCheckData.type, typeTypes);
+	  }
+	  return type;
+	}
+
+	function arrayify(obj) {
+	  if (!obj) {
+	    return [];
+	  } else if (Array.isArray(obj)) {
+	    return obj;
+	  } else {
+	    return [obj];
+	  }
+	}
+
+	function each(obj, iterator, context) {
+	  if (Array.isArray(obj)) {
+	    return eachArry(obj, iterator, context);
+	  } else {
+	    return eachObj(obj, iterator, context);
+	  }
+	}
+
+	function eachObj(obj, iterator, context) {
+	  var ret = undefined;
+	  var hasOwn = Object.prototype.hasOwnProperty;
+	  /* eslint prefer-const:0 */ // some weird eslint bug?
+	  for (var key in obj) {
+	    if (hasOwn.call(obj, key)) {
+	      ret = iterator.call(context, obj[key], key, obj);
+	      if (ret === false) {
+	        return ret;
+	      }
+	    }
+	  }
+	  return true;
+	}
+
+	function eachArry(obj, iterator, context) {
+	  var ret = undefined;
+	  var length = obj.length;
+	  for (var i = 0; i < length; i++) {
+	    ret = iterator.call(context, obj[i], i, obj);
+	    if (ret === false) {
+	      return ret;
+	    }
+	  }
+	  return true;
+	}
+
+	function isError(obj) {
+	  return obj instanceof Error;
+	}
+
+	function list(arry, join, finalJoin) {
+	  arry = arrayify(arry);
+	  var copy = arry.slice();
+	  var last = copy.pop();
+	  if (copy.length === 1) {
+	    join = ' ';
+	  }
+	  return copy.join(join) + ('' + (copy.length ? join + finalJoin : '') + last);
+	}
+
+	function getError(name, location, checkerType) {
+	  if (typeof checkerType === 'function') {
+	    checkerType = checkerType({ short: true });
+	  }
+	  var stringType = typeof checkerType !== 'object' ? checkerType : stringify(checkerType);
+	  return new Error(nAtL(name, location) + ' must be ' + t(stringType));
+	}
+
+	function nAtL(name, location) {
+	  var tName = t(name || 'value');
+	  var tLocation = !location ? '' : ' at ' + t(location);
+	  return '' + tName + tLocation;
+	}
+
+	function t(thing) {
+	  return '`' + thing + '`';
+	}
+
+	function undef(thing) {
+	  return typeof thing === 'undefined';
+	}
+
+	/**
+	 * This will set up the checker with all of the defaults that most checkers want like required by default and an
+	 * optional version
+	 *
+	 * @param {Function} checker - the checker to setup with properties
+	 * @param {Object} properties - properties to add to the checker
+	 * @param {boolean} disabled - when set to true, this will set the checker to a no-op function
+	 * @returns {Function} checker - the setup checker
+	 */
+	function setupChecker(checker, properties, disabled) {
+	  /* eslint complexity:[2, 9] */
+	  if (disabled) {
+	    // swap out the checker for its own copy of noop
+	    checker = getNoop();
+	    checker.isNoop = true;
+	  }
+
+	  if (typeof checker.type === 'string') {
+	    checker.shortType = checker.type;
+	  }
+
+	  // assign all properties given
+	  each(properties, function (prop, name) {
+	    return checker[name] = prop;
+	  });
+
+	  if (!checker.displayName) {
+	    checker.displayName = 'apiCheck ' + t(checker.shortType || checker.type || checker.name) + ' type checker';
+	  }
+
+	  if (!checker.notRequired) {
+	    checker = getRequiredVersion(checker, disabled);
+	  }
+
+	  if (!checker.notNullable) {
+	    addNullable(checker, disabled);
+	  }
+
+	  if (!checker.notOptional) {
+	    addOptional(checker, disabled);
+	  }
+
+	  return checker;
+	}
+
+	function getRequiredVersion(checker, disabled) {
+	  var requiredChecker = disabled ? getNoop() : function requiredChecker(val, name, location, obj) {
+	    if (undef(val) && !checker.isOptional) {
+	      var tLocation = location ? ' in ' + t(location) : '';
+	      var type = getCheckerDisplay(checker, { short: true });
+	      var stringType = typeof type !== 'object' ? type : stringify(type);
+	      return new Error('Required ' + t(name) + ' not specified' + tLocation + '. Must be ' + t(stringType));
+	    } else {
+	      return checker(val, name, location, obj);
+	    }
+	  };
+	  copyProps(checker, requiredChecker);
+	  requiredChecker.originalChecker = checker;
+	  return requiredChecker;
+	}
+
+	function addOptional(checker, disabled) {
+	  var optionalCheck = disabled ? getNoop() : function optionalCheck(val, name, location, obj) {
+	    if (!undef(val)) {
+	      return checker(val, name, location, obj);
+	    }
+	  };
+	  // inherit all properties on the original checker
+	  copyProps(checker, optionalCheck);
+
+	  optionalCheck.isOptional = true;
+	  optionalCheck.displayName = checker.displayName + ' (optional)';
+	  optionalCheck.originalChecker = checker;
+
+	  // the magic line that allows you to add .optional to the end of the checkers
+	  checker.optional = optionalCheck;
+
+	  fixType(checker, checker.optional);
+	}
+
+	function addNullable(checker, disabled) {
+	  var nullableCheck = disabled ? getNoop() : function nullableCheck(val, name, location, obj) {
+	    if (val !== null) {
+	      return checker(val, name, location, obj);
+	    }
+	  };
+	  // inherit all properties on the original checker
+	  copyProps(checker, nullableCheck);
+
+	  nullableCheck.isNullable = true;
+	  nullableCheck.displayName = checker.displayName + ' (nullable)';
+	  nullableCheck.originalChecker = checker;
+
+	  // the magic line that allows you to add .nullable to the end of the checkers
+	  checker.nullable = nullableCheck;
+
+	  fixType(checker, checker.nullable);
+	  if (!checker.notOptional) {
+	    addOptional(checker.nullable, disabled);
+	  }
+	}
+
+	function fixType(checker, checkerCopy) {
+	  // fix type, because it's not a straight copy...
+	  // the reason is we need to specify type.__apiCheckData.optional as true for the terse/verbose option.
+	  // we also want to add "(optional)" to the types with a string
+	  if (typeof checkerCopy.type === 'object') {
+	    checkerCopy.type = copy(checkerCopy.type); // make our own copy of this
+	  } else if (typeof checkerCopy.type === 'function') {
+	      checkerCopy.type = function () {
+	        return checker.type.apply(checker, arguments);
+	      };
+	    } else {
+	      checkerCopy.type += ' (optional)';
+	      return;
+	    }
+	  checkerCopy.type.__apiCheckData = copy(checker.type.__apiCheckData) || {}; // and this
+	  checkerCopy.type.__apiCheckData.optional = true;
+	}
+
+	// UTILS
+
+	function copyProps(src, dest) {
+	  each(Object.keys(src), function (key) {
+	    return dest[key] = src[key];
+	  });
+	}
+
+	function noop() {}
+
+	function getNoop() {
+	  /* eslint no-shadow:0 */
+	  /* istanbul ignore next */
+	  return function noop() {};
+	}
+
+/***/ },
+/* 4 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var stringify = __webpack_require__(2);
+
+	var _require = __webpack_require__(3);
+
+	var typeOf = _require.typeOf;
+	var each = _require.each;
+	var copy = _require.copy;
+	var getCheckerDisplay = _require.getCheckerDisplay;
+	var isError = _require.isError;
+	var arrayify = _require.arrayify;
+	var list = _require.list;
+	var getError = _require.getError;
+	var nAtL = _require.nAtL;
+	var t = _require.t;
+	var checkerHelpers = _require.checkerHelpers;
+	var undef = _require.undef;
+	var setupChecker = checkerHelpers.setupChecker;
+
+	var checkers = module.exports = getCheckers();
+	module.exports.getCheckers = getCheckers;
+
+	function getCheckers(disabled) {
+	  return {
+	    array: typeOfCheckGetter('Array'),
+	    bool: typeOfCheckGetter('Boolean'),
+	    number: typeOfCheckGetter('Number'),
+	    string: typeOfCheckGetter('String'),
+	    func: funcCheckGetter(),
+	    object: objectCheckGetter(),
+
+	    emptyObject: emptyObjectCheckGetter(),
+
+	    instanceOf: instanceCheckGetter,
+	    oneOf: oneOfCheckGetter,
+	    oneOfType: oneOfTypeCheckGetter,
+
+	    arrayOf: arrayOfCheckGetter,
+	    objectOf: objectOfCheckGetter,
+	    typeOrArrayOf: typeOrArrayOfCheckGetter,
+
+	    range: rangeCheckGetter,
+	    lessThan: lessThanCheckGetter,
+	    greaterThan: greaterThanCheckGetter,
+
+	    shape: getShapeCheckGetter(),
+	    args: argumentsCheckerGetter(),
+
+	    any: anyCheckGetter(),
+	    'null': nullCheckGetter()
+
+	  };
+
+	  function typeOfCheckGetter(type) {
+	    var lType = type.toLowerCase();
+	    return setupChecker(function typeOfCheckerDefinition(val, name, location) {
+	      if (typeOf(val) !== lType) {
+	        return getError(name, location, type);
+	      }
+	    }, { type: type }, disabled);
+	  }
+
+	  function funcCheckGetter() {
+	    var type = 'Function';
+	    var functionChecker = setupChecker(function functionCheckerDefinition(val, name, location) {
+	      if (typeOf(val) !== 'function') {
+	        return getError(name, location, type);
+	      }
+	    }, { type: type }, disabled);
+
+	    functionChecker.withProperties = function getWithPropertiesChecker(properties) {
+	      var apiError = checkers.objectOf(checkers.func)(properties, 'properties', 'apiCheck.func.withProperties');
+	      if (isError(apiError)) {
+	        throw apiError;
+	      }
+	      var shapeChecker = checkers.shape(properties, true);
+	      shapeChecker.type.__apiCheckData.type = 'func.withProperties';
+
+	      return setupChecker(function functionWithPropertiesChecker(val, name, location) {
+	        var notFunction = checkers.func(val, name, location);
+	        if (isError(notFunction)) {
+	          return notFunction;
+	        }
+	        return shapeChecker(val, name, location);
+	      }, { type: shapeChecker.type, shortType: 'func.withProperties' }, disabled);
+	    };
+	    return functionChecker;
+	  }
+
+	  function objectCheckGetter() {
+	    var type = 'Object';
+	    var nullType = 'Object (null ok)';
+	    var objectNullOkChecker = setupChecker(function objectNullOkCheckerDefinition(val, name, location) {
+	      if (typeOf(val) !== 'object') {
+	        return getError(name, location, nullType);
+	      }
+	    }, { type: nullType }, disabled);
+
+	    var objectChecker = setupChecker(function objectCheckerDefinition(val, name, location) {
+	      if (val === null || isError(objectNullOkChecker(val, name, location))) {
+	        return getError(name, location, objectChecker.type);
+	      }
+	    }, { type: type, nullOk: objectNullOkChecker }, disabled);
+
+	    return objectChecker;
+	  }
+
+	  function instanceCheckGetter(classToCheck) {
+	    return setupChecker(function instanceCheckerDefinition(val, name, location) {
+	      if (!(val instanceof classToCheck)) {
+	        return getError(name, location, classToCheck.name);
+	      }
+	    }, { type: classToCheck.name }, disabled);
+	  }
+
+	  function oneOfCheckGetter(enums) {
+	    var type = {
+	      __apiCheckData: { optional: false, type: 'enum' },
+	      'enum': enums
+	    };
+	    var shortType = 'oneOf[' + enums.map(function (enm) {
+	      return stringify(enm);
+	    }).join(', ') + ']';
+	    return setupChecker(function oneOfCheckerDefinition(val, name, location) {
+	      if (!enums.some(function (enm) {
+	        return enm === val;
+	      })) {
+	        return getError(name, location, shortType);
+	      }
+	    }, { type: type, shortType: shortType }, disabled);
+	  }
+
+	  function oneOfTypeCheckGetter(typeCheckers) {
+	    var checkersDisplay = typeCheckers.map(function (checker) {
+	      return getCheckerDisplay(checker, { short: true });
+	    });
+	    var shortType = 'oneOfType[' + checkersDisplay.join(', ') + ']';
+	    function type(options) {
+	      if (options && options.short) {
+	        return shortType;
+	      }
+	      return typeCheckers.map(function (checker) {
+	        return getCheckerDisplay(checker, options);
+	      });
+	    }
+	    type.__apiCheckData = { optional: false, type: 'oneOfType' };
+	    return setupChecker(function oneOfTypeCheckerDefinition(val, name, location) {
+	      if (!typeCheckers.some(function (checker) {
+	        return !isError(checker(val, name, location));
+	      })) {
+	        return getError(name, location, shortType);
+	      }
+	    }, { type: type, shortType: shortType }, disabled);
+	  }
+
+	  function arrayOfCheckGetter(checker) {
+	    var shortCheckerDisplay = getCheckerDisplay(checker, { short: true });
+	    var shortType = 'arrayOf[' + shortCheckerDisplay + ']';
+
+	    function type(options) {
+	      if (options && options.short) {
+	        return shortType;
+	      }
+	      return getCheckerDisplay(checker, options);
+	    }
+	    type.__apiCheckData = { optional: false, type: 'arrayOf' };
+
+	    return setupChecker(function arrayOfCheckerDefinition(val, name, location) {
+	      if (isError(checkers.array(val)) || !val.every(function (item) {
+	        return !isError(checker(item));
+	      })) {
+	        return getError(name, location, shortType);
+	      }
+	    }, { type: type, shortType: shortType }, disabled);
+	  }
+
+	  function objectOfCheckGetter(checker) {
+	    var checkerDisplay = getCheckerDisplay(checker, { short: true });
+	    var shortType = 'objectOf[' + checkerDisplay + ']';
+
+	    function type(options) {
+	      if (options && options.short) {
+	        return shortType;
+	      }
+	      return getCheckerDisplay(checker, options);
+	    }
+	    type.__apiCheckData = { optional: false, type: 'objectOf' };
+
+	    return setupChecker(function objectOfCheckerDefinition(val, name, location) {
+	      var notObject = checkers.object(val, name, location);
+	      if (isError(notObject)) {
+	        return notObject;
+	      }
+	      var allTypesSuccess = each(val, function (item, key) {
+	        if (isError(checker(item, key, name))) {
+	          return false;
+	        }
+	      });
+	      if (!allTypesSuccess) {
+	        return getError(name, location, shortType);
+	      }
+	    }, { type: type, shortType: shortType }, disabled);
+	  }
+
+	  function typeOrArrayOfCheckGetter(checker) {
+	    var checkerDisplay = getCheckerDisplay(checker, { short: true });
+	    var shortType = 'typeOrArrayOf[' + checkerDisplay + ']';
+
+	    function type(options) {
+	      if (options && options.short) {
+	        return shortType;
+	      }
+	      return getCheckerDisplay(checker, options);
+	    }
+
+	    type.__apiCheckData = { optional: false, type: 'typeOrArrayOf' };
+	    return setupChecker(function typeOrArrayOfDefinition(val, name, location, obj) {
+	      if (isError(checkers.oneOfType([checker, checkers.arrayOf(checker)])(val, name, location, obj))) {
+	        return getError(name, location, shortType);
+	      }
+	    }, { type: type, shortType: shortType }, disabled);
+	  }
+
+	  function getShapeCheckGetter() {
+	    function shapeCheckGetter(shape, nonObject) {
+	      var shapeTypes = {};
+	      each(shape, function (checker, prop) {
+	        shapeTypes[prop] = getCheckerDisplay(checker);
+	      });
+	      function type() {
+	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+	        var ret = {};
+	        var terse = options.terse;
+	        var obj = options.obj;
+	        var addHelpers = options.addHelpers;
+
+	        var parentRequired = options.required;
+	        each(shape, function (checker, prop) {
+	          /* eslint complexity:[2, 6] */
+	          var specified = obj && obj.hasOwnProperty(prop);
+	          var required = undef(parentRequired) ? !checker.isOptional : parentRequired;
+	          if (!terse || (specified || !checker.isOptional)) {
+	            ret[prop] = getCheckerDisplay(checker, { terse: terse, obj: obj && obj[prop], required: required, addHelpers: addHelpers });
+	          }
+	          if (addHelpers) {
+	            modifyTypeDisplayToHelpOut(ret, prop, specified, checker, required);
+	          }
+	        });
+	        return ret;
+
+	        function modifyTypeDisplayToHelpOut(theRet, prop, specified, checker, required) {
+	          if (!specified && required && !checker.isOptional) {
+	            var item = 'ITEM';
+	            if (checker.type && checker.type.__apiCheckData) {
+	              item = checker.type.__apiCheckData.type.toUpperCase();
+	            }
+	            addHelper('missing', 'MISSING THIS ' + item, ' <-- YOU ARE MISSING THIS');
+	          } else if (specified) {
+	            var error = checker(obj[prop], prop, null, obj);
+	            if (isError(error)) {
+	              addHelper('error', 'THIS IS THE PROBLEM: ' + error.message, ' <-- THIS IS THE PROBLEM: ' + error.message);
+	            }
+	          }
+
+	          function addHelper(property, objectMessage, stringMessage) {
+	            if (typeof theRet[prop] === 'string') {
+	              theRet[prop] += stringMessage;
+	            } else {
+	              theRet[prop].__apiCheckData[property] = objectMessage;
+	            }
+	          }
+	        }
+	      }
+
+	      type.__apiCheckData = { strict: false, optional: false, type: 'shape' };
+	      var shapeChecker = setupChecker(function shapeCheckerDefinition(val, name, location) {
+	        /* eslint complexity:[2, 6] */
+	        var isObject = !nonObject && checkers.object(val, name, location);
+	        if (isError(isObject)) {
+	          return isObject;
+	        }
+	        var shapePropError = undefined;
+	        location = location ? location + (name ? '/' : '') : '';
+	        name = name || '';
+	        each(shape, function (checker, prop) {
+	          if (val.hasOwnProperty(prop) || !checker.isOptional) {
+	            shapePropError = checker(val[prop], prop, '' + location + name, val);
+	            return !isError(shapePropError);
+	          }
+	        });
+	        if (isError(shapePropError)) {
+	          return shapePropError;
+	        }
+	      }, { type: type, shortType: 'shape' }, disabled);
+
+	      function strictType() {
+	        return type.apply(undefined, arguments);
+	      }
+
+	      strictType.__apiCheckData = copy(shapeChecker.type.__apiCheckData);
+	      strictType.__apiCheckData.strict = true;
+	      shapeChecker.strict = setupChecker(function strictShapeCheckerDefinition(val, name, location) {
+	        var shapeError = shapeChecker(val, name, location);
+	        if (isError(shapeError)) {
+	          return shapeError;
+	        }
+	        var allowedProperties = Object.keys(shape);
+	        var extraProps = Object.keys(val).filter(function (prop) {
+	          return allowedProperties.indexOf(prop) === -1;
+	        });
+	        if (extraProps.length) {
+	          return new Error(nAtL(name, location) + ' cannot have extra properties: ' + t(extraProps.join('`, `')) + '.' + ('It is limited to ' + t(allowedProperties.join('`, `'))));
+	        }
+	      }, { type: strictType, shortType: 'strict shape' }, disabled);
+
+	      return shapeChecker;
+	    }
+
+	    shapeCheckGetter.ifNot = function ifNot(otherProps, propChecker) {
+	      if (!Array.isArray(otherProps)) {
+	        otherProps = [otherProps];
+	      }
+	      var description = undefined;
+	      if (otherProps.length === 1) {
+	        description = 'specified only if ' + otherProps[0] + ' is not specified';
+	      } else {
+	        description = 'specified only if none of the following are specified: [' + list(otherProps, ', ', 'and ') + ']';
+	      }
+	      var shortType = 'ifNot[' + otherProps.join(', ') + ']';
+	      var type = getTypeForShapeChild(propChecker, description, shortType);
+	      return setupChecker(function ifNotChecker(prop, propName, location, obj) {
+	        var propExists = obj && obj.hasOwnProperty(propName);
+	        var otherPropsExist = otherProps.some(function (otherProp) {
+	          return obj && obj.hasOwnProperty(otherProp);
+	        });
+	        if (propExists === otherPropsExist) {
+	          return getError(propName, location, type);
+	        } else if (propExists) {
+	          return propChecker(prop, propName, location, obj);
+	        }
+	      }, { notRequired: true, type: type, shortType: shortType }, disabled);
+	    };
+
+	    shapeCheckGetter.onlyIf = function onlyIf(otherProps, propChecker) {
+	      otherProps = arrayify(otherProps);
+	      var description = undefined;
+	      if (otherProps.length === 1) {
+	        description = 'specified only if ' + otherProps[0] + ' is also specified';
+	      } else {
+	        description = 'specified only if all of the following are specified: [' + list(otherProps, ', ', 'and ') + ']';
+	      }
+	      var shortType = 'onlyIf[' + otherProps.join(', ') + ']';
+	      var type = getTypeForShapeChild(propChecker, description, shortType);
+	      return setupChecker(function onlyIfCheckerDefinition(prop, propName, location, obj) {
+	        var othersPresent = otherProps.every(function (property) {
+	          return obj.hasOwnProperty(property);
+	        });
+	        if (!othersPresent) {
+	          return getError(propName, location, type);
+	        } else {
+	          return propChecker(prop, propName, location, obj);
+	        }
+	      }, { type: type, shortType: shortType }, disabled);
+	    };
+
+	    shapeCheckGetter.requiredIfNot = function shapeRequiredIfNot(otherProps, propChecker) {
+	      if (!Array.isArray(otherProps)) {
+	        otherProps = [otherProps];
+	      }
+	      return getRequiredIfNotChecker(false, otherProps, propChecker);
+	    };
+
+	    shapeCheckGetter.requiredIfNot.all = function shapeRequiredIfNotAll(otherProps, propChecker) {
+	      if (!Array.isArray(otherProps)) {
+	        throw new Error('requiredIfNot.all must be passed an array');
+	      }
+	      return getRequiredIfNotChecker(true, otherProps, propChecker);
+	    };
+
+	    function getRequiredIfNotChecker(all, otherProps, propChecker) {
+	      var props = t(otherProps.join(', '));
+	      var ifProps = 'if ' + (all ? 'all of' : 'at least one of');
+	      var description = 'specified ' + ifProps + ' these are not specified: ' + props + ' (otherwise it\'s optional)';
+	      var shortType = 'requiredIfNot' + (all ? '.all' : '') + '[' + otherProps.join(', ') + '}]';
+	      var type = getTypeForShapeChild(propChecker, description, shortType);
+	      return setupChecker(function shapeRequiredIfNotDefinition(prop, propName, location, obj) {
+	        var propExists = obj && obj.hasOwnProperty(propName);
+	        var iteration = all ? 'every' : 'some';
+	        var otherPropsExist = otherProps[iteration](function (otherProp) {
+	          return obj && obj.hasOwnProperty(otherProp);
+	        });
+	        if (!otherPropsExist && !propExists) {
+	          return getError(propName, location, type);
+	        } else if (propExists) {
+	          return propChecker(prop, propName, location, obj);
+	        }
+	      }, { type: type, notRequired: true }, disabled);
+	    }
+
+	    return shapeCheckGetter;
+
+	    function getTypeForShapeChild(propChecker, description, shortType) {
+	      function type(options) {
+	        if (options && options.short) {
+	          return shortType;
+	        }
+	        return getCheckerDisplay(propChecker);
+	      }
+	      type.__apiCheckData = { optional: false, type: 'ifNot', description: description };
+	      return type;
+	    }
+	  }
+
+	  function argumentsCheckerGetter() {
+	    var type = 'function arguments';
+	    return setupChecker(function argsCheckerDefinition(val, name, location) {
+	      if (Array.isArray(val) || isError(checkers.object(val)) || isError(checkers.number(val.length))) {
+	        return getError(name, location, type);
+	      }
+	    }, { type: type }, disabled);
+	  }
+
+	  function anyCheckGetter() {
+	    return setupChecker(function anyCheckerDefinition() {
+	      // don't do anything
+	    }, { type: 'any' }, disabled);
+	  }
+
+	  function nullCheckGetter() {
+	    var type = 'null';
+	    return setupChecker(function nullChecker(val, name, location) {
+	      if (val !== null) {
+	        return getError(name, location, type);
+	      }
+	    }, { type: type }, disabled);
+	  }
+
+	  function rangeCheckGetter(min, max) {
+	    var type = 'Range (' + min + ' - ' + max + ')';
+	    return setupChecker(function rangeChecker(val, name, location) {
+	      if (typeof val !== 'number' || val < min || val > max) {
+	        return getError(name, location, type);
+	      }
+	    }, { type: type }, disabled);
+	  }
+
+	  function lessThanCheckGetter(min) {
+	    var type = 'lessThan[' + min + ']';
+	    return setupChecker(function lessThanChecker(val, name, location) {
+	      if (typeof val !== 'number' || val > min) {
+	        return getError(name, location, type);
+	      }
+	    }, { type: type }, disabled);
+	  }
+
+	  function greaterThanCheckGetter(max) {
+	    var type = 'greaterThan[' + max + ']';
+	    return setupChecker(function greaterThanChecker(val, name, location) {
+	      if (typeof val !== 'number' || val < max) {
+	        return getError(name, location, type);
+	      }
+	    }, { type: type }, disabled);
+	  }
+
+	  function emptyObjectCheckGetter() {
+	    var type = 'empty object';
+	    return setupChecker(function emptyObjectChecker(val, name, location) {
+	      if (typeOf(val) !== 'object' || val === null || Object.keys(val).length) {
+	        return getError(name, location, type);
+	      }
+	    }, { type: type }, disabled);
+	  }
+	}
+
+/***/ }
+/******/ ])
+});
+;

static/js/eda.dragdropway.css

@@ -0,0 +1,913 @@
+/*=========================================================
+    colors const
+===========================================================*/
+/*=========================================================
+    fonts const
+===========================================================*/
+/*=========================================================
+    common
+===========================================================*/
+.ta-hidden-input {
+  width: 1px;
+  height: 1px;
+  border: none;
+  margin: 0;
+  padding: 0;
+  position: absolute;
+  top: -10000px;
+  left: -10000px;
+  opacity: 0;
+  overflow: hidden; }
+
+.ta-root.focussed > .ta-scroll-window.form-control {
+  border-color: #66afe9;
+  outline: 0;
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 8px rgba(102, 175, 233, 0.6); }
+
+.ta-editor.ta-html, .ta-scroll-window.form-control {
+  min-height: 300px;
+  height: auto;
+  overflow: auto;
+  font-family: inherit;
+  font-size: 100%; }
+
+.ta-scroll-window.form-control {
+  position: relative;
+  padding: 0; }
+
+.ta-scroll-window > .ta-bind {
+  height: auto;
+  min-height: 300px;
+  padding: 6px 12px; }
+
+.ta-editor:focus {
+  -webkit-user-select: text;
+     -moz-user-select: text;
+      -ms-user-select: text;
+          user-select: text; }
+
+.ta-resizer-handle-overlay {
+  z-index: 100;
+  position: absolute;
+  display: none; }
+
+.ta-resizer-handle-overlay > .ta-resizer-handle-info {
+  position: absolute;
+  bottom: 16px;
+  right: 16px;
+  border: 1px solid #000;
+  background-color: #FFF;
+  padding: 0 4px;
+  opacity: .7; }
+
+.ta-resizer-handle-overlay > .ta-resizer-handle-background {
+  position: absolute;
+  bottom: 5px;
+  right: 5px;
+  left: 5px;
+  top: 5px;
+  border: 1px solid #000;
+  background-color: rgba(0, 0, 0, 0.2); }
+
+.ta-resizer-handle-overlay > .ta-resizer-handle-corner {
+  width: 10px;
+  height: 10px;
+  position: absolute; }
+
+.ta-resizer-handle-overlay > .ta-resizer-handle-corner-tl {
+  top: 0;
+  left: 0;
+  border-left: 1px solid #000;
+  border-top: 1px solid #000; }
+
+.ta-resizer-handle-overlay > .ta-resizer-handle-corner-tr {
+  top: 0;
+  right: 0;
+  border-right: 1px solid #000;
+  border-top: 1px solid #000; }
+
+.ta-resizer-handle-overlay > .ta-resizer-handle-corner-bl {
+  bottom: 0;
+  left: 0;
+  border-left: 1px solid #000;
+  border-bottom: 1px solid #000; }
+
+.ta-resizer-handle-overlay > .ta-resizer-handle-corner-br {
+  bottom: 0;
+  right: 0;
+  border: 1px solid #000;
+  cursor: se-resize;
+  background-color: #fff; }
+
+.popover {
+  position: absolute;
+  top: 0;
+  left: 0;
+  z-index: 1060;
+  display: none;
+  max-width: 276px;
+  padding: 1px;
+  font-size: 14px;
+  font-weight: 400;
+  line-height: 1.42857143;
+  text-align: left;
+  white-space: normal;
+  background-color: #fff;
+  background-clip: padding-box;
+  border: 1px solid #ccc;
+  border: 1px solid rgba(0, 0, 0, 0.2);
+  border-radius: 6px;
+  box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2); }
+
+.popover.top {
+  margin-top: -10px; }
+
+.popover.bottom {
+  margin-top: 10px; }
+
+.popover-title {
+  padding: 8px 14px;
+  margin: 0;
+  font-size: 14px;
+  background-color: #f7f7f7;
+  border-bottom: 1px solid #ebebeb;
+  border-radius: 5px 5px 0 0; }
+
+.popover-content {
+  padding: 9px 14px; }
+
+.popover > .arrow, .popover > .arrow:after {
+  position: absolute;
+  display: block;
+  width: 0;
+  height: 0;
+  border-color: transparent;
+  border-style: solid; }
+
+.popover > .arrow {
+  border-width: 11px; }
+
+.popover > .arrow:after {
+  content: "";
+  border-width: 10px; }
+
+.popover.top > .arrow {
+  bottom: -11px;
+  left: 50%;
+  margin-left: -11px;
+  border-top-color: #999;
+  border-top-color: rgba(0, 0, 0, 0.25);
+  border-bottom-width: 0; }
+
+.popover.top > .arrow:after {
+  bottom: 1px;
+  margin-left: -10px;
+  content: " ";
+  border-top-color: #fff;
+  border-bottom-width: 0; }
+
+.popover.bottom > .arrow {
+  top: -11px;
+  left: 50%;
+  margin-left: -11px;
+  border-top-width: 0;
+  border-bottom-color: #999;
+  border-bottom-color: rgba(0, 0, 0, 0.25); }
+
+.popover.bottom > .arrow:after {
+  top: 1px;
+  margin-left: -10px;
+  content: " ";
+  border-top-width: 0;
+  border-bottom-color: #fff; }
+
+/*=========================================================
+    common
+===========================================================*/
+body {
+  padding-top: 50px;
+  padding-bottom: 20px;
+  height: 100%;
+  background-color: #F2F2F2;
+  font-family: "Roboto", "Helvetica Neue", Helvetica, Arial, sans-serif; }
+
+.margintop60px {
+  margin-top: 80px; }
+
+.margintop120px {
+  margin-top: 120px; }
+
+.vAlignMiddle {
+  vertical-align: middle; }
+
+[ng\:cloak], [ng-cloak], [data-ng-cloak], [x-ng-cloak], .ng-cloak, .x-ng-cloak {
+  display: none !important; }
+
+/*=========================================================
+    bootstrap overrides
+===========================================================*/
+.nav .open > a, .nav .open > a:hover, .nav .open > a:focus {
+  background-color: #0d87e9;
+  border-color: #2196f3; }
+
+/*correction bug sur theme bootstrap journal*/
+.modal-backdrop {
+  z-index: -1; }
+
+.navbar-right {
+  margin-right: 20px; }
+
+textarea, textarea.form-control, input.form-control,
+input[type=text], input[type=password], input[type=email],
+input[type=number], [type=text].form-control, [type=password].form-control,
+[type=email].form-control, [type=tel].form-control, [contenteditable].form-control {
+  font-size: 13px; }
+
+select, select.form-control {
+  font-size: 13px; }
+
+/*container to 100%*/
+@media (min-width: 1200px) {
+  .container {
+    width: 100%;
+    margin-right: 20px; } }
+
+@media (min-width: 768px) {
+  .container {
+    width: 100%;
+    margin-right: 20px; } }
+
+@media (min-width: 992px) {
+  .container {
+    width: 100%; } }
+
+.container-fluid {
+  margin-right: auto;
+  margin-left: auto; }
+
+.container-fluid padding {
+  left: 30px;
+  right: 30px; }
+
+.panel-default > .panel-heading {
+  color: #212121;
+  background-color: #fff;
+  border-color: #eee; }
+
+.navbar-nav > li > a {
+  line-height: 30px; }
+
+.navbar-default .navbar-brand {
+  line-height: initial; }
+
+.panel-heading {
+  background-color: none;
+  border-bottom: solid 1px #eee; }
+
+.navBtnGroup {
+  padding-top: 20px;
+  padding-bottom: 22px;
+  padding-right: 15px;
+  padding-left: 15px; }
+
+.table > thead > tr > th,
+.table > tbody > tr > th,
+.table > tfoot > tr > th,
+.table > thead > tr > td,
+.table > tbody > tr > td,
+.table > tfoot > tr > td {
+  vertical-align: middle; }
+
+a:hover {
+  color: #fff; }
+
+a:focus {
+  color: #fff; }
+
+/*Forms setup*/
+.form-control {
+  border-radius: 0;
+  box-shadow: none;
+  height: auto; }
+
+.float-label {
+  font-size: 10px; }
+
+.socialIcon {
+  font-size: 32px; }
+  .socialIcon:hover {
+    color: #F2F2F2; }
+
+input[type="text"].form-control,
+input[type="search"].form-control {
+  border: none;
+  border-bottom: 1px dotted #CFCFCF; }
+
+textarea {
+  border: 1px dotted #CFCFCF !important;
+  height: 130px !important; }
+
+/*Content Container*/
+.content-container {
+  background-color: #fff;
+  padding: 35px 20px;
+  margin-bottom: 20px; }
+
+h1.content-title {
+  font-size: 32px;
+  font-weight: 300;
+  text-align: center;
+  margin-top: 0;
+  margin-bottom: 20px;
+  font-family: "Open Sans", sans-serif !important; }
+
+/*paper theme bootstrap*/
+.form-control {
+  font-family: "Roboto", "Helvetica Neue", Helvetica, Arial, sans-serif;
+  display: block;
+  width: 100%;
+  height: 39px;
+  padding: 8px 12px;
+  font-size: 13px;
+  line-height: 1.42857143;
+  color: #777777;
+  background-color: #ffffff;
+  background-image: none;
+  border: 1px solid #cccccc;
+  border-radius: 4px;
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s; }
+
+.form-control:focus {
+  border-color: #66afe9;
+  outline: 0;
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 8px rgba(102, 175, 233, 0.6); }
+
+.form-control::-moz-placeholder {
+  color: #999999;
+  opacity: 1; }
+
+.form-control:-ms-input-placeholder {
+  color: #999999; }
+
+.form-control::-webkit-input-placeholder {
+  color: #999999; }
+
+.form-control[disabled],
+.form-control[readonly],
+fieldset[disabled] .form-control {
+  background-color: #eeeeee;
+  opacity: 1; }
+
+.form-control[disabled],
+fieldset[disabled] .form-control {
+  cursor: not-allowed; }
+
+textarea.form-control {
+  height: auto; }
+
+.fakeControl[disabled] {
+  background-color: #fff;
+  opacity: 1; }
+
+.fakeControl[disabled] {
+  cursor: all-scroll; }
+
+.radio input[type=radio].fakeCheck {
+  cursor: all-scroll; }
+
+.checkbox input[type=checkbox].fakeCheck {
+  cursor: all-scroll; }
+
+label.fakeCheck {
+  cursor: all-scroll; }
+
+/* animation ng-repeat
+easy customize animation from here : http://www.nganimate.org/angularjs/ng-repeat/yo-yo-css3-keyframes-animation*/
+.animate-enter {
+  animation: enter 600ms cubic-bezier(0.445, 0.05, 0.55, 0.95);
+  display: block;
+  position: relative; }
+
+@keyframes enter {
+  from {
+    opacity: 0;
+    height: 0px;
+    left: -70px; }
+  75% {
+    left: 15px; }
+  to {
+    opacity: 1;
+    height: 30px;
+    left: 0px; } }
+
+.animate-leave {
+  animation: leave 600ms cubic-bezier(0.445, 0.05, 0.55, 0.95);
+  display: block;
+  position: relative; }
+
+@keyframes leave {
+  to {
+    opacity: 0;
+    height: 0px;
+    left: -70px; }
+  25% {
+    left: 15px; }
+  from {
+    opacity: 1;
+    height: 30px;
+    left: 0px; } }
+
+/* td table in myprofile */
+.tdCommun, .td40, .td60 {
+  height: 75px;
+  vertical-align: none; }
+
+.td40 {
+  width: 40%; }
+
+.td60 {
+  width: 60%; }
+
+.table-user-information > thead > tr > th,
+.table-user-information > tbody > tr > th,
+.table-user-information > tfoot > tr > th,
+.table-user-information > thead > tr > td,
+.table-user-information > tbody > tr > td,
+.table-user-information > tfoot > tr > td {
+  vertical-align: middle; }
+
+/*=========================================================
+   ANGULAR ANIMATIONS (in pair on animate.css)
+===========================================================*/
+/* animation on ng-switch */
+.switchAngularFadeIn .ng-enter {
+  animation: fadeIn 1s; }
+
+/*=========================================================
+   wfEdit
+===========================================================*/
+#pageWfEdit {
+  margin-top: 40px;
+  /*    right:2%;
+    left:2%; */
+  padding-top: 30px;
+  padding-bottom: 30px;
+  background-color: #F2F2F2;
+  /* border-top: solid 3px white;
+  border-bottom: solid 3px white; */ }
+
+.lineCommandButtons {
+  padding-bottom: 25px; }
+
+.addNewLine {
+  font-size: 24px;
+  vertical-align: middle;
+  color: #666666; }
+
+#editor {
+  margin-top: 0px;
+  margin-bottom: 0px;
+  height: 150px;
+  background-color: #52B3D9;
+  border-bottom: solid 1px #2C3E50; }
+
+#editor-content {
+  /* padding-top: 25px; */
+  /* padding-bottom: 25px; */
+  text-align: center;
+  color: white;
+  font-size: 13px; }
+
+#preview {
+  margin-top: 0px;
+  margin-bottom: 0px;
+  /* background-color: #E4F1FE; */
+  border: solid 1 px #2C3E50;
+  -o-box-shadow: 0px 0px 10px 0px #ddd;
+  box-shadow: 0px 0px 10px 0px #ddd;
+  filter: progid:DXImageTransform.Microsoft.Shadow(color=#ddd, Direction=NaN, Strength=10); }
+
+#preview-content {
+  background-color: #FFF;
+  padding-bottom: 25px;
+  /*text-align: center;*/
+  color: black;
+  /*font-size: 13px;*/ }
+
+#commandPanel {
+  padding-top: 25px;
+  padding-bottom: 25px; }
+
+/*  #commandPanel.affix {
+    position: fixed;
+    top: 0;
+    width:25%;
+    margin-top: -45px;
+  } */
+#visualPanel {
+  padding-top: 25px;
+  padding-bottom: 25px; }
+
+.customPagerButton {
+  width: 100px; }
+
+.numberOfColumnsLabel {
+  font-size: 32px;
+  text-align: center;
+  padding-top: 25%;
+  padding-bottom: 25%;
+  font-weight: bold;
+  text-align: center;
+  color: #666666; }
+
+.btnMinusColumns {
+  margin-top: 10px; }
+
+.btnAddColumns {
+  margin-top: 10px; }
+
+.numberOfcolumsText {
+  color: #666666; }
+
+.greyText {
+  color: #666666; }
+
+.blackText {
+  color: #000; }
+
+/*=========================================================
+  ANIMATE NG-SWITCH
+=========================================================*/
+.animate-switch-container {
+  position: relative;
+  background: white;
+  border-top: solid 1px #ECECEC;
+  border-bottom: solid 1px #ECECEC;
+  overflow: scroll; }
+  .animate-switch-container .well {
+    background-color: #89C4F4;
+    margin-bottom: 0px;
+    color: #ECECEC; }
+
+.linesList {
+  margin-top: 5px; }
+
+/*switch 1 : move top*/
+.animate-switch {
+  padding: 10px; }
+
+.animate-switch.ng-animate {
+  transition: all cubic-bezier(0.25, 0.46, 0.45, 0.94) 0.6s;
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0; }
+
+.animate-switch.ng-leave.ng-leave-active,
+.animate-switch.ng-enter {
+  left: 0px;
+  top: -500px;
+  opacity: 0; }
+
+.animate-switch.ng-leave,
+.animate-switch.ng-enter.ng-enter-active {
+  left: 0px;
+  top: 0px;
+  opacity: 0.8; }
+
+/*=========================================================
+  STEP INDICATOR
+=========================================================*/
+.stepwizardTopmargin {
+  margin-top: 25px; }
+
+.stepwizard-step p {
+  margin-top: 10px;
+  color: #666666; }
+
+.stepwizard-row {
+  display: table-row; }
+
+.stepwizard {
+  display: table;
+  width: 100%;
+  position: relative; }
+
+.stepwizard-step button[disabled] {
+  opacity: 1 !important;
+  filter: alpha(opacity=100) !important; }
+
+.stepwizard-row:before {
+  top: 14px;
+  bottom: 0;
+  position: absolute;
+  content: " ";
+  width: 100%;
+  height: 1px;
+  background-color: #ccc;
+  z-order: 0; }
+
+.stepwizard-step {
+  display: table-cell;
+  text-align: center;
+  position: relative; }
+
+.btn-circle {
+  width: 30px;
+  height: 30px;
+  text-align: center;
+  padding: 6px 0;
+  font-size: 12px;
+  line-height: 1.428571429;
+  border-radius: 15px; }
+
+.panelDebugScope {
+  color: #000; }
+
+/*=========================================================
+  Modal add control
+=========================================================*/
+.texteRouge {
+  color: #CF000F; }
+
+.editPropertiesLabel {
+  margin-top: 6px; }
+
+.textControlLabel {
+  color: #000; }
+
+.marginTopFivepixels {
+  margin-top: 5px; }
+
+.marginTopTenpixels {
+  margin-top: 5px; }
+
+.checkboxCssCorrection {
+  font-size: 4px; }
+
+.noGroupText {
+  margin-bottom: 0px; }
+
+.nya-bs-select {
+  margin-bottom: 16px; }
+
+.ta-scroll-window {
+  margin-bottom: 16px; }
+
+.formly-field-checkbox {
+  margin-top: 28px; }
+
+#inputAddNewRadioOption {
+  margin-bottom: 20px; }
+
+#inputAddNewBasicOption {
+  margin-bottom: 20px; }
+
+#inputAddNewGroupedOption {
+  margin-bottom: 20px; }
+
+#inputAddNewGroupGroupedOption {
+  margin-bottom: 20px; }
+
+.editGroupedSelectnyaSelect {
+  margin-bottom: 0px; }
+
+.heading-preview {
+  cursor: pointer; }
+
+/*=========================================================
+   specific drag and drop test (will change or be deleted)
+===========================================================*/
+/***************************** pageSlide directive css *****************************/
+/* Needed for hiding crollbars when pushing */
+html {
+  overflow-x: hidden; }
+
+.ng-pageslide {
+  background: #eee;
+  box-shadow: 5px 1px 12px 0px rgba(188, 183, 183, 0.7);
+  -moz-box-shadow: 5px 1px 12px 0px rgba(188, 183, 183, 0.7);
+  -webkit-box-shadow: 5px 1px 12px 0px rgba(188, 183, 183, 0.7); }
+
+#controlEditLeftPanel {
+  margin-top: 95px;
+  padding-top: 20px;
+  padding-bottom: 20px;
+  padding-right: 10px;
+  padding-left: 10px;
+  height: 85%;
+  overflow-y: scroll; }
+
+.separator10pixel {
+  margin-top: 5px;
+  margin-bottom: 5px;
+  height: 25px; }
+
+.panelControlWidth {
+  width: 45%; }
+
+/***************************** Required styles *****************************/
+/**
+ * For the correct positioning of the placeholder element, the dnd-list and
+ * it's children must have position: relative
+ */
+.advancedDemo ul[dnd-list],
+.advancedDemo ul[dnd-list] > li {
+  position: relative;
+  border: solid 1px #F1F1F1; }
+
+/***************************** Dropzone Styling *****************************/
+/**
+ * The dnd-list should always have a min-height,
+ * otherwise you can't drop to it once it's empty
+ */
+.advancedDemo .dropzone ul[dnd-list] {
+  min-height: 42px;
+  margin: 0px;
+  padding-left: 0px; }
+
+/**
+ * The dnd-lists's child elements currently MUST have
+ * position: relative. Otherwise we can not determine
+ * whether the mouse pointer is in the upper or lower
+ * half of the element we are dragging over. In other
+ * browsers we can use event.offsetY for this.
+ */
+.advancedDemo .dropzone li {
+  display: block; }
+
+/**
+ * Reduce opacity of elements during the drag operation. This allows the user
+ * to see where he is dropping his element, even if the element is huge. The
+ * .dndDragging class is automatically set during the drag operation.
+ */
+.advancedDemo .dropzone .dndDragging {
+  opacity: 0.7;
+  border: 2px dotted #000; }
+
+/**
+ * The dndDraggingSource class will be applied to the source element of a drag
+ * operation. It makes sense to hide it to give the user the feeling that he's
+ * actually moving it. Note that the source element has also .dndDragging class.
+ */
+.advancedDemo .dropzone .dndDraggingSource {
+  display: none; }
+
+/**
+ * An element with .dndPlaceholder class will be added as child of the dnd-list
+ * while the user is dragging over it.
+ */
+.advancedDemo .dropzone .dndPlaceholder {
+  background-color: #ddd !important;
+  min-height: 155px;
+  display: block;
+  position: relative;
+  -o-box-shadow: inset 0px 0px 5px 0px #343434;
+  box-shadow: inset 0px 0px 5px 0px #343434;
+  filter: progid:DXImageTransform.Microsoft.Shadow(color=#343434, Direction=NaN, Strength=5); }
+
+/***************************** Element type specific styles *****************************/
+.advancedDemo .dropzone .itemlist {
+  min-height: 115px !important; }
+
+ul.itemlist.ng-scope {
+  border: none; }
+
+.effect1ForDragDropItem, #itemContent {
+  box-shadow: 0 10px 6px -6px #777;
+  min-height: 115px; }
+
+.advancedDemo .dropzone .itemlist > li {
+  border: none;
+  min-width: 180px;
+  border-radius: .25em;
+  float: left;
+  font-weight: 700;
+  height: 135px; }
+
+#itemContent {
+  background-color: #fff;
+  border: 2px outset #0d87e9;
+  border-radius: .25em;
+  color: #fff;
+  float: left;
+  font-weight: 700;
+  height: 115px;
+  margin: 5px;
+  padding: 3px;
+  text-align: center;
+  width: 100%;
+  cursor: all-scroll; }
+
+.dragItemtextarea {
+  height: 60px; }
+
+textarea {
+  border: 1px dotted #CFCFCF !important;
+  height: 50px !important; }
+
+.advancedDemo .dropzone .container-element {
+  margin: 10px; }
+
+.isCollapsableZone {
+  cursor: pointer; }
+
+.buttonHeaderAddNewLine {
+  margin-top: 15px;
+  margin-bottom: 0px; }
+
+.buttonCloneLineHidden {
+  visibility: hidden; }
+
+.buttonCloseLine {
+  margin-top: -10px;
+  margin-right: -10px;
+  border-radius: 50%;
+  height: 45px; }
+
+.interligne {
+  padding-bottom: 10px; }
+
+.confirmLineDelete {
+  margin-top: 0;
+  margin-bottom: 0;
+  background-color: #F5F5F5;
+  opacity: 1.0;
+  animation: shake 1.3s infinite; }
+
+.demoddDatepicker {
+  padding-left: 0;
+  margin-left: 0; }
+
+.selectfordemo {
+  margin-top: 30px; }
+
+/*=========================================================
+   animation shake
+===========================================================*/
+
+@keyframes shake {
+  0%, 100% {
+    transform: translate3d(0, 0, 0); }
+  10%, 30%, 50%, 70%, 90% {
+    transform: translate3d(-10px, 0, 0); }
+  20%, 40%, 60%, 80% {
+    transform: translate3d(10px, 0, 0); } }
+
+.shake {
+  animation-name: shake; }
+
+.previewControlinItem {
+  margin-top: 2%;
+  background-color: #fff;
+  padding-top: 5px;
+  padding-bottom: 5px;
+  padding-left: 10px;
+  padding-right: 10px;
+  border-radius: 5px;
+  color: #F1F1F1;
+  font-size: 18px; }
+
+.vertical-line {
+  border-left: thick solid #000; }
+
+/*=========================================================
+   animation glyphicon rotate
+===========================================================*/
+.gly-spin {
+  animation: spin 2s infinite linear; }
+
+@keyframes spin {
+  0% {
+    transform: rotate(0deg); }
+  100% {
+    transform: rotate(359deg); } }
+
+.gly-rotate-90 {
+  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=1);
+  transform: rotate(90deg); }
+
+.gly-rotate-180 {
+  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=2);
+  transform: rotate(180deg); }
+
+.gly-rotate-270 {
+  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=3);
+  transform: rotate(270deg); }
+
+.gly-flip-horizontal {
+  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1);
+  transform: scale(-1, 1); }
+
+.gly-flip-vertical {
+  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1);
+  transform: scale(1, -1); }
+
+.rightClickCtrl {
+  opacity: 1.0;
+  transition: opacity .3s ease-in; }
+
+.rightClickCtrlSelected {
+  opacity: 0.5; }

static/js/eda.dragdropway.css.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"eda.dragdropway.css","sourceRoot":""}

static/js/eda.formviewer.css.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"eda.formviewer.css","sourceRoot":""}

static/js/eda.stepway.css.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"eda.stepway.css","sourceRoot":""}

static/js/formly.js

@@ -0,0 +1,2833 @@
+/*!
+* angular-formly JavaScript Library v0.0.0-semantically-released.0
+*
+* @license MIT (http://license.angular-formly.com)
+*
+* built with ♥ by Astrism <astrisms@gmail.com>, Kent C. Dodds <kent@doddsfamily.us>
+* (ó ì_í)=óò=(ì_í ò)
+*/
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("angular"), require("api-check"));
+	else if(typeof define === 'function' && define.amd)
+		define(["angular", "api-check"], factory);
+	else if(typeof exports === 'object')
+		exports["ngFormly"] = factory(require("angular"), require("api-check"));
+	else
+		root["ngFormly"] = factory(root["angular"], root["apiCheck"]);
+})(this, function(__WEBPACK_EXTERNAL_MODULE_3__, __WEBPACK_EXTERNAL_MODULE_5__) {
+return /******/ (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__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+	var _indexCommon = __webpack_require__(1);
+
+	var _indexCommon2 = _interopRequireDefault(_indexCommon);
+
+	exports['default'] = _indexCommon2['default'];
+	module.exports = exports['default'];
+
+/***/ },
+/* 1 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+	var _angularFix = __webpack_require__(2);
+
+	var _angularFix2 = _interopRequireDefault(_angularFix);
+
+	var _providersFormlyApiCheck = __webpack_require__(4);
+
+	var _providersFormlyApiCheck2 = _interopRequireDefault(_providersFormlyApiCheck);
+
+	var _otherDocsBaseUrl = __webpack_require__(6);
+
+	var _otherDocsBaseUrl2 = _interopRequireDefault(_otherDocsBaseUrl);
+
+	var _providersFormlyUsability = __webpack_require__(7);
+
+	var _providersFormlyUsability2 = _interopRequireDefault(_providersFormlyUsability);
+
+	var _providersFormlyConfig = __webpack_require__(8);
+
+	var _providersFormlyConfig2 = _interopRequireDefault(_providersFormlyConfig);
+
+	var _providersFormlyValidationMessages = __webpack_require__(10);
+
+	var _providersFormlyValidationMessages2 = _interopRequireDefault(_providersFormlyValidationMessages);
+
+	var _servicesFormlyUtil = __webpack_require__(11);
+
+	var _servicesFormlyUtil2 = _interopRequireDefault(_servicesFormlyUtil);
+
+	var _servicesFormlyWarn = __webpack_require__(12);
+
+	var _servicesFormlyWarn2 = _interopRequireDefault(_servicesFormlyWarn);
+
+	var _directivesFormlyCustomValidation = __webpack_require__(13);
+
+	var _directivesFormlyCustomValidation2 = _interopRequireDefault(_directivesFormlyCustomValidation);
+
+	var _directivesFormlyField = __webpack_require__(14);
+
+	var _directivesFormlyField2 = _interopRequireDefault(_directivesFormlyField);
+
+	var _directivesFormlyFocus = __webpack_require__(15);
+
+	var _directivesFormlyFocus2 = _interopRequireDefault(_directivesFormlyFocus);
+
+	var _directivesFormlyForm = __webpack_require__(16);
+
+	var _directivesFormlyForm2 = _interopRequireDefault(_directivesFormlyForm);
+
+	var _directivesFormlyFormController = __webpack_require__(17);
+
+	var _directivesFormlyFormController2 = _interopRequireDefault(_directivesFormlyFormController);
+
+	var _runFormlyNgModelAttrsManipulator = __webpack_require__(18);
+
+	var _runFormlyNgModelAttrsManipulator2 = _interopRequireDefault(_runFormlyNgModelAttrsManipulator);
+
+	var _runFormlyCustomTags = __webpack_require__(19);
+
+	var _runFormlyCustomTags2 = _interopRequireDefault(_runFormlyCustomTags);
+
+	var ngModuleName = 'formly';
+
+	exports['default'] = ngModuleName;
+
+	var ngModule = _angularFix2['default'].module(ngModuleName, []);
+
+	ngModule.constant('formlyApiCheck', _providersFormlyApiCheck2['default']);
+	ngModule.constant('formlyErrorAndWarningsUrlPrefix', _otherDocsBaseUrl2['default']);
+	ngModule.constant('formlyVersion', ("0.0.0-semantically-released.0")); // <-- webpack variable
+
+	ngModule.provider('formlyUsability', _providersFormlyUsability2['default']);
+	ngModule.provider('formlyConfig', _providersFormlyConfig2['default']);
+
+	ngModule.factory('formlyValidationMessages', _providersFormlyValidationMessages2['default']);
+	ngModule.factory('formlyUtil', _servicesFormlyUtil2['default']);
+	ngModule.factory('formlyWarn', _servicesFormlyWarn2['default']);
+
+	ngModule.directive('formlyCustomValidation', _directivesFormlyCustomValidation2['default']);
+	ngModule.directive('formlyField', _directivesFormlyField2['default']);
+	ngModule.directive('formlyFocus', _directivesFormlyFocus2['default']);
+	ngModule.directive('formlyForm', _directivesFormlyForm2['default']);
+	ngModule.controller('FormlyFormController', _directivesFormlyFormController2['default']);
+
+	ngModule.run(_runFormlyNgModelAttrsManipulator2['default']);
+	ngModule.run(_runFormlyCustomTags2['default']);
+	module.exports = exports['default'];
+
+/***/ },
+/* 2 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// some versions of angular don't export the angular module properly,
+	// so we get it from window in this case.
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+	var angular = __webpack_require__(3);
+
+	/* istanbul ignore next */
+	if (!angular.version) {
+	  angular = window.angular;
+	}
+	exports['default'] = angular;
+	module.exports = exports['default'];
+
+/***/ },
+/* 3 */
+/***/ function(module, exports) {
+
+	module.exports = __WEBPACK_EXTERNAL_MODULE_3__;
+
+/***/ },
+/* 4 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+	var _angularFix = __webpack_require__(2);
+
+	var _angularFix2 = _interopRequireDefault(_angularFix);
+
+	var _apiCheck = __webpack_require__(5);
+
+	var _apiCheck2 = _interopRequireDefault(_apiCheck);
+
+	var apiCheck = (0, _apiCheck2['default'])({
+	  output: {
+	    prefix: 'angular-formly:',
+	    docsBaseUrl: __webpack_require__(6)
+	  }
+	});
+
+	function shapeRequiredIfNot(otherProps, propChecker) {
+	  if (!_angularFix2['default'].isArray(otherProps)) {
+	    otherProps = [otherProps];
+	  }
+	  var type = 'specified if these are not specified: `' + otherProps.join(', ') + '` (otherwise it\'s optional)';
+
+	  function shapeRequiredIfNotDefinition(prop, propName, location, obj) {
+	    var propExists = obj && obj.hasOwnProperty(propName);
+	    var otherPropsExist = otherProps.some(function (otherProp) {
+	      return obj && obj.hasOwnProperty(otherProp);
+	    });
+	    if (!otherPropsExist && !propExists) {
+	      return apiCheck.utils.getError(propName, location, type);
+	    } else if (propExists) {
+	      return propChecker(prop, propName, location, obj);
+	    }
+	  }
+
+	  shapeRequiredIfNotDefinition.type = type;
+	  return apiCheck.utils.checkerHelpers.setupChecker(shapeRequiredIfNotDefinition);
+	}
+
+	var formlyExpression = apiCheck.oneOfType([apiCheck.string, apiCheck.func]);
+	var specifyWrapperType = apiCheck.typeOrArrayOf(apiCheck.string).nullable;
+
+	var apiCheckProperty = apiCheck.func;
+
+	var apiCheckInstanceProperty = apiCheck.shape.onlyIf('apiCheck', apiCheck.func.withProperties({
+	  warn: apiCheck.func,
+	  'throw': apiCheck.func,
+	  shape: apiCheck.func
+	}));
+
+	var apiCheckFunctionProperty = apiCheck.shape.onlyIf('apiCheck', apiCheck.oneOf(['throw', 'warn']));
+
+	var formlyWrapperType = apiCheck.shape({
+	  name: shapeRequiredIfNot('types', apiCheck.string).optional,
+	  template: apiCheck.shape.ifNot('templateUrl', apiCheck.string).optional,
+	  templateUrl: apiCheck.shape.ifNot('template', apiCheck.string).optional,
+	  types: apiCheck.typeOrArrayOf(apiCheck.string).optional,
+	  overwriteOk: apiCheck.bool.optional,
+	  apiCheck: apiCheckProperty.optional,
+	  apiCheckInstance: apiCheckInstanceProperty.optional,
+	  apiCheckFunction: apiCheckFunctionProperty.optional,
+	  apiCheckOptions: apiCheck.object.optional
+	}).strict;
+
+	var expressionProperties = apiCheck.objectOf(apiCheck.oneOfType([formlyExpression, apiCheck.shape({
+	  expression: formlyExpression,
+	  message: formlyExpression.optional
+	}).strict]));
+
+	var modelChecker = apiCheck.oneOfType([apiCheck.string, apiCheck.object]);
+
+	var templateManipulators = apiCheck.shape({
+	  preWrapper: apiCheck.arrayOf(apiCheck.func).nullable.optional,
+	  postWrapper: apiCheck.arrayOf(apiCheck.func).nullable.optional
+	}).strict.nullable;
+
+	var validatorChecker = apiCheck.objectOf(apiCheck.oneOfType([formlyExpression, apiCheck.shape({
+	  expression: formlyExpression,
+	  message: formlyExpression.optional
+	}).strict]));
+
+	var watcherChecker = apiCheck.typeOrArrayOf(apiCheck.shape({
+	  expression: formlyExpression.optional,
+	  listener: formlyExpression.optional,
+	  runFieldExpressions: apiCheck.bool.optional
+	}));
+
+	var fieldOptionsApiShape = {
+	  $$hashKey: apiCheck.any.optional,
+	  type: apiCheck.shape.ifNot(['template', 'templateUrl'], apiCheck.string).optional,
+	  template: apiCheck.shape.ifNot(['type', 'templateUrl'], apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,
+	  templateUrl: apiCheck.shape.ifNot(['type', 'template'], apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,
+	  key: apiCheck.oneOfType([apiCheck.string, apiCheck.number]).optional,
+	  model: modelChecker.optional,
+	  originalModel: modelChecker.optional,
+	  className: apiCheck.string.optional,
+	  id: apiCheck.string.optional,
+	  name: apiCheck.string.optional,
+	  expressionProperties: expressionProperties.optional,
+	  extras: apiCheck.shape({
+	    validateOnModelChange: apiCheck.bool.optional,
+	    skipNgModelAttrsManipulator: apiCheck.oneOfType([apiCheck.string, apiCheck.bool]).optional
+	  }).strict.optional,
+	  data: apiCheck.object.optional,
+	  templateOptions: apiCheck.object.optional,
+	  wrapper: specifyWrapperType.optional,
+	  modelOptions: apiCheck.shape({
+	    updateOn: apiCheck.string.optional,
+	    debounce: apiCheck.oneOfType([apiCheck.objectOf(apiCheck.number), apiCheck.number]).optional,
+	    allowInvalid: apiCheck.bool.optional,
+	    getterSetter: apiCheck.bool.optional,
+	    timezone: apiCheck.string.optional
+	  }).optional,
+	  watcher: watcherChecker.optional,
+	  validators: validatorChecker.optional,
+	  asyncValidators: validatorChecker.optional,
+	  parsers: apiCheck.arrayOf(formlyExpression).optional,
+	  formatters: apiCheck.arrayOf(formlyExpression).optional,
+	  noFormControl: apiCheck.bool.optional,
+	  hide: apiCheck.bool.optional,
+	  hideExpression: formlyExpression.optional,
+	  ngModelElAttrs: apiCheck.objectOf(apiCheck.string).optional,
+	  ngModelAttrs: apiCheck.objectOf(apiCheck.shape({
+	    statement: apiCheck.shape.ifNot(['value', 'attribute', 'bound', 'boolean'], apiCheck.any).optional,
+	    value: apiCheck.shape.ifNot('statement', apiCheck.any).optional,
+	    attribute: apiCheck.shape.ifNot('statement', apiCheck.any).optional,
+	    bound: apiCheck.shape.ifNot('statement', apiCheck.any).optional,
+	    boolean: apiCheck.shape.ifNot('statement', apiCheck.any).optional
+	  }).strict).optional,
+	  elementAttributes: apiCheck.objectOf(apiCheck.string).optional,
+	  optionsTypes: apiCheck.typeOrArrayOf(apiCheck.string).optional,
+	  link: apiCheck.func.optional,
+	  controller: apiCheck.oneOfType([apiCheck.string, apiCheck.func, apiCheck.array]).optional,
+	  validation: apiCheck.shape({
+	    show: apiCheck.bool.nullable.optional,
+	    messages: apiCheck.objectOf(formlyExpression).optional,
+	    errorExistsAndShouldBeVisible: apiCheck.bool.optional
+	  }).optional,
+	  formControl: apiCheck.typeOrArrayOf(apiCheck.object).optional,
+	  value: apiCheck.func.optional,
+	  runExpressions: apiCheck.func.optional,
+	  templateManipulators: templateManipulators.optional,
+	  resetModel: apiCheck.func.optional,
+	  updateInitialValue: apiCheck.func.optional,
+	  initialValue: apiCheck.any.optional,
+	  defaultValue: apiCheck.any.optional
+	};
+
+	var formlyFieldOptions = apiCheck.shape(fieldOptionsApiShape).strict;
+
+	var formOptionsApi = apiCheck.shape({
+	  formState: apiCheck.object.optional,
+	  resetModel: apiCheck.func.optional,
+	  updateInitialValue: apiCheck.func.optional,
+	  removeChromeAutoComplete: apiCheck.bool.optional,
+	  parseKeyArrays: apiCheck.bool.optional,
+	  templateManipulators: templateManipulators.optional,
+	  manualModelWatcher: apiCheck.oneOfType([apiCheck.bool, apiCheck.func]).optional,
+	  watchAllExpressions: apiCheck.bool.optional,
+	  wrapper: specifyWrapperType.optional,
+	  fieldTransform: apiCheck.oneOfType([apiCheck.func, apiCheck.array]).optional,
+	  data: apiCheck.object.optional
+	}).strict;
+
+	var fieldGroup = apiCheck.shape({
+	  $$hashKey: apiCheck.any.optional,
+	  key: apiCheck.oneOfType([apiCheck.string, apiCheck.number]).optional,
+	  // danger. Nested field groups wont get api-checked...
+	  fieldGroup: apiCheck.arrayOf(apiCheck.oneOfType([formlyFieldOptions, apiCheck.object])),
+	  className: apiCheck.string.optional,
+	  options: formOptionsApi.optional,
+	  templateOptions: apiCheck.object.optional,
+	  wrapper: specifyWrapperType.optional,
+	  watcher: watcherChecker.optional,
+	  hide: apiCheck.bool.optional,
+	  hideExpression: formlyExpression.optional,
+	  data: apiCheck.object.optional,
+	  model: modelChecker.optional,
+	  form: apiCheck.object.optional,
+	  elementAttributes: apiCheck.objectOf(apiCheck.string).optional
+	}).strict;
+
+	var typeOptionsDefaultOptions = _angularFix2['default'].copy(fieldOptionsApiShape);
+	typeOptionsDefaultOptions.key = apiCheck.string.optional;
+
+	var formlyTypeOptions = apiCheck.shape({
+	  name: apiCheck.string,
+	  template: apiCheck.shape.ifNot('templateUrl', apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,
+	  templateUrl: apiCheck.shape.ifNot('template', apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,
+	  controller: apiCheck.oneOfType([apiCheck.func, apiCheck.string, apiCheck.array]).optional,
+	  link: apiCheck.func.optional,
+	  defaultOptions: apiCheck.oneOfType([apiCheck.func, apiCheck.shape(typeOptionsDefaultOptions)]).optional,
+	  'extends': apiCheck.string.optional,
+	  wrapper: specifyWrapperType.optional,
+	  data: apiCheck.object.optional,
+	  apiCheck: apiCheckProperty.optional,
+	  apiCheckInstance: apiCheckInstanceProperty.optional,
+	  apiCheckFunction: apiCheckFunctionProperty.optional,
+	  apiCheckOptions: apiCheck.object.optional,
+	  overwriteOk: apiCheck.bool.optional
+	}).strict;
+
+	_angularFix2['default'].extend(apiCheck, {
+	  formlyTypeOptions: formlyTypeOptions, formlyFieldOptions: formlyFieldOptions, formlyExpression: formlyExpression, formlyWrapperType: formlyWrapperType, fieldGroup: fieldGroup, formOptionsApi: formOptionsApi
+	});
+
+	exports['default'] = apiCheck;
+	module.exports = exports['default'];
+
+/***/ },
+/* 5 */
+/***/ function(module, exports) {
+
+	module.exports = __WEBPACK_EXTERNAL_MODULE_5__;
+
+/***/ },
+/* 6 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports["default"] = "https://github.com/formly-js/angular-formly/blob/" + ("0.0.0-semantically-released.0") + "/other/ERRORS_AND_WARNINGS.md#";
+	module.exports = exports["default"];
+
+/***/ },
+/* 7 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	formlyUsability.$inject = ["formlyApiCheck", "formlyErrorAndWarningsUrlPrefix"];
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+	var _angularFix = __webpack_require__(2);
+
+	var _angularFix2 = _interopRequireDefault(_angularFix);
+
+	exports['default'] = formlyUsability;
+
+	// @ngInject
+	function formlyUsability(formlyApiCheck, formlyErrorAndWarningsUrlPrefix) {
+	  var _this = this;
+
+	  _angularFix2['default'].extend(this, {
+	    getFormlyError: getFormlyError,
+	    getFieldError: getFieldError,
+	    checkWrapper: checkWrapper,
+	    checkWrapperTemplate: checkWrapperTemplate,
+	    getErrorMessage: getErrorMessage,
+	    $get: function $get() {
+	      return _this;
+	    }
+	  });
+
+	  function getFieldError(errorInfoSlug, message, field) {
+	    if (arguments.length < 3) {
+	      field = message;
+	      message = errorInfoSlug;
+	      errorInfoSlug = null;
+	    }
+	    return new Error(getErrorMessage(errorInfoSlug, message) + (' Field definition: ' + _angularFix2['default'].toJson(field)));
+	  }
+
+	  function getFormlyError(errorInfoSlug, message) {
+	    if (!message) {
+	      message = errorInfoSlug;
+	      errorInfoSlug = null;
+	    }
+	    return new Error(getErrorMessage(errorInfoSlug, message));
+	  }
+
+	  function getErrorMessage(errorInfoSlug, message) {
+	    var url = '';
+	    if (errorInfoSlug !== null) {
+	      url = '' + formlyErrorAndWarningsUrlPrefix + errorInfoSlug;
+	    }
+	    return 'Formly Error: ' + message + '. ' + url;
+	  }
+
+	  function checkWrapper(wrapper) {
+	    formlyApiCheck['throw'](formlyApiCheck.formlyWrapperType, wrapper, {
+	      prefix: 'formlyConfig.setWrapper',
+	      urlSuffix: 'setwrapper-validation-failed'
+	    });
+	  }
+
+	  function checkWrapperTemplate(template, additionalInfo) {
+	    var formlyTransclude = '<formly-transclude></formly-transclude>';
+	    if (template.indexOf(formlyTransclude) === -1) {
+	      throw getFormlyError('Template wrapper templates must use "' + formlyTransclude + '" somewhere in them. ' + ('This one does not have "<formly-transclude></formly-transclude>" in it: ' + template) + '\n' + ('Additional information: ' + JSON.stringify(additionalInfo)));
+	    }
+	  }
+	}
+	module.exports = exports['default'];
+
+/***/ },
+/* 8 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	formlyConfig.$inject = ["formlyUsabilityProvider", "formlyErrorAndWarningsUrlPrefix", "formlyApiCheck"];
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+	function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }
+
+	var _angularFix = __webpack_require__(2);
+
+	var _angularFix2 = _interopRequireDefault(_angularFix);
+
+	var _otherUtils = __webpack_require__(9);
+
+	var _otherUtils2 = _interopRequireDefault(_otherUtils);
+
+	exports['default'] = formlyConfig;
+
+	// @ngInject
+	function formlyConfig(formlyUsabilityProvider, formlyErrorAndWarningsUrlPrefix, formlyApiCheck) {
+	  var _this2 = this;
+
+	  var typeMap = {};
+	  var templateWrappersMap = {};
+	  var defaultWrapperName = 'default';
+	  var _this = this;
+	  var getError = formlyUsabilityProvider.getFormlyError;
+
+	  _angularFix2['default'].extend(this, {
+	    setType: setType,
+	    getType: getType,
+	    getTypes: getTypes,
+	    getTypeHeritage: getTypeHeritage,
+	    setWrapper: setWrapper,
+	    getWrapper: getWrapper,
+	    getWrapperByType: getWrapperByType,
+	    removeWrapperByName: removeWrapperByName,
+	    removeWrappersForType: removeWrappersForType,
+	    disableWarnings: false,
+	    extras: {
+	      disableNgModelAttrsManipulator: false,
+	      fieldTransform: [],
+	      ngModelAttrsManipulatorPreferUnbound: false,
+	      removeChromeAutoComplete: false,
+	      parseKeyArrays: false,
+	      defaultHideDirective: 'ng-if',
+	      getFieldId: null
+	    },
+	    templateManipulators: {
+	      preWrapper: [],
+	      postWrapper: []
+	    },
+	    $get: function $get() {
+	      return _this2;
+	    }
+	  });
+
+	  function setType(options) {
+	    if (_angularFix2['default'].isArray(options)) {
+	      var _ret = (function () {
+	        var allTypes = [];
+	        _angularFix2['default'].forEach(options, function (item) {
+	          allTypes.push(setType(item));
+	        });
+	        return {
+	          v: allTypes
+	        };
+	      })();
+
+	      if (typeof _ret === 'object') return _ret.v;
+	    } else if (_angularFix2['default'].isObject(options)) {
+	      checkType(options);
+	      if (options['extends']) {
+	        extendTypeOptions(options);
+	      }
+	      typeMap[options.name] = options;
+	      return typeMap[options.name];
+	    } else {
+	      throw getError('You must provide an object or array for setType. You provided: ' + JSON.stringify(arguments));
+	    }
+	  }
+
+	  function checkType(options) {
+	    formlyApiCheck['throw'](formlyApiCheck.formlyTypeOptions, options, {
+	      prefix: 'formlyConfig.setType',
+	      url: 'settype-validation-failed'
+	    });
+	    if (!options.overwriteOk) {
+	      checkOverwrite(options.name, typeMap, options, 'types');
+	    } else {
+	      options.overwriteOk = undefined;
+	    }
+	  }
+
+	  function extendTypeOptions(options) {
+	    var extendsType = getType(options['extends'], true, options);
+	    extendTypeControllerFunction(options, extendsType);
+	    extendTypeLinkFunction(options, extendsType);
+	    extendTypeDefaultOptions(options, extendsType);
+	    _otherUtils2['default'].reverseDeepMerge(options, extendsType);
+	    extendTemplate(options, extendsType);
+	  }
+
+	  function extendTemplate(options, extendsType) {
+	    if (options.template && extendsType.templateUrl) {
+	      delete options.templateUrl;
+	    } else if (options.templateUrl && extendsType.template) {
+	      delete options.template;
+	    }
+	  }
+
+	  function extendTypeControllerFunction(options, extendsType) {
+	    var extendsCtrl = extendsType.controller;
+	    if (!_angularFix2['default'].isDefined(extendsCtrl)) {
+	      return;
+	    }
+	    var optionsCtrl = options.controller;
+	    if (_angularFix2['default'].isDefined(optionsCtrl)) {
+	      options.controller = function ($scope, $controller) {
+	        $controller(extendsCtrl, { $scope: $scope });
+	        $controller(optionsCtrl, { $scope: $scope });
+	      };
+	      options.controller.$inject = ['$scope', '$controller'];
+	    } else {
+	      options.controller = extendsCtrl;
+	    }
+	  }
+
+	  function extendTypeLinkFunction(options, extendsType) {
+	    var extendsFn = extendsType.link;
+	    if (!_angularFix2['default'].isDefined(extendsFn)) {
+	      return;
+	    }
+	    var optionsFn = options.link;
+	    if (_angularFix2['default'].isDefined(optionsFn)) {
+	      options.link = function () {
+	        extendsFn.apply(undefined, arguments);
+	        optionsFn.apply(undefined, arguments);
+	      };
+	    } else {
+	      options.link = extendsFn;
+	    }
+	  }
+
+	  function extendTypeDefaultOptions(options, extendsType) {
+	    var extendsDO = extendsType.defaultOptions;
+	    if (!_angularFix2['default'].isDefined(extendsDO)) {
+	      return;
+	    }
+	    var optionsDO = options.defaultOptions || {};
+	    var optionsDOIsFn = _angularFix2['default'].isFunction(optionsDO);
+	    var extendsDOIsFn = _angularFix2['default'].isFunction(extendsDO);
+	    if (extendsDOIsFn) {
+	      options.defaultOptions = function defaultOptions(opts, scope) {
+	        var extendsDefaultOptions = extendsDO(opts, scope);
+	        var mergedDefaultOptions = {};
+	        _otherUtils2['default'].reverseDeepMerge(mergedDefaultOptions, opts, extendsDefaultOptions);
+	        var extenderOptionsDefaultOptions = optionsDO;
+	        if (optionsDOIsFn) {
+	          extenderOptionsDefaultOptions = extenderOptionsDefaultOptions(mergedDefaultOptions, scope);
+	        }
+	        _otherUtils2['default'].reverseDeepMerge(extenderOptionsDefaultOptions, extendsDefaultOptions);
+	        return extenderOptionsDefaultOptions;
+	      };
+	    } else if (optionsDOIsFn) {
+	      options.defaultOptions = function defaultOptions(opts, scope) {
+	        var newDefaultOptions = {};
+	        _otherUtils2['default'].reverseDeepMerge(newDefaultOptions, opts, extendsDO);
+	        return optionsDO(newDefaultOptions, scope);
+	      };
+	    }
+	  }
+
+	  function getType(name, throwError, errorContext) {
+	    if (!name) {
+	      return undefined;
+	    }
+	    var type = typeMap[name];
+	    if (!type && throwError === true) {
+	      throw getError('There is no type by the name of "' + name + '": ' + JSON.stringify(errorContext));
+	    } else {
+	      return type;
+	    }
+	  }
+
+	  function getTypes() {
+	    return typeMap;
+	  }
+
+	  function getTypeHeritage(parent) {
+	    var heritage = [];
+	    var type = parent;
+	    if (_angularFix2['default'].isString(type)) {
+	      type = getType(parent);
+	    }
+	    parent = type['extends'];
+	    while (parent) {
+	      type = getType(parent);
+	      heritage.push(type);
+	      parent = type['extends'];
+	    }
+	    return heritage;
+	  }
+
+	  function setWrapper(_x, _x2) {
+	    var _again = true;
+
+	    _function: while (_again) {
+	      var options = _x,
+	          name = _x2;
+	      _again = false;
+
+	      if (_angularFix2['default'].isArray(options)) {
+	        return options.map(function (wrapperOptions) {
+	          return setWrapper(wrapperOptions);
+	        });
+	      } else if (_angularFix2['default'].isObject(options)) {
+	        options.types = getOptionsTypes(options);
+	        options.name = getOptionsName(options, name);
+	        checkWrapperAPI(options);
+	        templateWrappersMap[options.name] = options;
+	        return options;
+	      } else if (_angularFix2['default'].isString(options)) {
+	        _x = {
+	          template: options,
+	          name: name
+	        };
+	        _x2 = undefined;
+	        _again = true;
+	        continue _function;
+	      }
+	    }
+	  }
+
+	  function getOptionsTypes(options) {
+	    if (_angularFix2['default'].isString(options.types)) {
+	      return [options.types];
+	    }
+	    if (!_angularFix2['default'].isDefined(options.types)) {
+	      return [];
+	    } else {
+	      return options.types;
+	    }
+	  }
+
+	  function getOptionsName(options, name) {
+	    return options.name || name || options.types.join(' ') || defaultWrapperName;
+	  }
+
+	  function checkWrapperAPI(options) {
+	    formlyUsabilityProvider.checkWrapper(options);
+	    if (options.template) {
+	      formlyUsabilityProvider.checkWrapperTemplate(options.template, options);
+	    }
+	    if (!options.overwriteOk) {
+	      checkOverwrite(options.name, templateWrappersMap, options, 'templateWrappers');
+	    } else {
+	      delete options.overwriteOk;
+	    }
+	    checkWrapperTypes(options);
+	  }
+
+	  function checkWrapperTypes(options) {
+	    var shouldThrow = !_angularFix2['default'].isArray(options.types) || !options.types.every(_angularFix2['default'].isString);
+	    if (shouldThrow) {
+	      throw getError('Attempted to create a template wrapper with types that is not a string or an array of strings');
+	    }
+	  }
+
+	  function checkOverwrite(property, object, newValue, objectName) {
+	    if (object.hasOwnProperty(property)) {
+	      warn('overwriting-types-or-wrappers', ['Attempting to overwrite ' + property + ' on ' + objectName + ' which is currently', JSON.stringify(object[property]) + ' with ' + JSON.stringify(newValue), 'To supress this warning, specify the property "overwriteOk: true"'].join(' '));
+	    }
+	  }
+
+	  function getWrapper(name) {
+	    return templateWrappersMap[name || defaultWrapperName];
+	  }
+
+	  function getWrapperByType(type) {
+	    /* eslint prefer-const:0 */
+	    var wrappers = [];
+	    for (var _name in templateWrappersMap) {
+	      if (templateWrappersMap.hasOwnProperty(_name)) {
+	        if (templateWrappersMap[_name].types && templateWrappersMap[_name].types.indexOf(type) !== -1) {
+	          wrappers.push(templateWrappersMap[_name]);
+	        }
+	      }
+	    }
+	    return wrappers;
+	  }
+
+	  function removeWrapperByName(name) {
+	    var wrapper = templateWrappersMap[name];
+	    delete templateWrappersMap[name];
+	    return wrapper;
+	  }
+
+	  function removeWrappersForType(type) {
+	    var wrappers = getWrapperByType(type);
+	    if (!wrappers) {
+	      return undefined;
+	    }
+	    if (!_angularFix2['default'].isArray(wrappers)) {
+	      return removeWrapperByName(wrappers.name);
+	    } else {
+	      wrappers.forEach(function (wrapper) {
+	        return removeWrapperByName(wrapper.name);
+	      });
+	      return wrappers;
+	    }
+	  }
+
+	  function warn() {
+	    if (!_this.disableWarnings && console.warn) {
+	      /* eslint no-console:0 */
+	      var args = Array.prototype.slice.call(arguments);
+	      var warnInfoSlug = args.shift();
+	      args.unshift('Formly Warning:');
+	      args.push('' + formlyErrorAndWarningsUrlPrefix + warnInfoSlug);
+	      console.warn.apply(console, _toConsumableArray(args));
+	    }
+	  }
+	}
+	module.exports = exports['default'];
+
+/***/ },
+/* 9 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+	var _angularFix = __webpack_require__(2);
+
+	var _angularFix2 = _interopRequireDefault(_angularFix);
+
+	exports['default'] = {
+	  containsSelector: containsSelector, containsSpecialChar: containsSpecialChar, formlyEval: formlyEval, getFieldId: getFieldId, reverseDeepMerge: reverseDeepMerge, findByNodeName: findByNodeName,
+	  arrayify: arrayify, extendFunction: extendFunction, extendArray: extendArray, startsWith: startsWith, contains: contains
+	};
+
+	function containsSelector(string) {
+	  return containsSpecialChar(string, '.') || containsSpecialChar(string, '[') && containsSpecialChar(string, ']');
+	}
+
+	function containsSpecialChar(a, b) {
+	  if (!a || !a.indexOf) {
+	    return false;
+	  }
+	  return a.indexOf(b) !== -1;
+	}
+
+	function formlyEval(scope, expression, $modelValue, $viewValue, extraLocals) {
+	  if (_angularFix2['default'].isFunction(expression)) {
+	    return expression($viewValue, $modelValue, scope, extraLocals);
+	  } else {
+	    return scope.$eval(expression, _angularFix2['default'].extend({ $viewValue: $viewValue, $modelValue: $modelValue }, extraLocals));
+	  }
+	}
+
+	function getFieldId(formId, options, index) {
+	  if (options.id) {
+	    return options.id;
+	  }
+	  var type = options.type;
+	  if (!type && options.template) {
+	    type = 'template';
+	  } else if (!type && options.templateUrl) {
+	    type = 'templateUrl';
+	  }
+
+	  return [formId, type, options.key, index].join('_');
+	}
+
+	function reverseDeepMerge(dest) {
+	  _angularFix2['default'].forEach(arguments, function (src, index) {
+	    if (!index) {
+	      return;
+	    }
+	    _angularFix2['default'].forEach(src, function (val, prop) {
+	      if (!_angularFix2['default'].isDefined(dest[prop])) {
+	        dest[prop] = _angularFix2['default'].copy(val);
+	      } else if (objAndSameType(dest[prop], val)) {
+	        reverseDeepMerge(dest[prop], val);
+	      }
+	    });
+	  });
+	  return dest;
+	}
+
+	function objAndSameType(obj1, obj2) {
+	  return _angularFix2['default'].isObject(obj1) && _angularFix2['default'].isObject(obj2) && Object.getPrototypeOf(obj1) === Object.getPrototypeOf(obj2);
+	}
+
+	// recurse down a node tree to find a node with matching nodeName, for custom tags jQuery.find doesn't work in IE8
+	function findByNodeName(el, nodeName) {
+	  if (!el.prop) {
+	    // not a jQuery or jqLite object -> wrap it
+	    el = _angularFix2['default'].element(el);
+	  }
+
+	  if (el.prop('nodeName') === nodeName.toUpperCase()) {
+	    return el;
+	  }
+
+	  var c = el.children();
+	  for (var i = 0; c && i < c.length; i++) {
+	    var node = findByNodeName(c[i], nodeName);
+	    if (node) {
+	      return node;
+	    }
+	  }
+	}
+
+	function arrayify(obj) {
+	  if (obj && !_angularFix2['default'].isArray(obj)) {
+	    obj = [obj];
+	  } else if (!obj) {
+	    obj = [];
+	  }
+	  return obj;
+	}
+
+	function extendFunction() {
+	  for (var _len = arguments.length, fns = Array(_len), _key = 0; _key < _len; _key++) {
+	    fns[_key] = arguments[_key];
+	  }
+
+	  return function extendedFunction() {
+	    var args = arguments;
+	    fns.forEach(function (fn) {
+	      return fn.apply(null, args);
+	    });
+	  };
+	}
+
+	function extendArray(primary, secondary, property) {
+	  if (property) {
+	    primary = primary[property];
+	    secondary = secondary[property];
+	  }
+	  if (secondary && primary) {
+	    _angularFix2['default'].forEach(secondary, function (item) {
+	      if (primary.indexOf(item) === -1) {
+	        primary.push(item);
+	      }
+	    });
+	    return primary;
+	  } else if (secondary) {
+	    return secondary;
+	  } else {
+	    return primary;
+	  }
+	}
+
+	function startsWith(str, search) {
+	  if (_angularFix2['default'].isString(str) && _angularFix2['default'].isString(search)) {
+	    return str.length >= search.length && str.substring(0, search.length) === search;
+	  } else {
+	    return false;
+	  }
+	}
+
+	function contains(str, search) {
+	  if (_angularFix2['default'].isString(str) && _angularFix2['default'].isString(search)) {
+	    return str.length >= search.length && str.indexOf(search) !== -1;
+	  } else {
+	    return false;
+	  }
+	}
+	module.exports = exports['default'];
+
+/***/ },
+/* 10 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+	exports['default'] = formlyValidationMessages;
+
+	// @ngInject
+	function formlyValidationMessages() {
+
+	  var validationMessages = {
+	    addTemplateOptionValueMessage: addTemplateOptionValueMessage,
+	    addStringMessage: addStringMessage,
+	    messages: {}
+	  };
+
+	  return validationMessages;
+
+	  function addTemplateOptionValueMessage(name, prop, prefix, suffix, alternate) {
+	    validationMessages.messages[name] = templateOptionValue(prop, prefix, suffix, alternate);
+	  }
+
+	  function addStringMessage(name, string) {
+	    validationMessages.messages[name] = function () {
+	      return string;
+	    };
+	  }
+
+	  function templateOptionValue(prop, prefix, suffix, alternate) {
+	    return function getValidationMessage(viewValue, modelValue, scope) {
+	      if (typeof scope.options.templateOptions[prop] !== 'undefined') {
+	        return prefix + ' ' + scope.options.templateOptions[prop] + ' ' + suffix;
+	      } else {
+	        return alternate;
+	      }
+	    };
+	  }
+	}
+	module.exports = exports['default'];
+
+/***/ },
+/* 11 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+	var _otherUtils = __webpack_require__(9);
+
+	var _otherUtils2 = _interopRequireDefault(_otherUtils);
+
+	exports['default'] = formlyUtil;
+
+	// @ngInject
+	function formlyUtil() {
+	  return _otherUtils2['default'];
+	}
+	module.exports = exports['default'];
+
+/***/ },
+/* 12 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	formlyWarn.$inject = ["formlyConfig", "formlyErrorAndWarningsUrlPrefix", "$log"];
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }
+
+	exports['default'] = formlyWarn;
+
+	// @ngInject
+	function formlyWarn(formlyConfig, formlyErrorAndWarningsUrlPrefix, $log) {
+	  return function warn() {
+	    if (!formlyConfig.disableWarnings) {
+	      var args = Array.prototype.slice.call(arguments);
+	      var warnInfoSlug = args.shift();
+	      args.unshift('Formly Warning:');
+	      args.push('' + formlyErrorAndWarningsUrlPrefix + warnInfoSlug);
+	      $log.warn.apply($log, _toConsumableArray(args));
+	    }
+	  };
+	}
+	module.exports = exports['default'];
+
+/***/ },
+/* 13 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	formlyCustomValidation.$inject = ["formlyUtil"];
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+	var _angularFix = __webpack_require__(2);
+
+	var _angularFix2 = _interopRequireDefault(_angularFix);
+
+	exports['default'] = formlyCustomValidation;
+
+	// @ngInject
+	function formlyCustomValidation(formlyUtil) {
+	  return {
+	    restrict: 'A',
+	    require: 'ngModel',
+	    link: function formlyCustomValidationLink(scope, el, attrs, ctrl) {
+	      var opts = scope.options;
+	      opts.validation.messages = opts.validation.messages || {};
+	      _angularFix2['default'].forEach(opts.validation.messages, function (message, key) {
+	        opts.validation.messages[key] = function () {
+	          return formlyUtil.formlyEval(scope, message, ctrl.$modelValue, ctrl.$viewValue);
+	        };
+	      });
+
+	      var useNewValidatorsApi = ctrl.hasOwnProperty('$validators') && !attrs.hasOwnProperty('useParsers');
+	      _angularFix2['default'].forEach(opts.validators, _angularFix2['default'].bind(null, addValidatorToPipeline, false));
+	      _angularFix2['default'].forEach(opts.asyncValidators, _angularFix2['default'].bind(null, addValidatorToPipeline, true));
+
+	      function addValidatorToPipeline(isAsync, validator, name) {
+	        setupMessage(validator, name);
+	        validator = _angularFix2['default'].isObject(validator) ? validator.expression : validator;
+	        if (useNewValidatorsApi) {
+	          setupWithValidators(validator, name, isAsync);
+	        } else {
+	          setupWithParsers(validator, name, isAsync);
+	        }
+	      }
+
+	      function setupMessage(validator, name) {
+	        var message = validator.message;
+	        if (message) {
+	          opts.validation.messages[name] = function () {
+	            return formlyUtil.formlyEval(scope, message, ctrl.$modelValue, ctrl.$viewValue);
+	          };
+	        }
+	      }
+
+	      function setupWithValidators(validator, name, isAsync) {
+	        var validatorCollection = isAsync ? '$asyncValidators' : '$validators';
+
+	        ctrl[validatorCollection][name] = function evalValidity(modelValue, viewValue) {
+	          return formlyUtil.formlyEval(scope, validator, modelValue, viewValue);
+	        };
+	      }
+
+	      function setupWithParsers(validator, name, isAsync) {
+	        var inFlightValidator = undefined;
+	        ctrl.$parsers.unshift(function evalValidityOfParser(viewValue) {
+	          var isValid = formlyUtil.formlyEval(scope, validator, ctrl.$modelValue, viewValue);
+	          if (isAsync) {
+	            ctrl.$pending = ctrl.$pending || {};
+	            ctrl.$pending[name] = true;
+	            inFlightValidator = isValid;
+	            isValid.then(function () {
+	              if (inFlightValidator === isValid) {
+	                ctrl.$setValidity(name, true);
+	              }
+	            })['catch'](function () {
+	              if (inFlightValidator === isValid) {
+	                ctrl.$setValidity(name, false);
+	              }
+	            })['finally'](function () {
+	              var $pending = ctrl.$pending || {};
+	              if (Object.keys($pending).length === 1) {
+	                delete ctrl.$pending;
+	              } else {
+	                delete ctrl.$pending[name];
+	              }
+	            });
+	          } else {
+	            ctrl.$setValidity(name, isValid);
+	          }
+	          return viewValue;
+	        });
+	      }
+	    }
+	  };
+	}
+	module.exports = exports['default'];
+
+/***/ },
+/* 14 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	formlyField.$inject = ["$http", "$q", "$compile", "$templateCache", "$interpolate", "formlyConfig", "formlyApiCheck", "formlyUtil", "formlyUsability", "formlyWarn"];
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+	function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }
+
+	var _angularFix = __webpack_require__(2);
+
+	var _angularFix2 = _interopRequireDefault(_angularFix);
+
+	var _apiCheck = __webpack_require__(5);
+
+	var _apiCheck2 = _interopRequireDefault(_apiCheck);
+
+	exports['default'] = formlyField;
+
+	/**
+	 * @ngdoc directive
+	 * @name formlyField
+	 * @restrict AE
+	 */
+	// @ngInject
+	function formlyField($http, $q, $compile, $templateCache, $interpolate, formlyConfig, formlyApiCheck, formlyUtil, formlyUsability, formlyWarn) {
+	  FormlyFieldController.$inject = ["$scope", "$timeout", "$parse", "$controller", "formlyValidationMessages"];
+	  var arrayify = formlyUtil.arrayify;
+
+	  return {
+	    restrict: 'AE',
+	    transclude: true,
+	    require: '?^formlyForm',
+	    scope: {
+	      options: '=',
+	      model: '=',
+	      originalModel: '=?',
+	      formId: '@', // TODO remove formId in a breaking release
+	      index: '=?',
+	      fields: '=?',
+	      formState: '=?',
+	      formOptions: '=?',
+	      form: '=?' },
+	    // TODO require form in a breaking release
+	    controller: FormlyFieldController,
+	    link: fieldLink
+	  };
+
+	  // @ngInject
+	  function FormlyFieldController($scope, $timeout, $parse, $controller, formlyValidationMessages) {
+	    /* eslint max-statements:[2, 37] */
+	    if ($scope.options.fieldGroup) {
+	      setupFieldGroup();
+	      return;
+	    }
+
+	    var fieldType = getFieldType($scope.options);
+	    simplifyLife($scope.options);
+	    mergeFieldOptionsWithTypeDefaults($scope.options, fieldType);
+	    extendOptionsWithDefaults($scope.options, $scope.index);
+	    checkApi($scope.options);
+	    // set field id to link labels and fields
+
+	    // initalization
+	    setFieldIdAndName();
+	    setDefaultValue();
+	    setInitialValue();
+	    runExpressions();
+	    watchExpressions();
+	    addValidationMessages($scope.options);
+	    invokeControllers($scope, $scope.options, fieldType);
+
+	    // function definitions
+	    function runExpressions() {
+	      var deferred = $q.defer();
+	      // must run on next tick to make sure that the current value is correct.
+	      $timeout(function runExpressionsOnNextTick() {
+	        var promises = [];
+	        var field = $scope.options;
+	        var currentValue = valueGetterSetter();
+	        _angularFix2['default'].forEach(field.expressionProperties, function runExpression(expression, prop) {
+	          var setter = $parse(prop).assign;
+	          var promise = $q.when(formlyUtil.formlyEval($scope, expression, currentValue, currentValue)).then(function setFieldValue(value) {
+	            setter(field, value);
+	          });
+	          promises.push(promise);
+	        });
+	        $q.all(promises).then(function () {
+	          deferred.resolve();
+	        });
+	      }, 0, false);
+	      return deferred.promise;
+	    }
+
+	    function watchExpressions() {
+	      if ($scope.formOptions.watchAllExpressions) {
+	        (function () {
+	          var field = $scope.options;
+	          var currentValue = valueGetterSetter();
+	          _angularFix2['default'].forEach(field.expressionProperties, function watchExpression(expression, prop) {
+	            var setter = $parse(prop).assign;
+	            $scope.$watch(function expressionPropertyWatcher() {
+	              return formlyUtil.formlyEval($scope, expression, currentValue, currentValue);
+	            }, function expressionPropertyListener(value) {
+	              setter(field, value);
+	            }, true);
+	          });
+	        })();
+	      }
+	    }
+
+	    function valueGetterSetter(newVal) {
+	      if (!$scope.model || !$scope.options.key) {
+	        return undefined;
+	      }
+	      if (_angularFix2['default'].isDefined(newVal)) {
+	        parseSet($scope.options.key, $scope.model, newVal);
+	      }
+	      return parseGet($scope.options.key, $scope.model);
+	    }
+
+	    function shouldNotUseParseKey(key) {
+	      return _angularFix2['default'].isNumber(key) || !formlyUtil.containsSelector(key);
+	    }
+
+	    function keyContainsArrays(key) {
+	      return (/\[\d{1,}\]/.test(key)
+	      );
+	    }
+
+	    function deepAssign(obj, prop, value) {
+	      if (_angularFix2['default'].isString(prop)) {
+	        prop = prop.replace(/\[(\w+)\]/g, '.$1').split('.');
+	      }
+
+	      if (prop.length > 1) {
+	        var e = prop.shift();
+	        obj[e] = obj[e] || isNaN(prop[0]) ? {} : [];
+	        deepAssign(obj[e], prop, value);
+	      } else {
+	        obj[prop[0]] = value;
+	      }
+	    }
+
+	    function parseSet(key, model, newVal) {
+	      // If either of these are null/undefined then just return undefined
+	      if (!key && key !== 0 || !model) {
+	        return;
+	      }
+	      // If we are working with a number then $parse wont work, default back to the old way for now
+	      if (shouldNotUseParseKey(key)) {
+	        // TODO: Fix this so we can get several levels instead of just one with properties that are numeric
+	        model[key] = newVal;
+	      } else if (formlyConfig.extras.parseKeyArrays && keyContainsArrays(key)) {
+	        deepAssign($scope.model, key, newVal);
+	      } else {
+	        var setter = $parse($scope.options.key).assign;
+	        if (setter) {
+	          setter($scope.model, newVal);
+	        }
+	      }
+	    }
+
+	    function parseGet(key, model) {
+	      // If either of these are null/undefined then just return undefined
+	      if (!key && key !== 0 || !model) {
+	        return undefined;
+	      }
+
+	      // If we are working with a number then $parse wont work, default back to the old way for now
+	      if (shouldNotUseParseKey(key)) {
+	        // TODO: Fix this so we can get several levels instead of just one with properties that are numeric
+	        return model[key];
+	      } else {
+	        return $parse(key)(model);
+	      }
+	    }
+
+	    function simplifyLife(options) {
+	      // add a few empty objects (if they don't already exist) so you don't have to undefined check everywhere
+	      formlyUtil.reverseDeepMerge(options, {
+	        originalModel: options.model,
+	        extras: {},
+	        data: {},
+	        templateOptions: {},
+	        validation: {}
+	      });
+	      // create $scope.to so template authors can reference to instead of $scope.options.templateOptions
+	      $scope.to = $scope.options.templateOptions;
+	      $scope.formOptions = $scope.formOptions || {};
+	    }
+
+	    function setFieldIdAndName() {
+	      if (_angularFix2['default'].isFunction(formlyConfig.extras.getFieldId)) {
+	        $scope.id = formlyConfig.extras.getFieldId($scope.options, $scope.model, $scope);
+	      } else {
+	        var formName = $scope.form && $scope.form.$name || $scope.formId;
+	        $scope.id = formlyUtil.getFieldId(formName, $scope.options, $scope.index);
+	      }
+	      $scope.options.id = $scope.id;
+	      $scope.name = $scope.options.name || $scope.options.id;
+	      $scope.options.name = $scope.name;
+	    }
+
+	    function setDefaultValue() {
+	      if (_angularFix2['default'].isDefined($scope.options.defaultValue) && !_angularFix2['default'].isDefined(parseGet($scope.options.key, $scope.model))) {
+	        parseSet($scope.options.key, $scope.model, $scope.options.defaultValue);
+	      }
+	    }
+
+	    function setInitialValue() {
+	      $scope.options.initialValue = $scope.model && parseGet($scope.options.key, $scope.model);
+	    }
+
+	    function mergeFieldOptionsWithTypeDefaults(options, type) {
+	      if (type) {
+	        mergeOptions(options, type.defaultOptions);
+	      }
+	      var properOrder = arrayify(options.optionsTypes).reverse(); // so the right things are overridden
+	      _angularFix2['default'].forEach(properOrder, function (typeName) {
+	        mergeOptions(options, formlyConfig.getType(typeName, true, options).defaultOptions);
+	      });
+	    }
+
+	    function mergeOptions(options, extraOptions) {
+	      if (extraOptions) {
+	        if (_angularFix2['default'].isFunction(extraOptions)) {
+	          extraOptions = extraOptions(options, $scope);
+	        }
+	        formlyUtil.reverseDeepMerge(options, extraOptions);
+	      }
+	    }
+
+	    function extendOptionsWithDefaults(options, index) {
+	      var key = options.key || index || 0;
+	      _angularFix2['default'].extend(options, {
+	        // attach the key in case the formly-field directive is used directly
+	        key: key,
+	        value: options.value || valueGetterSetter,
+	        runExpressions: runExpressions,
+	        resetModel: resetModel,
+	        updateInitialValue: updateInitialValue
+	      });
+	    }
+
+	    function resetModel() {
+	      parseSet($scope.options.key, $scope.model, $scope.options.initialValue);
+	      if ($scope.options.formControl) {
+	        if (_angularFix2['default'].isArray($scope.options.formControl)) {
+	          _angularFix2['default'].forEach($scope.options.formControl, function (formControl) {
+	            resetFormControl(formControl, true);
+	          });
+	        } else {
+	          resetFormControl($scope.options.formControl);
+	        }
+	      }
+	      if ($scope.form) {
+	        $scope.form.$setUntouched && $scope.form.$setUntouched();
+	        $scope.form.$setPristine();
+	      }
+	    }
+
+	    function resetFormControl(formControl, isMultiNgModel) {
+	      if (!isMultiNgModel) {
+	        formControl.$setViewValue(parseGet($scope.options.key, $scope.model));
+	      }
+
+	      formControl.$render();
+	      formControl.$setUntouched && formControl.$setUntouched();
+	      formControl.$setPristine();
+
+	      // To prevent breaking change requiring a digest to reset $viewModel
+	      if (!$scope.$root.$$phase) {
+	        $scope.$digest();
+	      }
+	    }
+
+	    function updateInitialValue() {
+	      $scope.options.initialValue = parseGet($scope.options.key, $scope.model);
+	    }
+
+	    function addValidationMessages(options) {
+	      options.validation.messages = options.validation.messages || {};
+	      _angularFix2['default'].forEach(formlyValidationMessages.messages, function createFunctionForMessage(expression, name) {
+	        if (!options.validation.messages[name]) {
+	          options.validation.messages[name] = function evaluateMessage(viewValue, modelValue, scope) {
+	            return formlyUtil.formlyEval(scope, expression, modelValue, viewValue);
+	          };
+	        }
+	      });
+	    }
+
+	    function invokeControllers(scope) {
+	      var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+	      var type = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+
+	      _angularFix2['default'].forEach([type.controller, options.controller], function (controller) {
+	        if (controller) {
+	          $controller(controller, { $scope: scope });
+	        }
+	      });
+	    }
+
+	    function setupFieldGroup() {
+	      $scope.options.options = $scope.options.options || {};
+	      $scope.options.options.formState = $scope.formState;
+	      $scope.to = $scope.options.templateOptions;
+	    }
+	  }
+
+	  // link function
+	  function fieldLink(scope, el, attrs, formlyFormCtrl) {
+	    if (scope.options.fieldGroup) {
+	      setFieldGroupTemplate();
+	      return;
+	    }
+
+	    // watch the field model (if exists) if there is no parent formly-form directive (that would watch it instead)
+	    if (!formlyFormCtrl && scope.options.model) {
+	      scope.$watch('options.model', function () {
+	        return scope.options.runExpressions();
+	      }, true);
+	    }
+
+	    addAttributes();
+	    addClasses();
+
+	    var type = getFieldType(scope.options);
+	    var args = arguments;
+	    var thusly = this;
+	    var fieldCount = 0;
+	    var fieldManipulators = getManipulators(scope.options, scope.formOptions);
+	    getFieldTemplate(scope.options).then(runManipulators(fieldManipulators.preWrapper)).then(transcludeInWrappers(scope.options, scope.formOptions)).then(runManipulators(fieldManipulators.postWrapper)).then(setElementTemplate).then(watchFormControl).then(callLinkFunctions)['catch'](function (error) {
+	      formlyWarn('there-was-a-problem-setting-the-template-for-this-field', 'There was a problem setting the template for this field ', scope.options, error);
+	    });
+
+	    function setFieldGroupTemplate() {
+	      checkFieldGroupApi(scope.options);
+	      el.addClass('formly-field-group');
+	      var extraAttributes = '';
+	      if (scope.options.elementAttributes) {
+	        extraAttributes = Object.keys(scope.options.elementAttributes).map(function (key) {
+	          return key + '="' + scope.options.elementAttributes[key] + '"';
+	        }).join(' ');
+	      }
+	      var modelValue = 'model';
+	      scope.options.form = scope.form;
+	      if (scope.options.key) {
+	        modelValue = 'model[\'' + scope.options.key + '\']';
+	      }
+	      getTemplate('\n          <formly-form model="' + modelValue + '"\n                       fields="options.fieldGroup"\n                       options="options.options"\n                       form="options.form"\n                       class="' + scope.options.className + '"\n                       ' + extraAttributes + '\n                       is-field-group>\n          </formly-form>\n        ').then(transcludeInWrappers(scope.options, scope.formOptions)).then(setElementTemplate);
+	    }
+
+	    function addAttributes() {
+	      if (scope.options.elementAttributes) {
+	        el.attr(scope.options.elementAttributes);
+	      }
+	    }
+
+	    function addClasses() {
+	      if (scope.options.className) {
+	        el.addClass(scope.options.className);
+	      }
+	      if (scope.options.type) {
+	        el.addClass('formly-field-' + scope.options.type);
+	      }
+	    }
+
+	    function setElementTemplate(templateString) {
+	      el.html(asHtml(templateString));
+	      $compile(el.contents())(scope);
+	      return templateString;
+	    }
+
+	    function watchFormControl(templateString) {
+	      var stopWatchingShowError = _angularFix2['default'].noop;
+	      if (scope.options.noFormControl) {
+	        return;
+	      }
+	      var templateEl = _angularFix2['default'].element('<div>' + templateString + '</div>');
+	      var ngModelNodes = templateEl[0].querySelectorAll('[ng-model],[data-ng-model]');
+
+	      if (ngModelNodes.length) {
+	        _angularFix2['default'].forEach(ngModelNodes, function (ngModelNode) {
+	          fieldCount++;
+	          watchFieldNameOrExistence(ngModelNode.getAttribute('name'));
+	        });
+	      }
+
+	      function watchFieldNameOrExistence(name) {
+	        var nameExpressionRegex = /\{\{(.*?)}}/;
+	        var nameExpression = nameExpressionRegex.exec(name);
+	        if (nameExpression) {
+	          name = $interpolate(name)(scope);
+	        }
+	        watchFieldExistence(name);
+	      }
+
+	      function watchFieldExistence(name) {
+	        scope.$watch('form["' + name + '"]', function formControlChange(formControl) {
+	          if (formControl) {
+	            if (fieldCount > 1) {
+	              if (!scope.options.formControl) {
+	                scope.options.formControl = [];
+	              }
+	              scope.options.formControl.push(formControl);
+	            } else {
+	              scope.options.formControl = formControl;
+	            }
+	            scope.fc = scope.options.formControl; // shortcut for template authors
+	            stopWatchingShowError();
+	            addShowMessagesWatcher();
+	            addParsers();
+	            addFormatters();
+	          }
+	        });
+	      }
+
+	      function addShowMessagesWatcher() {
+	        stopWatchingShowError = scope.$watch(function watchShowValidationChange() {
+	          var customExpression = formlyConfig.extras.errorExistsAndShouldBeVisibleExpression;
+	          var options = scope.options;
+	          var formControls = arrayify(scope.fc);
+	          if (!formControls.some(function (fc) {
+	            return fc.$invalid;
+	          })) {
+	            return false;
+	          } else if (typeof options.validation.show === 'boolean') {
+	            return options.validation.show;
+	          } else if (customExpression) {
+	            return formControls.some(function (fc) {
+	              return formlyUtil.formlyEval(scope, customExpression, fc.$modelValue, fc.$viewValue);
+	            });
+	          } else {
+	            return formControls.some(function (fc) {
+	              var noTouchedButDirty = _angularFix2['default'].isUndefined(fc.$touched) && fc.$dirty;
+	              return fc.$touched || noTouchedButDirty;
+	            });
+	          }
+	        }, function onShowValidationChange(show) {
+	          scope.options.validation.errorExistsAndShouldBeVisible = show;
+	          scope.showError = show; // shortcut for template authors
+	        });
+	      }
+
+	      function addParsers() {
+	        setParsersOrFormatters('parsers');
+	      }
+
+	      function addFormatters() {
+	        setParsersOrFormatters('formatters');
+	        var ctrl = scope.fc;
+	        var formWasPristine = scope.form.$pristine;
+	        if (scope.options.formatters) {
+	          (function () {
+	            var value = ctrl.$modelValue;
+	            ctrl.$formatters.forEach(function (formatter) {
+	              value = formatter(value);
+	            });
+
+	            ctrl.$setViewValue(value);
+	            ctrl.$render();
+	            ctrl.$setPristine();
+	            if (formWasPristine) {
+	              scope.form.$setPristine();
+	            }
+	          })();
+	        }
+	      }
+
+	      function setParsersOrFormatters(which) {
+	        var originalThingProp = 'originalParser';
+	        if (which === 'formatters') {
+	          originalThingProp = 'originalFormatter';
+	        }
+
+	        // init with type's parsers
+	        var things = getThingsFromType(type);
+
+	        // get optionsTypes things
+	        things = formlyUtil.extendArray(things, getThingsFromOptionsTypes(scope.options.optionsTypes));
+
+	        // get field's things
+	        things = formlyUtil.extendArray(things, scope.options[which]);
+
+	        // convert things into formlyExpression things
+	        _angularFix2['default'].forEach(things, function (thing, index) {
+	          things[index] = getFormlyExpressionThing(thing);
+	        });
+
+	        var ngModelCtrls = scope.fc;
+	        if (!_angularFix2['default'].isArray(ngModelCtrls)) {
+	          ngModelCtrls = [ngModelCtrls];
+	        }
+
+	        _angularFix2['default'].forEach(ngModelCtrls, function (ngModelCtrl) {
+	          var _ngModelCtrl;
+
+	          ngModelCtrl['$' + which] = (_ngModelCtrl = ngModelCtrl['$' + which]).concat.apply(_ngModelCtrl, _toConsumableArray(things));
+	        });
+
+	        function getThingsFromType(theType) {
+	          if (!theType) {
+	            return [];
+	          }
+	          if (_angularFix2['default'].isString(theType)) {
+	            theType = formlyConfig.getType(theType, true, scope.options);
+	          }
+	          var typeThings = [];
+
+	          // get things from parent
+	          if (theType['extends']) {
+	            typeThings = formlyUtil.extendArray(typeThings, getThingsFromType(theType['extends']));
+	          }
+
+	          // get own type's things
+	          typeThings = formlyUtil.extendArray(typeThings, getDefaultOptionsProperty(theType, which, []));
+
+	          // get things from optionsTypes
+	          typeThings = formlyUtil.extendArray(typeThings, getThingsFromOptionsTypes(getDefaultOptionsOptionsTypes(theType)));
+
+	          return typeThings;
+	        }
+
+	        function getThingsFromOptionsTypes() {
+	          var optionsTypes = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];
+
+	          var optionsTypesThings = [];
+	          _angularFix2['default'].forEach(_angularFix2['default'].copy(arrayify(optionsTypes)).reverse(), function (optionsTypeName) {
+	            optionsTypesThings = formlyUtil.extendArray(optionsTypesThings, getThingsFromType(optionsTypeName));
+	          });
+	          return optionsTypesThings;
+	        }
+
+	        function getFormlyExpressionThing(thing) {
+	          formlyExpressionParserOrFormatterFunction[originalThingProp] = thing;
+	          return formlyExpressionParserOrFormatterFunction;
+
+	          function formlyExpressionParserOrFormatterFunction($viewValue) {
+	            var $modelValue = scope.options.value();
+	            return formlyUtil.formlyEval(scope, thing, $modelValue, $viewValue);
+	          }
+	        }
+	      }
+	    }
+
+	    function callLinkFunctions() {
+	      if (type && type.link) {
+	        type.link.apply(thusly, args);
+	      }
+	      if (scope.options.link) {
+	        scope.options.link.apply(thusly, args);
+	      }
+	    }
+
+	    function runManipulators(manipulators) {
+	      return function runManipulatorsOnTemplate(templateToManipulate) {
+	        var chain = $q.when(templateToManipulate);
+	        _angularFix2['default'].forEach(manipulators, function (manipulator) {
+	          chain = chain.then(function (template) {
+	            return $q.when(manipulator(template, scope.options, scope)).then(function (newTemplate) {
+	              return _angularFix2['default'].isString(newTemplate) ? newTemplate : asHtml(newTemplate);
+	            });
+	          });
+	        });
+	        return chain;
+	      };
+	    }
+	  }
+
+	  // sort-of stateless util functions
+	  function asHtml(el) {
+	    var wrapper = _angularFix2['default'].element('<a></a>');
+	    return wrapper.append(el).html();
+	  }
+
+	  function getFieldType(options) {
+	    return options.type && formlyConfig.getType(options.type);
+	  }
+
+	  function getManipulators(options, formOptions) {
+	    var preWrapper = [];
+	    var postWrapper = [];
+	    addManipulators(options.templateManipulators);
+	    addManipulators(formOptions.templateManipulators);
+	    addManipulators(formlyConfig.templateManipulators);
+	    return { preWrapper: preWrapper, postWrapper: postWrapper };
+
+	    function addManipulators(manipulators) {
+	      /* eslint-disable */ // it doesn't understand this :-(
+
+	      var _ref = manipulators || {};
+
+	      var _ref$preWrapper = _ref.preWrapper;
+	      var pre = _ref$preWrapper === undefined ? [] : _ref$preWrapper;
+	      var _ref$postWrapper = _ref.postWrapper;
+	      var post = _ref$postWrapper === undefined ? [] : _ref$postWrapper;
+
+	      preWrapper = preWrapper.concat(pre);
+	      postWrapper = postWrapper.concat(post);
+	      /* eslint-enable */
+	    }
+	  }
+
+	  function getFieldTemplate(options) {
+	    function fromOptionsOrType(key, fieldType) {
+	      if (_angularFix2['default'].isDefined(options[key])) {
+	        return options[key];
+	      } else if (fieldType && _angularFix2['default'].isDefined(fieldType[key])) {
+	        return fieldType[key];
+	      }
+	    }
+
+	    var type = formlyConfig.getType(options.type, true, options);
+	    var template = fromOptionsOrType('template', type);
+	    var templateUrl = fromOptionsOrType('templateUrl', type);
+	    if (_angularFix2['default'].isUndefined(template) && !templateUrl) {
+	      throw formlyUsability.getFieldError('type-type-has-no-template', 'Type \'' + options.type + '\' has no template. On element:', options);
+	    }
+
+	    return getTemplate(templateUrl || template, _angularFix2['default'].isUndefined(template), options);
+	  }
+
+	  function getTemplate(template, isUrl, options) {
+	    var templatePromise = undefined;
+	    if (_angularFix2['default'].isFunction(template)) {
+	      templatePromise = $q.when(template(options));
+	    } else {
+	      templatePromise = $q.when(template);
+	    }
+
+	    if (!isUrl) {
+	      return templatePromise;
+	    } else {
+	      var _ret3 = (function () {
+	        var httpOptions = { cache: $templateCache };
+	        return {
+	          v: templatePromise.then(function (url) {
+	            return $http.get(url, httpOptions);
+	          }).then(function (response) {
+	            return response.data;
+	          })['catch'](function handleErrorGettingATemplate(error) {
+	            formlyWarn('problem-loading-template-for-templateurl', 'Problem loading template for ' + template, error);
+	          })
+	        };
+	      })();
+
+	      if (typeof _ret3 === 'object') return _ret3.v;
+	    }
+	  }
+
+	  function transcludeInWrappers(options, formOptions) {
+	    var wrapper = getWrapperOption(options, formOptions);
+
+	    return function transcludeTemplate(template) {
+	      if (!wrapper.length) {
+	        return $q.when(template);
+	      }
+
+	      wrapper.forEach(function (aWrapper) {
+	        formlyUsability.checkWrapper(aWrapper, options);
+	        runApiCheck(aWrapper, options);
+	      });
+	      var promises = wrapper.map(function (w) {
+	        return getTemplate(w.template || w.templateUrl, !w.template);
+	      });
+	      return $q.all(promises).then(function (wrappersTemplates) {
+	        wrappersTemplates.forEach(function (wrapperTemplate, index) {
+	          formlyUsability.checkWrapperTemplate(wrapperTemplate, wrapper[index]);
+	        });
+	        wrappersTemplates.reverse(); // wrapper 0 is wrapped in wrapper 1 and so on...
+	        var totalWrapper = wrappersTemplates.shift();
+	        wrappersTemplates.forEach(function (wrapperTemplate) {
+	          totalWrapper = doTransclusion(totalWrapper, wrapperTemplate);
+	        });
+	        return doTransclusion(totalWrapper, template);
+	      });
+	    };
+	  }
+
+	  function doTransclusion(wrapper, template) {
+	    var superWrapper = _angularFix2['default'].element('<a></a>'); // this allows people not have to have a single root in wrappers
+	    superWrapper.append(wrapper);
+	    var transcludeEl = superWrapper.find('formly-transclude');
+	    if (!transcludeEl.length) {
+	      // try it using our custom find function
+	      transcludeEl = formlyUtil.findByNodeName(superWrapper, 'formly-transclude');
+	    }
+	    transcludeEl.replaceWith(template);
+	    return superWrapper.html();
+	  }
+
+	  function getWrapperOption(options, formOptions) {
+	    /* eslint complexity:[2, 6] */
+	    var wrapper = options.wrapper;
+	    // explicit null means no wrapper
+	    if (wrapper === null) {
+	      return [];
+	    }
+
+	    // nothing specified means use the default wrapper for the type
+	    if (!wrapper) {
+	      // get all wrappers that specify they apply to this type
+	      wrapper = arrayify(formlyConfig.getWrapperByType(options.type));
+	    } else {
+	      wrapper = arrayify(wrapper).map(formlyConfig.getWrapper);
+	    }
+
+	    // get all wrappers for that the type specified that it uses.
+	    var type = formlyConfig.getType(options.type, true, options);
+	    if (type && type.wrapper) {
+	      var typeWrappers = arrayify(type.wrapper).map(formlyConfig.getWrapper);
+	      wrapper = wrapper.concat(typeWrappers);
+	    }
+
+	    // add form wrappers
+	    if (formOptions.wrapper) {
+	      var formWrappers = arrayify(formOptions.wrapper).map(formlyConfig.getWrapper);
+	      wrapper = wrapper.concat(formWrappers);
+	    }
+
+	    // add the default wrapper last
+	    var defaultWrapper = formlyConfig.getWrapper();
+	    if (defaultWrapper) {
+	      wrapper.push(defaultWrapper);
+	    }
+	    return wrapper;
+	  }
+
+	  function checkApi(options) {
+	    formlyApiCheck['throw'](formlyApiCheck.formlyFieldOptions, options, {
+	      prefix: 'formly-field directive',
+	      url: 'formly-field-directive-validation-failed'
+	    });
+	    // validate with the type
+	    var type = options.type && formlyConfig.getType(options.type);
+	    if (type) {
+	      runApiCheck(type, options, true);
+	    }
+	    if (options.expressionProperties && options.expressionProperties.hide) {
+	      formlyWarn('dont-use-expressionproperties.hide-use-hideexpression-instead', 'You have specified `hide` in `expressionProperties`. Use `hideExpression` instead', options);
+	    }
+	  }
+
+	  function checkFieldGroupApi(options) {
+	    formlyApiCheck['throw'](formlyApiCheck.fieldGroup, options, {
+	      prefix: 'formly-field directive',
+	      url: 'formly-field-directive-validation-failed'
+	    });
+	  }
+
+	  function runApiCheck(_ref2, options, forType) {
+	    var apiCheck = _ref2.apiCheck;
+	    var apiCheckInstance = _ref2.apiCheckInstance;
+	    var apiCheckFunction = _ref2.apiCheckFunction;
+	    var apiCheckOptions = _ref2.apiCheckOptions;
+
+	    runApiCheckForType(apiCheck, apiCheckInstance, apiCheckFunction, apiCheckOptions, options);
+	    if (forType && options.type) {
+	      _angularFix2['default'].forEach(formlyConfig.getTypeHeritage(options.type), function (type) {
+	        runApiCheckForType(type.apiCheck, type.apiCheckInstance, type.apiCheckFunction, type.apiCheckOptions, options);
+	      });
+	    }
+	  }
+
+	  function runApiCheckForType(apiCheck, apiCheckInstance, apiCheckFunction, apiCheckOptions, options) {
+	    /* eslint complexity:[2, 9] */
+	    if (!apiCheck) {
+	      return;
+	    }
+	    var instance = apiCheckInstance || formlyConfig.extras.apiCheckInstance || formlyApiCheck;
+	    if (instance.config.disabled || _apiCheck2['default'].globalConfig.disabled) {
+	      return;
+	    }
+	    var fn = apiCheckFunction || 'warn';
+	    // this is the new API
+	    var checkerObjects = apiCheck(instance);
+	    _angularFix2['default'].forEach(checkerObjects, function (shape, name) {
+	      var checker = instance.shape(shape);
+	      var checkOptions = _angularFix2['default'].extend({
+	        prefix: 'formly-field type ' + options.type + ' for property ' + name,
+	        url: formlyApiCheck.config.output.docsBaseUrl + 'formly-field-type-apicheck-failed'
+	      }, apiCheckOptions);
+	      instance[fn](checker, options[name], checkOptions);
+	    });
+	  }
+	}
+
+	// Stateless util functions
+	function getDefaultOptionsOptionsTypes(type) {
+	  return getDefaultOptionsProperty(type, 'optionsTypes', []);
+	}
+
+	function getDefaultOptionsProperty(type, prop, defaultValue) {
+	  return type.defaultOptions && type.defaultOptions[prop] || defaultValue;
+	}
+	module.exports = exports['default'];
+
+/***/ },
+/* 15 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	formlyFocus.$inject = ["$timeout", "$document"];
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+	exports['default'] = formlyFocus;
+
+	// @ngInject
+	function formlyFocus($timeout, $document) {
+	  return {
+	    restrict: 'A',
+	    link: function formlyFocusLink(scope, element, attrs) {
+	      var previousEl = null;
+	      var el = element[0];
+	      var doc = $document[0];
+	      attrs.$observe('formlyFocus', function respondToFocusExpressionChange(value) {
+	        /* eslint no-bitwise:0 */ // I know what I'm doing. I promise...
+	        if (value === 'true') {
+	          $timeout(function setElementFocus() {
+	            previousEl = doc.activeElement;
+	            el.focus();
+	          }, ~ ~attrs.focusWait);
+	        } else if (value === 'false') {
+	          if (doc.activeElement === el) {
+	            el.blur();
+	            if (attrs.hasOwnProperty('refocus') && previousEl) {
+	              previousEl.focus();
+	            }
+	          }
+	        }
+	      });
+	    }
+	  };
+	}
+	module.exports = exports['default'];
+
+/***/ },
+/* 16 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	formlyForm.$inject = ["formlyUsability", "formlyWarn", "$parse", "formlyConfig", "$interpolate"];
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+	var _angularFix = __webpack_require__(2);
+
+	var _angularFix2 = _interopRequireDefault(_angularFix);
+
+	exports['default'] = formlyForm;
+
+	/**
+	 * @ngdoc directive
+	 * @name formlyForm
+	 * @restrict AE
+	 */
+	// @ngInject
+	function formlyForm(formlyUsability, formlyWarn, $parse, formlyConfig, $interpolate) {
+	  var currentFormId = 1;
+	  return {
+	    restrict: 'AE',
+	    template: formlyFormGetTemplate,
+	    replace: true,
+	    transclude: true,
+	    scope: {
+	      fields: '=',
+	      model: '=',
+	      form: '=?',
+	      options: '=?'
+	    },
+	    controller: 'FormlyFormController',
+	    link: formlyFormLink
+	  };
+
+	  function formlyFormGetTemplate(el, attrs) {
+	    var rootEl = getRootEl();
+	    var fieldRootEl = getFieldRootEl();
+	    var formId = 'formly_' + currentFormId++;
+	    var parentFormAttributes = '';
+	    if (attrs.hasOwnProperty('isFieldGroup') && el.parent().parent().hasClass('formly')) {
+	      parentFormAttributes = copyAttributes(el.parent().parent()[0].attributes);
+	    }
+	    return '\n        <' + rootEl + ' class="formly"\n                 name="' + getFormName() + '"\n                 role="form" ' + parentFormAttributes + '>\n          <' + fieldRootEl + ' formly-field\n               ng-repeat="field in fields ' + getTrackBy() + '"\n               ' + getHideDirective() + '="!field.hide"\n               class="formly-field"\n               options="field"\n               model="field.model || model"\n               original-model="model"\n               fields="fields"\n               form="theFormlyForm"\n               form-id="' + getFormName() + '"\n               form-state="options.formState"\n               form-options="options"\n               index="$index">\n          </' + fieldRootEl + '>\n          <div ng-transclude class="' + getTranscludeClass() + '"></div>\n        </' + rootEl + '>\n      ';
+
+	    function getRootEl() {
+	      return attrs.rootEl || 'ng-form';
+	    }
+
+	    function getFieldRootEl() {
+	      return attrs.fieldRootEl || 'div';
+	    }
+
+	    function getHideDirective() {
+	      return attrs.hideDirective || formlyConfig.extras.defaultHideDirective || 'ng-if';
+	    }
+
+	    function getTrackBy() {
+	      if (!attrs.trackBy) {
+	        return '';
+	      } else {
+	        return 'track by ' + attrs.trackBy;
+	      }
+	    }
+
+	    function getFormName() {
+	      var formName = formId;
+	      var bindName = attrs.bindName;
+	      if (bindName) {
+	        if (_angularFix2['default'].version.minor < 3) {
+	          throw formlyUsability.getFormlyError('bind-name attribute on formly-form not allowed in < angular 1.3');
+	        }
+	        // we can do a one-time binding here because we know we're in 1.3.x territory
+	        formName = $interpolate.startSymbol() + '::\'formly_\' + ' + bindName + $interpolate.endSymbol();
+	      }
+	      return formName;
+	    }
+
+	    function getTranscludeClass() {
+	      return attrs.transcludeClass || '';
+	    }
+
+	    function copyAttributes(attributes) {
+	      var excluded = ['model', 'form', 'fields', 'options', 'name', 'role', 'class', 'data-model', 'data-form', 'data-fields', 'data-options', 'data-name'];
+	      var arrayAttrs = [];
+	      _angularFix2['default'].forEach(attributes, function (_ref) {
+	        var nodeName = _ref.nodeName;
+	        var value = _ref.value;
+
+	        if (nodeName !== 'undefined' && excluded.indexOf(nodeName) === -1) {
+	          arrayAttrs.push(toKebabCase(nodeName) + '="' + value + '"');
+	        }
+	      });
+	      return arrayAttrs.join(' ');
+	    }
+	  }
+
+	  function formlyFormLink(scope, el, attrs) {
+	    setFormController();
+	    fixChromeAutocomplete();
+
+	    function setFormController() {
+	      var formId = attrs.name;
+	      scope.formId = formId;
+	      scope.theFormlyForm = scope[formId];
+	      if (attrs.form) {
+	        var getter = $parse(attrs.form);
+	        var setter = getter.assign;
+	        var parentForm = getter(scope.$parent);
+	        if (parentForm) {
+	          scope.theFormlyForm = parentForm;
+	          if (scope[formId]) {
+	            scope.theFormlyForm.$removeControl(scope[formId]);
+	          }
+
+	          // this next line is probably one of the more dangerous things that angular-formly does to improve the
+	          // API for angular-formly forms. It ensures that the NgModelControllers inside of formly-form will be
+	          // attached to the form that is passed to formly-form rather than the one that formly-form creates
+	          // this is necessary because it's confusing to have a step between the form you pass in
+	          // and the fields in that form. It also is because angular doesn't propagate properties like $submitted down
+	          // to children forms :-( This line was added to solve this issue:
+	          // https://github.com/formly-js/angular-formly/issues/287
+	          // luckily, this is how the formController has been accessed by the NgModelController since angular 1.0.0
+	          // so I expect it will remain this way for the life of angular 1.x
+	          el.removeData('$formController');
+	        } else {
+	          setter(scope.$parent, scope[formId]);
+	        }
+	      }
+	      if (!scope.theFormlyForm && !formlyConfig.disableWarnings) {
+	        /* eslint no-console:0 */
+	        formlyWarn('formly-form-has-no-formcontroller', 'Your formly-form does not have a `form` property. Many functions of the form (like validation) may not work', el, scope);
+	      }
+	    }
+
+	    /*
+	     * chrome autocomplete lameness
+	     * see https://code.google.com/p/chromium/issues/detail?id=468153#c14
+	     * ლ(ಠ益ಠლ)   (╯°□°)╯︵ ┻━┻    (◞‸◟；)
+	     */
+	    function fixChromeAutocomplete() {
+	      var global = formlyConfig.extras.removeChromeAutoComplete === true;
+	      var offInstance = scope.options && scope.options.removeChromeAutoComplete === false;
+	      var onInstance = scope.options && scope.options.removeChromeAutoComplete === true;
+	      if (global && !offInstance || onInstance) {
+	        var input = document.createElement('input');
+	        input.setAttribute('autocomplete', 'address-level4');
+	        input.setAttribute('hidden', 'true');
+	        el[0].appendChild(input);
+	      }
+	    }
+	  }
+
+	  // stateless util functions
+	  function toKebabCase(string) {
+	    if (string) {
+	      return string.replace(/([A-Z])/g, function ($1) {
+	        return '-' + $1.toLowerCase();
+	      });
+	    } else {
+	      return '';
+	    }
+	  }
+	}
+	module.exports = exports['default'];
+
+/***/ },
+/* 17 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	FormlyFormController.$inject = ["formlyUsability", "formlyWarn", "formlyConfig", "$parse", "$scope", "formlyApiCheck", "formlyUtil"];
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+	var _slice = Array.prototype.slice;
+	exports['default'] = FormlyFormController;
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+	function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }
+
+	var _angularFix = __webpack_require__(2);
+
+	var _angularFix2 = _interopRequireDefault(_angularFix);
+
+	function isFieldGroup(field) {
+	  return field && !!field.fieldGroup;
+	}
+
+	// @ngInject
+
+	function FormlyFormController(formlyUsability, formlyWarn, formlyConfig, $parse, $scope, formlyApiCheck, formlyUtil) {
+
+	  setupOptions();
+	  $scope.model = $scope.model || {};
+	  setupFields();
+
+	  // watch the model and evaluate watch expressions that depend on it.
+	  if (!$scope.options.manualModelWatcher) {
+	    $scope.$watch('model', onModelOrFormStateChange, true);
+	  } else if (_angularFix2['default'].isFunction($scope.options.manualModelWatcher)) {
+	    $scope.$watch($scope.options.manualModelWatcher, onModelOrFormStateChange, true);
+	  }
+
+	  if ($scope.options.formState) {
+	    $scope.$watch('options.formState', onModelOrFormStateChange, true);
+	  }
+
+	  function onModelOrFormStateChange() {
+	    _angularFix2['default'].forEach($scope.fields, runFieldExpressionProperties);
+	  }
+
+	  function validateFormControl(formControl, promise) {
+	    var validate = formControl.$validate;
+	    if (promise) {
+	      promise.then(function () {
+	        return validate.apply(formControl);
+	      });
+	    } else {
+	      validate();
+	    }
+	  }
+
+	  function runFieldExpressionProperties(field, index) {
+	    var model = field.model || $scope.model;
+	    var promise = field.runExpressions && field.runExpressions();
+	    if (field.hideExpression) {
+	      // can't use hide with expressionProperties reliably
+	      var val = model[field.key];
+	      field.hide = evalCloseToFormlyExpression(field.hideExpression, val, field, index, { model: model });
+	    }
+	    if (field.extras && field.extras.validateOnModelChange && field.formControl) {
+	      if (_angularFix2['default'].isArray(field.formControl)) {
+	        _angularFix2['default'].forEach(field.formControl, function (formControl) {
+	          validateFormControl(formControl, promise);
+	        });
+	      } else {
+	        validateFormControl(field.formControl, promise);
+	      }
+	    }
+	  }
+
+	  function setupFields() {
+	    $scope.fields = $scope.fields || [];
+
+	    checkDeprecatedOptions($scope.options);
+
+	    var fieldTransforms = $scope.options.fieldTransform || formlyConfig.extras.fieldTransform;
+
+	    if (!_angularFix2['default'].isArray(fieldTransforms)) {
+	      fieldTransforms = [fieldTransforms];
+	    }
+
+	    _angularFix2['default'].forEach(fieldTransforms, function transformFields(fieldTransform) {
+	      if (fieldTransform) {
+	        $scope.fields = fieldTransform($scope.fields, $scope.model, $scope.options, $scope.form);
+	        if (!$scope.fields) {
+	          throw formlyUsability.getFormlyError('fieldTransform must return an array of fields');
+	        }
+	      }
+	    });
+
+	    setupModels();
+
+	    if ($scope.options.watchAllExpressions) {
+	      _angularFix2['default'].forEach($scope.fields, setupHideExpressionWatcher);
+	    }
+
+	    _angularFix2['default'].forEach($scope.fields, attachKey); // attaches a key based on the index if a key isn't specified
+	    _angularFix2['default'].forEach($scope.fields, setupWatchers); // setup watchers for all fields
+	  }
+
+	  function checkDeprecatedOptions(options) {
+	    if (formlyConfig.extras.fieldTransform && _angularFix2['default'].isFunction(formlyConfig.extras.fieldTransform)) {
+	      formlyWarn('fieldtransform-as-a-function-deprecated', 'fieldTransform as a function has been deprecated.', 'Attempted for formlyConfig.extras: ' + formlyConfig.extras.fieldTransform.name, formlyConfig.extras);
+	    } else if (options.fieldTransform && _angularFix2['default'].isFunction(options.fieldTransform)) {
+	      formlyWarn('fieldtransform-as-a-function-deprecated', 'fieldTransform as a function has been deprecated.', 'Attempted for form', options);
+	    }
+	  }
+
+	  function setupOptions() {
+	    formlyApiCheck['throw']([formlyApiCheck.formOptionsApi.optional], [$scope.options], { prefix: 'formly-form options check' });
+	    $scope.options = $scope.options || {};
+	    $scope.options.formState = $scope.options.formState || {};
+
+	    _angularFix2['default'].extend($scope.options, {
+	      updateInitialValue: updateInitialValue,
+	      resetModel: resetModel
+	    });
+	  }
+
+	  function updateInitialValue() {
+	    _angularFix2['default'].forEach($scope.fields, function (field) {
+	      if (isFieldGroup(field) && field.options) {
+	        field.options.updateInitialValue();
+	      } else {
+	        field.updateInitialValue();
+	      }
+	    });
+	  }
+
+	  function resetModel() {
+	    _angularFix2['default'].forEach($scope.fields, function (field) {
+	      if (isFieldGroup(field) && field.options) {
+	        field.options.resetModel();
+	      } else if (field.resetModel) {
+	        field.resetModel();
+	      }
+	    });
+	  }
+
+	  function setupModels() {
+	    // a set of field models that are already watched (the $scope.model will have its own watcher)
+	    var watchedModels = [$scope.model];
+	    // we will not set up automatic model watchers if manual mode is set
+	    var manualModelWatcher = $scope.options.manualModelWatcher;
+
+	    if ($scope.options.formState) {
+	      // $scope.options.formState will have its own watcher
+	      watchedModels.push($scope.options.formState);
+	    }
+
+	    _angularFix2['default'].forEach($scope.fields, function (field) {
+	      var isNewModel = initModel(field);
+
+	      if (field.model && isNewModel && watchedModels.indexOf(field.model) === -1 && !manualModelWatcher) {
+	        $scope.$watch(function () {
+	          return field.model;
+	        }, onModelOrFormStateChange, true);
+	        watchedModels.push(field.model);
+	      }
+	    });
+	  }
+
+	  function setupHideExpressionWatcher(field, index) {
+	    if (field.hideExpression) {
+	      (function () {
+	        // can't use hide with expressionProperties reliably
+	        var model = field.model || $scope.model;
+	        $scope.$watch(function hideExpressionWatcher() {
+	          var val = model[field.key];
+	          return evalCloseToFormlyExpression(field.hideExpression, val, field, index, { model: model });
+	        }, function (hide) {
+	          return field.hide = hide;
+	        }, true);
+	      })();
+	    }
+	  }
+
+	  function initModel(field) {
+	    var isNewModel = true;
+
+	    if (_angularFix2['default'].isString(field.model)) {
+	      (function () {
+	        var expression = field.model;
+
+	        isNewModel = !referencesCurrentlyWatchedModel(expression);
+
+	        field.model = resolveStringModel(expression);
+
+	        $scope.$watch(function () {
+	          return resolveStringModel(expression);
+	        }, function (model) {
+	          return field.model = model;
+	        });
+	      })();
+	    }
+
+	    return isNewModel;
+
+	    function resolveStringModel(expression) {
+	      var index = $scope.fields.indexOf(field);
+	      var model = evalCloseToFormlyExpression(expression, undefined, field, index, { model: $scope.model });
+
+	      if (!model) {
+	        throw formlyUsability.getFieldError('field-model-must-be-initialized', 'Field model must be initialized. When specifying a model as a string for a field, the result of the' + ' expression must have been initialized ahead of time.', field);
+	      }
+
+	      return model;
+	    }
+	  }
+
+	  function referencesCurrentlyWatchedModel(expression) {
+	    return ['model', 'formState'].some(function (item) {
+	      return formlyUtil.startsWith(expression, item + '.') || formlyUtil.startsWith(expression, item + '[');
+	    });
+	  }
+
+	  function attachKey(field, index) {
+	    if (!isFieldGroup(field)) {
+	      field.key = field.key || index || 0;
+	    }
+	  }
+
+	  function setupWatchers(field, index) {
+	    if (!_angularFix2['default'].isDefined(field.watcher)) {
+	      return;
+	    }
+	    var watchers = field.watcher;
+	    if (!_angularFix2['default'].isArray(watchers)) {
+	      watchers = [watchers];
+	    }
+	    _angularFix2['default'].forEach(watchers, function setupWatcher(watcher) {
+	      if (!_angularFix2['default'].isDefined(watcher.listener) && !watcher.runFieldExpressions) {
+	        throw formlyUsability.getFieldError('all-field-watchers-must-have-a-listener', 'All field watchers must have a listener', field);
+	      }
+	      var watchExpression = getWatchExpression(watcher, field, index);
+	      var watchListener = getWatchListener(watcher, field, index);
+
+	      var type = watcher.type || '$watch';
+	      watcher.stopWatching = $scope[type](watchExpression, watchListener, watcher.watchDeep);
+	    });
+	  }
+
+	  function getWatchExpression(watcher, field, index) {
+	    var watchExpression = undefined;
+	    if (!_angularFix2['default'].isUndefined(watcher.expression)) {
+	      watchExpression = watcher.expression;
+	    } else if (field.key) {
+	      watchExpression = 'model[\'' + field.key.toString().split('.').join('\'][\'') + '\']';
+	    }
+	    if (_angularFix2['default'].isFunction(watchExpression)) {
+	      (function () {
+	        // wrap the field's watch expression so we can call it with the field as the first arg
+	        // and the stop function as the last arg as a helper
+	        var originalExpression = watchExpression;
+	        watchExpression = function formlyWatchExpression() {
+	          var args = modifyArgs.apply(undefined, [watcher, index].concat(_slice.call(arguments)));
+	          return originalExpression.apply(undefined, _toConsumableArray(args));
+	        };
+	        watchExpression.displayName = 'Formly Watch Expression for field for ' + field.key;
+	      })();
+	    } else if (field.model) {
+	      watchExpression = $parse(watchExpression).bind(null, $scope, { model: field.model });
+	    }
+	    return watchExpression;
+	  }
+
+	  function getWatchListener(watcher, field, index) {
+	    var watchListener = watcher.listener;
+	    if (_angularFix2['default'].isFunction(watchListener) || watcher.runFieldExpressions) {
+	      (function () {
+	        // wrap the field's watch listener so we can call it with the field as the first arg
+	        // and the stop function as the last arg as a helper
+	        var originalListener = watchListener;
+	        watchListener = function formlyWatchListener() {
+	          var value = undefined;
+	          if (originalListener) {
+	            var args = modifyArgs.apply(undefined, [watcher, index].concat(_slice.call(arguments)));
+	            value = originalListener.apply(undefined, _toConsumableArray(args));
+	          }
+	          if (watcher.runFieldExpressions) {
+	            runFieldExpressionProperties(field, index);
+	          }
+	          return value;
+	        };
+	        watchListener.displayName = 'Formly Watch Listener for field for ' + field.key;
+	      })();
+	    }
+	    return watchListener;
+	  }
+
+	  function modifyArgs(watcher, index) {
+	    for (var _len = arguments.length, originalArgs = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+	      originalArgs[_key - 2] = arguments[_key];
+	    }
+
+	    return [$scope.fields[index]].concat(originalArgs, [watcher.stopWatching]);
+	  }
+
+	  function evalCloseToFormlyExpression(expression, val, field, index) {
+	    var extraLocals = arguments.length <= 4 || arguments[4] === undefined ? {} : arguments[4];
+
+	    extraLocals = _angularFix2['default'].extend(getFormlyFieldLikeLocals(field, index), extraLocals);
+	    return formlyUtil.formlyEval($scope, expression, val, val, extraLocals);
+	  }
+
+	  function getFormlyFieldLikeLocals(field, index) {
+	    // this makes it closer to what a regular formlyExpression would be
+	    return {
+	      model: field.model,
+	      options: field,
+	      index: index,
+	      formState: $scope.options.formState,
+	      originalModel: $scope.model,
+	      formOptions: $scope.options,
+	      formId: $scope.formId
+	    };
+	  }
+	}
+
+	module.exports = exports['default'];
+
+/***/ },
+/* 18 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	addFormlyNgModelAttrsManipulator.$inject = ["formlyConfig", "$interpolate"];
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+	var _angularFix = __webpack_require__(2);
+
+	var _angularFix2 = _interopRequireDefault(_angularFix);
+
+	var _otherUtils = __webpack_require__(9);
+
+	exports['default'] = addFormlyNgModelAttrsManipulator;
+
+	// @ngInject
+	function addFormlyNgModelAttrsManipulator(formlyConfig, $interpolate) {
+	  if (formlyConfig.extras.disableNgModelAttrsManipulator) {
+	    return;
+	  }
+	  formlyConfig.templateManipulators.preWrapper.push(ngModelAttrsManipulator);
+
+	  function ngModelAttrsManipulator(template, options, scope) {
+	    var node = document.createElement('div');
+	    var skip = options.extras && options.extras.skipNgModelAttrsManipulator;
+	    if (skip === true) {
+	      return template;
+	    }
+	    node.innerHTML = template;
+
+	    var modelNodes = getNgModelNodes(node, skip);
+	    if (!modelNodes || !modelNodes.length) {
+	      return template;
+	    }
+
+	    addIfNotPresent(modelNodes, 'id', scope.id);
+	    addIfNotPresent(modelNodes, 'name', scope.name || scope.id);
+
+	    addValidation();
+	    alterNgModelAttr();
+	    addModelOptions();
+	    addTemplateOptionsAttrs();
+	    addNgModelElAttrs();
+
+	    return node.innerHTML;
+
+	    function addValidation() {
+	      if (_angularFix2['default'].isDefined(options.validators) || _angularFix2['default'].isDefined(options.validation.messages)) {
+	        addIfNotPresent(modelNodes, 'formly-custom-validation', '');
+	      }
+	    }
+
+	    function alterNgModelAttr() {
+	      if (isPropertyAccessor(options.key)) {
+	        addRegardlessOfPresence(modelNodes, 'ng-model', 'model.' + options.key);
+	      }
+	    }
+
+	    function addModelOptions() {
+	      if (_angularFix2['default'].isDefined(options.modelOptions)) {
+	        addIfNotPresent(modelNodes, 'ng-model-options', 'options.modelOptions');
+	        if (options.modelOptions.getterSetter) {
+	          addRegardlessOfPresence(modelNodes, 'ng-model', 'options.value');
+	        }
+	      }
+	    }
+
+	    function addTemplateOptionsAttrs() {
+	      if (!options.templateOptions && !options.expressionProperties) {
+	        // no need to run these if there are no templateOptions or expressionProperties
+	        return;
+	      }
+	      var to = options.templateOptions || {};
+	      var ep = options.expressionProperties || {};
+
+	      var ngModelAttributes = getBuiltInAttributes();
+
+	      // extend with the user's specifications winning
+	      _angularFix2['default'].extend(ngModelAttributes, options.ngModelAttrs);
+
+	      // Feel free to make this more simple :-)
+	      _angularFix2['default'].forEach(ngModelAttributes, function (val, name) {
+	        /* eslint complexity:[2, 14] */
+	        var attrVal = undefined,
+	            attrName = undefined;
+	        var ref = 'options.templateOptions[\'' + name + '\']';
+	        var toVal = to[name];
+	        var epVal = getEpValue(ep, name);
+
+	        var inTo = _angularFix2['default'].isDefined(toVal);
+	        var inEp = _angularFix2['default'].isDefined(epVal);
+	        if (val.value) {
+	          // I realize this looks backwards, but it's right, trust me...
+	          attrName = val.value;
+	          attrVal = name;
+	        } else if (val.statement && inTo) {
+	          attrName = val.statement;
+	          if (_angularFix2['default'].isString(to[name])) {
+	            attrVal = '$eval(' + ref + ')';
+	          } else if (_angularFix2['default'].isFunction(to[name])) {
+	            attrVal = ref + '(model[options.key], options, this, $event)';
+	          } else {
+	            throw new Error('options.templateOptions.' + name + ' must be a string or function: ' + JSON.stringify(options));
+	          }
+	        } else if (val.bound && inEp) {
+	          attrName = val.bound;
+	          attrVal = ref;
+	        } else if ((val.attribute || val.boolean) && inEp) {
+	          attrName = val.attribute || val.boolean;
+	          attrVal = '' + $interpolate.startSymbol() + ref + $interpolate.endSymbol();
+	        } else if (val.attribute && inTo) {
+	          attrName = val.attribute;
+	          attrVal = toVal;
+	        } else if (val.boolean) {
+	          if (inTo && !inEp && toVal) {
+	            attrName = val.boolean;
+	            attrVal = true;
+	          } else {
+	            /* eslint no-empty:0 */
+	            // empty to illustrate that a boolean will not be added via val.bound
+	            // if you want it added via val.bound, then put it in expressionProperties
+	          }
+	        } else if (val.bound && inTo) {
+	            attrName = val.bound;
+	            attrVal = ref;
+	          }
+
+	        if (_angularFix2['default'].isDefined(attrName) && _angularFix2['default'].isDefined(attrVal)) {
+	          addIfNotPresent(modelNodes, attrName, attrVal);
+	        }
+	      });
+	    }
+
+	    function addNgModelElAttrs() {
+	      _angularFix2['default'].forEach(options.ngModelElAttrs, function (val, name) {
+	        addRegardlessOfPresence(modelNodes, name, val);
+	      });
+	    }
+	  }
+
+	  // Utility functions
+	  function getNgModelNodes(node, skip) {
+	    var selectorNot = _angularFix2['default'].isString(skip) ? ':not(' + skip + ')' : '';
+	    var skipNot = ':not([formly-skip-ng-model-attrs-manipulator])';
+	    var query = '[ng-model]' + selectorNot + skipNot + ', [data-ng-model]' + selectorNot + skipNot;
+	    try {
+	      return node.querySelectorAll(query);
+	    } catch (e) {
+	      //this code is needed for IE8, as it does not support the CSS3 ':not' selector
+	      //it should be removed when IE8 support is dropped
+	      return getNgModelNodesFallback(node, skip);
+	    }
+	  }
+
+	  function getNgModelNodesFallback(node, skip) {
+	    var allNgModelNodes = node.querySelectorAll('[ng-model], [data-ng-model]');
+	    var matchingNgModelNodes = [];
+
+	    //make sure this array is compatible with NodeList type by adding an 'item' function
+	    matchingNgModelNodes.item = function (i) {
+	      return this[i];
+	    };
+
+	    for (var i = 0; i < allNgModelNodes.length; i++) {
+	      var ngModelNode = allNgModelNodes[i];
+	      if (!ngModelNode.hasAttribute('formly-skip-ng-model-attrs-manipulator') && !(_angularFix2['default'].isString(skip) && nodeMatches(ngModelNode, skip))) {
+	        matchingNgModelNodes.push(ngModelNode);
+	      }
+	    }
+
+	    return matchingNgModelNodes;
+	  }
+
+	  function nodeMatches(node, selector) {
+	    var div = document.createElement('div');
+	    div.innerHTML = node.outerHTML;
+	    return div.querySelector(selector);
+	  }
+
+	  function getBuiltInAttributes() {
+	    var ngModelAttributes = {
+	      focus: {
+	        attribute: 'formly-focus'
+	      }
+	    };
+	    var boundOnly = [];
+	    var bothBooleanAndBound = ['required', 'disabled'];
+	    var bothAttributeAndBound = ['pattern', 'minlength'];
+	    var statementOnly = ['change', 'keydown', 'keyup', 'keypress', 'click', 'focus', 'blur'];
+	    var attributeOnly = ['placeholder', 'min', 'max', 'step', 'tabindex', 'type'];
+	    if (formlyConfig.extras.ngModelAttrsManipulatorPreferUnbound) {
+	      bothAttributeAndBound.push('maxlength');
+	    } else {
+	      boundOnly.push('maxlength');
+	    }
+
+	    _angularFix2['default'].forEach(boundOnly, function (item) {
+	      ngModelAttributes[item] = { bound: 'ng-' + item };
+	    });
+
+	    _angularFix2['default'].forEach(bothBooleanAndBound, function (item) {
+	      ngModelAttributes[item] = { boolean: item, bound: 'ng-' + item };
+	    });
+
+	    _angularFix2['default'].forEach(bothAttributeAndBound, function (item) {
+	      ngModelAttributes[item] = { attribute: item, bound: 'ng-' + item };
+	    });
+
+	    _angularFix2['default'].forEach(statementOnly, function (item) {
+	      var propName = 'on' + item.substr(0, 1).toUpperCase() + item.substr(1);
+	      ngModelAttributes[propName] = { statement: 'ng-' + item };
+	    });
+
+	    _angularFix2['default'].forEach(attributeOnly, function (item) {
+	      ngModelAttributes[item] = { attribute: item };
+	    });
+	    return ngModelAttributes;
+	  }
+
+	  function getEpValue(ep, name) {
+	    return ep['templateOptions.' + name] || ep['templateOptions[\'' + name + '\']'] || ep['templateOptions["' + name + '"]'];
+	  }
+
+	  function addIfNotPresent(nodes, attr, val) {
+	    _angularFix2['default'].forEach(nodes, function (node) {
+	      if (!node.getAttribute(attr)) {
+	        node.setAttribute(attr, val);
+	      }
+	    });
+	  }
+
+	  function addRegardlessOfPresence(nodes, attr, val) {
+	    _angularFix2['default'].forEach(nodes, function (node) {
+	      node.setAttribute(attr, val);
+	    });
+	  }
+
+	  function isPropertyAccessor(key) {
+	    return (0, _otherUtils.contains)(key, '.') || (0, _otherUtils.contains)(key, '[') && (0, _otherUtils.contains)(key, ']');
+	  }
+	}
+	module.exports = exports['default'];
+
+/***/ },
+/* 19 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	addCustomTags.$inject = ["$document"];
+	Object.defineProperty(exports, '__esModule', {
+	  value: true
+	});
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+	var _angularFix = __webpack_require__(2);
+
+	var _angularFix2 = _interopRequireDefault(_angularFix);
+
+	exports['default'] = addCustomTags;
+
+	// @ngInject
+	function addCustomTags($document) {
+	  // IE8 check ->
+	  // https://msdn.microsoft.com/en-us/library/cc196988(v=vs.85).aspx
+	  if ($document && $document.documentMode < 9) {
+	    (function () {
+	      var document = $document.get(0);
+	      // add the custom elements that we need for formly
+	      var customElements = ['formly-field', 'formly-form'];
+	      _angularFix2['default'].forEach(customElements, function (el) {
+	        document.createElement(el);
+	      });
+	    })();
+	  }
+	}
+	module.exports = exports['default'];
+
+/***/ }
+/******/ ])
+});
+;