text: // angular-formly version 6.5.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("api-check"), require("angular"));
  	else if(typeof define === 'function' && define.amd)
  		define(["api-check", "angular"], factory);
  	else if(typeof exports === 'object')
  		exports["ngFormly"] = factory(require("api-check"), require("angular"));
  	else
  		root["ngFormly"] = factory(root["apiCheck"], root["angular"]);
  })(this, function(__WEBPACK_EXTERNAL_MODULE_16__, __WEBPACK_EXTERNAL_MODULE_17__) {
  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";
  	
  	var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
  	
  	var index = _interopRequire(__webpack_require__(1));
  	
  	module.exports = index;
  
  /***/ },
  /* 1 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
  	
  	var angular = _interopRequire(__webpack_require__(15));
  	
  	var formlyApiCheck = _interopRequire(__webpack_require__(2));
  	
  	var formlyErrorAndWarningsUrlPrefix = _interopRequire(__webpack_require__(3));
  	
  	var formlyUsability = _interopRequire(__webpack_require__(4));
  	
  	var formlyConfig = _interopRequire(__webpack_require__(5));
  	
  	var formlyValidationMessages = _interopRequire(__webpack_require__(6));
  	
  	var formlyUtil = _interopRequire(__webpack_require__(7));
  	
  	var formlyWarn = _interopRequire(__webpack_require__(8));
  	
  	var formlyCustomValidation = _interopRequire(__webpack_require__(9));
  	
  	var formlyField = _interopRequire(__webpack_require__(10));
  	
  	var formlyFocus = _interopRequire(__webpack_require__(11));
  	
  	var formlyForm = _interopRequire(__webpack_require__(12));
  	
  	var formlyNgModelAttrsManipulator = _interopRequire(__webpack_require__(13));
  	
  	var formlyCustomTags = _interopRequire(__webpack_require__(14));
  	
  	var ngModuleName = "formly";
  	
  	module.exports = ngModuleName;
  	
  	var ngModule = angular.module(ngModuleName, []);
  	
  	ngModule.constant("formlyApiCheck", formlyApiCheck);
  	ngModule.constant("formlyErrorAndWarningsUrlPrefix", formlyErrorAndWarningsUrlPrefix);
  	ngModule.constant("formlyVersion", ("6.5.0")); // <-- webpack variable
  	
  	ngModule.provider("formlyUsability", formlyUsability);
  	ngModule.provider("formlyConfig", formlyConfig);
  	
  	ngModule.factory("formlyValidationMessages", formlyValidationMessages);
  	ngModule.factory("formlyUtil", formlyUtil);
  	ngModule.factory("formlyWarn", formlyWarn);
  	
  	ngModule.directive("formlyCustomValidation", formlyCustomValidation);
  	ngModule.directive("formlyField", formlyField);
  	ngModule.directive("formlyFocus", formlyFocus);
  	ngModule.directive("formlyForm", formlyForm);
  	
  	ngModule.run(formlyNgModelAttrsManipulator);
  	ngModule.run(formlyCustomTags);
  
  /***/ },
  /* 2 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
  	
  	var apiCheckFactory = _interopRequire(__webpack_require__(16));
  	
  	var apiCheck = apiCheckFactory({
  	  output: {
  	    prefix: "angular-formly:",
  	    docsBaseUrl: __webpack_require__(3)
  	  }
  	});
  	
  	function shapeRequiredIfNot(otherProps, propChecker) {
  	  if (!angular.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.oneOfType([apiCheck.oneOf([null]), apiCheck.typeOrArrayOf(apiCheck.string)]);
  	
  	var apiCheckProperty = apiCheck.objectOf(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,
  	  validateOptions: apiCheck.func.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 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: apiCheck.object.optional,
  	  className: apiCheck.string.optional,
  	  expressionProperties: expressionProperties.optional,
  	  data: apiCheck.object.optional,
  	  templateOptions: apiCheck.object.optional,
  	  wrapper: specifyWrapperType.optional,
  	  modelOptions: apiCheck.shape({
  	    updateOn: apiCheck.string.optional,
  	    debounce: apiCheck.oneOfType([apiCheck.object, apiCheck.string]).optional,
  	    allowInvalid: apiCheck.bool.optional,
  	    getterSetter: apiCheck.bool.optional,
  	    timezone: apiCheck.string.optional
  	  }).optional,
  	  watcher: apiCheck.typeOrArrayOf(apiCheck.shape({
  	    expression: formlyExpression.optional,
  	    listener: formlyExpression
  	  })).optional,
  	  validators: apiCheck.objectOf(apiCheck.oneOfType([formlyExpression, apiCheck.shape({
  	    expression: formlyExpression,
  	    message: formlyExpression.optional
  	  }).strict])).optional,
  	  noFormControl: apiCheck.bool.optional,
  	  hide: apiCheck.bool.optional,
  	  hideExpression: formlyExpression.optional,
  	  ngModelAttrs: apiCheck.objectOf(apiCheck.shape({
  	    expression: apiCheck.shape.ifNot(["value", "attribute", "bound"], apiCheck.any).optional,
  	    value: apiCheck.shape.ifNot("expression", apiCheck.any).optional,
  	    attribute: apiCheck.shape.ifNot("expression", apiCheck.any).optional,
  	    bound: apiCheck.shape.ifNot("expression", 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.oneOfType([apiCheck.bool, apiCheck.oneOf([null])]).optional,
  	    messages: apiCheck.objectOf(formlyExpression).optional,
  	    errorExistsAndShouldBeVisible: apiCheck.bool.optional
  	  }).optional,
  	  formControl: apiCheck.object.optional,
  	  value: apiCheck.func.optional,
  	  runExpressions: apiCheck.func.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
  	}).strict;
  	
  	var fieldGroup = apiCheck.shape({
  	  $$hashKey: apiCheck.any.optional,
  	  fieldGroup: apiCheck.arrayOf(formlyFieldOptions),
  	  className: apiCheck.string.optional,
  	  options: formOptionsApi.optional,
  	  hide: apiCheck.bool.optional,
  	  hideExpression: formlyExpression.optional,
  	  model: apiCheck.object.optional,
  	  form: apiCheck.object.optional,
  	  elementAttributes: apiCheck.objectOf(apiCheck.string).optional
  	}).strict;
  	
  	var typeOptionsDefaultOptions = angular.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,
  	  validateOptions: apiCheck.func.optional,
  	  apiCheck: apiCheckProperty.optional,
  	  apiCheckInstance: apiCheckInstanceProperty.optional,
  	  apiCheckFunction: apiCheckFunctionProperty.optional,
  	  apiCheckOptions: apiCheck.object.optional,
  	  overwriteOk: apiCheck.bool.optional
  	}).strict;
  	angular.extend(apiCheck, {
  	  formlyTypeOptions: formlyTypeOptions, formlyFieldOptions: formlyFieldOptions, formlyExpression: formlyExpression, formlyWrapperType: formlyWrapperType, fieldGroup: fieldGroup, formOptionsApi: formOptionsApi
  	});
  	
  	module.exports = apiCheck;
  
  /***/ },
  /* 3 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	module.exports = "https://github.com/formly-js/angular-formly/blob/" + ("6.5.0") + "/other/ERRORS_AND_WARNINGS.md#";
  
  /***/ },
  /* 4 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
  	
  	var angular = _interopRequire(__webpack_require__(15));
  	
  	module.exports = formlyUsability;
  	
  	// @ngInject
  	function formlyUsability(formlyApiCheck, formlyErrorAndWarningsUrlPrefix) {
  	  var _this = this;
  	
  	  angular.extend(this, {
  	    getFormlyError: getFormlyError,
  	    getFieldError: getFieldError,
  	    checkWrapper: checkWrapper,
  	    checkWrapperTemplate: checkWrapperTemplate,
  	    $get: function () {
  	      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: " + angular.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)));
  	    }
  	  }
  	}
  	formlyUsability.$inject = ["formlyApiCheck", "formlyErrorAndWarningsUrlPrefix"];
  
  /***/ },
  /* 5 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
  	
  	var angular = _interopRequire(__webpack_require__(15));
  	
  	var utils = _interopRequire(__webpack_require__(18));
  	
  	module.exports = formlyConfig;
  	
  	// @ngInject
  	function formlyConfig(formlyUsabilityProvider, formlyApiCheck) {
  	  var _this2 = this;
  	
  	  var typeMap = {};
  	  var templateWrappersMap = {};
  	  var defaultWrapperName = "default";
  	  var _this = this;
  	  var getError = formlyUsabilityProvider.getFormlyError;
  	
  	  angular.extend(this, {
  	    setType: setType,
  	    getType: getType,
  	    setWrapper: setWrapper,
  	    getWrapper: getWrapper,
  	    getWrapperByType: getWrapperByType,
  	    removeWrapperByName: removeWrapperByName,
  	    removeWrappersForType: removeWrappersForType,
  	    disableWarnings: false,
  	    extras: {
  	      disableNgModelAttrsManipulator: false,
  	      ngModelAttrsManipulatorPreferUnbound: false,
  	      removeChromeAutoComplete: false,
  	      defaultHideDirective: "ng-if"
  	    },
  	    templateManipulators: {
  	      preWrapper: [],
  	      postWrapper: []
  	    },
  	    $get: function () {
  	      return _this2;
  	    }
  	  });
  	
  	  function setType(options) {
  	    if (angular.isArray(options)) {
  	      angular.forEach(options, setType);
  	    } else if (angular.isObject(options)) {
  	      checkType(options);
  	      if (options["extends"]) {
  	        extendTypeOptions(options);
  	      }
  	      typeMap[options.name] = options;
  	    } 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);
  	    extendTypeValidateOptionsFunction(options, extendsType);
  	    extendTypeDefaultOptions(options, extendsType);
  	    utils.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 (!angular.isDefined(extendsCtrl)) {
  	      return;
  	    }
  	    var optionsCtrl = options.controller;
  	    if (angular.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 (!angular.isDefined(extendsFn)) {
  	      return;
  	    }
  	    var optionsFn = options.link;
  	    if (angular.isDefined(optionsFn)) {
  	      options.link = function () {
  	        extendsFn.apply(undefined, arguments);
  	        optionsFn.apply(undefined, arguments);
  	      };
  	    } else {
  	      options.link = extendsFn;
  	    }
  	  }
  	
  	  function extendTypeValidateOptionsFunction(options, extendsType) {
  	    var extendsFn = extendsType.validateOptions;
  	    if (!angular.isDefined(extendsFn)) {
  	      return;
  	    }
  	    var optionsFn = options.validateOptions;
  	    var originalDefaultOptions = options.defaultOptions;
  	    if (angular.isDefined(optionsFn)) {
  	      options.validateOptions = function (options) {
  	        optionsFn(options);
  	        var mergedOptions = angular.copy(options);
  	        var defaultOptions = originalDefaultOptions;
  	        if (defaultOptions) {
  	          if (angular.isFunction(defaultOptions)) {
  	            defaultOptions = defaultOptions(mergedOptions);
  	          }
  	          utils.reverseDeepMerge(mergedOptions, defaultOptions);
  	        }
  	        extendsFn(mergedOptions);
  	      };
  	    } else {
  	      options.validateOptions = extendsFn;
  	    }
  	  }
  	
  	  function extendTypeDefaultOptions(options, extendsType) {
  	    var extendsDO = extendsType.defaultOptions;
  	    if (!angular.isDefined(extendsDO)) {
  	      return;
  	    }
  	    var optionsDO = options.defaultOptions;
  	    var optionsDOIsFn = angular.isFunction(optionsDO);
  	    var extendsDOIsFn = angular.isFunction(extendsDO);
  	    if (extendsDOIsFn) {
  	      options.defaultOptions = function defaultOptions(options) {
  	        var extendsDefaultOptions = extendsDO(options);
  	        var mergedDefaultOptions = {};
  	        utils.reverseDeepMerge(mergedDefaultOptions, options, extendsDefaultOptions);
  	        var extenderOptionsDefaultOptions = optionsDO;
  	        if (optionsDOIsFn) {
  	          extenderOptionsDefaultOptions = extenderOptionsDefaultOptions(mergedDefaultOptions);
  	        }
  	        utils.reverseDeepMerge(extendsDefaultOptions, extenderOptionsDefaultOptions);
  	        return extendsDefaultOptions;
  	      };
  	    } else if (optionsDOIsFn) {
  	      options.defaultOptions = function defaultOptions(options) {
  	        var newDefaultOptions = {};
  	        utils.reverseDeepMerge(newDefaultOptions, options, extendsDO);
  	        return optionsDO(newDefaultOptions);
  	      };
  	    }
  	  }
  	
  	  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 setWrapper(_x, _x2) {
  	    var _again = true;
  	
  	    _function: while (_again) {
  	      _again = false;
  	      var options = _x,
  	          name = _x2;
  	
  	      if (angular.isArray(options)) {
  	        return options.map(function (wrapperOptions) {
  	          return setWrapper(wrapperOptions);
  	        });
  	      } else if (angular.isObject(options)) {
  	        options.types = getOptionsTypes(options);
  	        options.name = getOptionsName(options, name);
  	        checkWrapperAPI(options);
  	        templateWrappersMap[options.name] = options;
  	        return options;
  	      } else if (angular.isString(options)) {
  	        _x = {
  	          template: options,
  	          name: name
  	        };
  	        _again = true;
  	        continue _function;
  	      }
  	    }
  	  }
  	
  	  function getOptionsTypes(options) {
  	    if (angular.isString(options.types)) {
  	      return [options.types];
  	    }
  	    if (!angular.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 = !angular.isArray(options.types) || !options.types.every(angular.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(["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) {
  	    /* jshint maxcomplexity:6 */
  	    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;
  	    }
  	    if (!angular.isArray(wrappers)) {
  	      return removeWrapperByName(wrappers.name);
  	    } else {
  	      wrappers.forEach(function (wrapper) {
  	        return removeWrapperByName(wrapper.name);
  	      });
  	      return wrappers;
  	    }
  	  }
  	
  	  function warn() {
  	    if (!_this.disableWarnings) {
  	      console.warn.apply(console, arguments);
  	    }
  	  }
  	}
  	formlyConfig.$inject = ["formlyUsabilityProvider", "formlyApiCheck"];
  
  /***/ },
  /* 6 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	module.exports = 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 (scope.options.templateOptions[prop]) {
  	        return "" + prefix + " " + scope.options.templateOptions[prop] + " " + suffix;
  	      } else {
  	        return alternate;
  	      }
  	    };
  	  }
  	}
  
  /***/ },
  /* 7 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
  	
  	var utils = _interopRequire(__webpack_require__(18));
  	
  	module.exports = formlyUtil;
  	
  	// @ngInject
  	function formlyUtil() {
  	  return utils;
  	}
  
  /***/ },
  /* 8 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	var _toConsumableArray = function (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); } };
  	
  	module.exports = 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));
  	    }
  	  };
  	}
  	formlyWarn.$inject = ["formlyConfig", "formlyErrorAndWarningsUrlPrefix", "$log"];
  
  /***/ },
  /* 9 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	module.exports = formlyCustomValidation;
  	
  	// @ngInject
  	function formlyCustomValidation(formlyUtil, $q) {
  	  return {
  	    restrict: "A",
  	    require: "ngModel",
  	    link: function formlyCustomValidationLink(scope, el, attrs, ctrl) {
  	      var opts = scope.options;
  	      if (opts.validators) {
  	        checkValidators(opts.validators);
  	      }
  	      opts.validation.messages = opts.validation.messages || {};
  	      angular.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");
  	      angular.forEach(opts.validators, function addValidatorToPipeline(validator, name) {
  	        var message = validator.message;
  	        if (message) {
  	          opts.validation.messages[name] = function () {
  	            return formlyUtil.formlyEval(scope, message, ctrl.$modelValue, ctrl.$viewValue);
  	          };
  	        }
  	        validator = angular.isObject(validator) ? validator.expression : validator;
  	        var isPossiblyAsync = !angular.isString(validator);
  	        if (useNewValidatorsApi) {
  	          setupWithValidators();
  	        } else {
  	          setupWithParsers();
  	        }
  	
  	        function setupWithValidators() {
  	          var validatorCollection = isPossiblyAsync ? "$asyncValidators" : "$validators";
  	          ctrl[validatorCollection][name] = function evalValidity(modelValue, viewValue) {
  	            var value = formlyUtil.formlyEval(scope, validator, modelValue, viewValue);
  	            if (isPossiblyAsync) {
  	              return isPromiseLike(value) ? value : value ? $q.when(value) : $q.reject(value);
  	            } else {
  	              return value;
  	            }
  	          };
  	        }
  	
  	        function setupWithParsers() {
  	          var inFlightValidator = undefined;
  	          ctrl.$parsers.unshift(function evalValidityOfParser(viewValue) {
  	            var isValid = formlyUtil.formlyEval(scope, validator, ctrl.$modelValue, viewValue);
  	            if (isPromiseLike(isValid)) {
  	              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 () {
  	                if (Object.keys(ctrl.$pending).length === 1) {
  	                  delete ctrl.$pending;
  	                } else {
  	                  delete ctrl.$pending[name];
  	                }
  	              });
  	            } else {
  	              ctrl.$setValidity(name, isValid);
  	            }
  	            return viewValue;
  	          });
  	        }
  	      });
  	    }
  	  };
  	
  	  function isPromiseLike(obj) {
  	    return obj && angular.isFunction(obj.then);
  	  }
  	
  	  function checkValidators(validators) {
  	    var allowedProperties = ["expression", "message"];
  	    var validatorsWithExtraProps = {};
  	    angular.forEach(validators, function (validator, name) {
  	      if (angular.isString(validator)) {
  	        return;
  	      }
  	      var extraProps = [];
  	      angular.forEach(validator, function (v, key) {
  	        if (allowedProperties.indexOf(key) === -1) {
  	          extraProps.push(key);
  	        }
  	      });
  	      if (extraProps.length) {
  	        validatorsWithExtraProps[name] = extraProps;
  	      }
  	    });
  	    if (Object.keys(validatorsWithExtraProps).length) {
  	      throw new Error(["Validators are only allowed to be functions or objects that have " + allowedProperties.join(", ") + ".", "You provided some extra properties: " + JSON.stringify(validatorsWithExtraProps)].join(" "));
  	    }
  	  }
  	}
  	formlyCustomValidation.$inject = ["formlyUtil", "$q"];
  
  /***/ },
  /* 10 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
  	
  	var angular = _interopRequire(__webpack_require__(15));
  	
  	module.exports = formlyField;
  	
  	/**
  	 * @ngdoc directive
  	 * @name formlyField
  	 * @restrict AE
  	 */
  	// @ngInject
  	function formlyField($http, $q, $compile, $templateCache, formlyConfig, formlyValidationMessages, formlyApiCheck, formlyUtil, formlyUsability, formlyWarn) {
  	  var arrayify = formlyUtil.arrayify;
  	
  	  FormlyFieldController.$inject = ["$scope", "$timeout", "$parse", "$controller"];
  	  return {
  	    restrict: "AE",
  	    transclude: true,
  	    scope: {
  	      options: "=",
  	      model: "=",
  	      formId: "@",
  	      index: "=?",
  	      fields: "=?",
  	      formState: "=?",
  	      form: "=?"
  	    },
  	    controller: FormlyFieldController,
  	    link: fieldLink
  	  };
  	
  	  // @ngInject
  	  function FormlyFieldController($scope, $timeout, $parse, $controller) {
  	    /* jshint maxstatements:31 */
  	    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
  	    $scope.id = formlyUtil.getFieldId($scope.formId, $scope.options, $scope.index);
  	
  	    // initalization
  	    setDefaultValue();
  	    setInitialValue();
  	    runExpressions();
  	    addModelWatcher($scope, $scope.options);
  	    addValidationMessages($scope.options);
  	    invokeControllers($scope, $scope.options, fieldType);
  	
  	    // function definitions
  	    function runExpressions() {
  	      // must run on next tick to make sure that the current value is correct.
  	      $timeout(function runExpressionsOnNextTick() {
  	        var field = $scope.options;
  	        var currentValue = valueGetterSetter();
  	        angular.forEach(field.expressionProperties, function runExpression(expression, prop) {
  	          var setter = $parse(prop).assign;
  	          var promise = $q.when(formlyUtil.formlyEval($scope, expression, currentValue));
  	          promise.then(function setFieldValue(value) {
  	            setter(field, value);
  	          });
  	        });
  	      });
  	    }
  	
  	    function valueGetterSetter(newVal) {
  	      if (!$scope.model || !$scope.options.key) {
  	        return;
  	      }
  	      if (angular.isDefined(newVal)) {
  	        $scope.model[$scope.options.key] = newVal;
  	      }
  	      return $scope.model[$scope.options.key];
  	    }
  	
  	    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, {
  	        data: {},
  	        templateOptions: {},
  	        validation: {}
  	      });
  	      // create $scope.to so template authors can reference to instead of $scope.options.templateOptions
  	      $scope.to = $scope.options.templateOptions;
  	    }
  	
  	    function setDefaultValue() {
  	      if (angular.isDefined($scope.options.defaultValue) && !angular.isDefined($scope.model[$scope.options.key])) {
  	        $scope.model[$scope.options.key] = $scope.options.defaultValue;
  	      }
  	    }
  	
  	    function setInitialValue() {
  	      $scope.options.initialValue = $scope.model && $scope.model[$scope.options.key];
  	    }
  	
  	    function mergeFieldOptionsWithTypeDefaults(options, type) {
  	      if (type) {
  	        mergeOptions(options, type.defaultOptions);
  	      }
  	      var properOrder = arrayify(options.optionsTypes).reverse(); // so the right things are overridden
  	      angular.forEach(properOrder, function (typeName) {
  	        mergeOptions(options, formlyConfig.getType(typeName, true, options).defaultOptions);
  	      });
  	    }
  	
  	    function mergeOptions(options, extraOptions) {
  	      if (extraOptions) {
  	        if (angular.isFunction(extraOptions)) {
  	          extraOptions = extraOptions(options);
  	        }
  	        formlyUtil.reverseDeepMerge(options, extraOptions);
  	      }
  	    }
  	
  	    function extendOptionsWithDefaults(options, index) {
  	      var key = options.key || index || 0;
  	      angular.extend(options, {
  	        // attach the key in case the formly-field directive is used directly
  	        key: key,
  	        value: valueGetterSetter,
  	        runExpressions: runExpressions,
  	        resetModel: resetModel,
  	        updateInitialValue: updateInitialValue
  	      });
  	    }
  	
  	    // initialization functions
  	    function addModelWatcher(scope, options) {
  	      if (options.model) {
  	        scope.$watch("options.model", runExpressions, true);
  	      }
  	    }
  	
  	    function resetModel() {
  	      $scope.model[$scope.options.key] = $scope.options.initialValue;
  	      if ($scope.options.formControl) {
  	        $scope.options.formControl.$setViewValue($scope.model[$scope.options.key]);
  	        $scope.options.formControl.$render();
  	        $scope.options.formControl.$setUntouched();
  	        $scope.options.formControl.$setPristine();
  	      }
  	    }
  	
  	    function updateInitialValue() {
  	      $scope.options.initialValue = $scope.model[$scope.options.key];
  	    }
  	
  	    function addValidationMessages(options) {
  	      options.validation.messages = options.validation.messages || {};
  	      angular.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[1] === undefined ? {} : arguments[1];
  	      var type = arguments[2] === undefined ? {} : arguments[2];
  	
  	      angular.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;
  	    }
  	  }
  	
  	  // link function
  	  function fieldLink(scope, el) {
  	    if (scope.options.fieldGroup) {
  	      setFieldGroupTemplate();
  	      return;
  	    }
  	
  	    addAttributes();
  	    addClasses();
  	
  	    var type = getFieldType(scope.options);
  	    var args = arguments;
  	    var thusly = this;
  	    getFieldTemplate(scope.options).then(runManipulators(formlyConfig.templateManipulators.preWrapper)).then(transcludeInWrappers(scope.options)).then(runManipulators(formlyConfig.templateManipulators.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(" ");
  	      }
  	      setElementTemplate("\n          <formly-form model=\"model\"\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        ");
  	    }
  	
  	    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 stopWatchingField = angular.noop;
  	      var stopWatchingShowError = angular.noop;
  	      if (scope.options.noFormControl) {
  	        return;
  	      }
  	      var templateEl = angular.element("<div>" + templateString + "</div>");
  	      var ngModelNode = templateEl[0].querySelector("[ng-model]");
  	      if (ngModelNode && ngModelNode.getAttribute("name")) {
  	        watchFieldNameOrExistence(ngModelNode.getAttribute("name"));
  	      }
  	
  	      function watchFieldNameOrExistence(name) {
  	        var nameExpressionRegex = /\{\{(.*?)}}/;
  	        var nameExpression = nameExpressionRegex.exec(name);
  	        if (nameExpression) {
  	          watchFieldName(nameExpression[1]);
  	        } else {
  	          watchFieldExistence(name);
  	        }
  	      }
  	
  	      function watchFieldName(expression) {
  	        scope.$watch(expression, function oneFieldNameChange(name) {
  	          if (name) {
  	            stopWatchingField();
  	            watchFieldExistence(name);
  	          }
  	        });
  	      }
  	
  	      function watchFieldExistence(name) {
  	        stopWatchingField = scope.$watch("form[\"" + name + "\"]", function formControlChange(formControl) {
  	          if (formControl) {
  	            scope.fc = formControl; // shortcut for template authors
  	            scope.options.formControl = formControl;
  	            stopWatchingShowError();
  	            addShowMessagesWatcher();
  	          }
  	        });
  	      }
  	
  	      function addShowMessagesWatcher() {
  	        stopWatchingShowError = scope.$watch(function watchShowValidationChange() {
  	          var customExpression = formlyConfig.extras.errorExistsAndShouldBeVisibleExpression;
  	          var options = scope.options;
  	          var fc = scope.fc;
  	
  	          if (!fc.$invalid) {
  	            return false;
  	          } else if (typeof options.validation.show === "boolean") {
  	            return options.validation.show;
  	          } else if (customExpression) {
  	            return formlyUtil.formlyEval(scope, customExpression, fc.$modelValue, fc.$viewValue);
  	          } else {
  	            var noTouchedButDirty = angular.isUndefined(fc.$touched) && fc.$dirty;
  	            return scope.fc.$touched || noTouchedButDirty;
  	          }
  	        }, function onShowValidationChange(show) {
  	          scope.options.validation.errorExistsAndShouldBeVisible = show;
  	          scope.showError = show; // shortcut for template authors
  	        });
  	      }
  	    }
  	
  	    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(template) {
  	        var chain = $q.when(template);
  	        angular.forEach(manipulators, function (manipulator) {
  	          chain = chain.then(function (template) {
  	            return $q.when(manipulator(template, scope.options, scope)).then(function (newTemplate) {
  	              return angular.isString(newTemplate) ? newTemplate : asHtml(newTemplate);
  	            });
  	          });
  	        });
  	        return chain;
  	      };
  	    }
  	  }
  	
  	  // stateless util functions
  	  function asHtml(el) {
  	    var wrapper = angular.element("<a></a>");
  	    return wrapper.append(el).html();
  	  }
  	
  	  function getFieldType(options) {
  	    return options.type && formlyConfig.getType(options.type);
  	  }
  	
  	  function getFieldTemplate(options) {
  	    function fromOptionsOrType(key, type) {
  	      if (angular.isDefined(options[key])) {
  	        return options[key];
  	      } else if (type && angular.isDefined(type[key])) {
  	        return type[key];
  	      }
  	    }
  	
  	    var type = formlyConfig.getType(options.type, true, options);
  	    var template = fromOptionsOrType("template", type);
  	    var templateUrl = fromOptionsOrType("templateUrl", type);
  	    if (angular.isUndefined(template) && !templateUrl) {
  	      throw formlyUsability.getFieldError("type-type-has-no-template", "Type '" + options.type + "' has not template. On element:", options);
  	    }
  	
  	    return getTemplate(templateUrl || template, angular.isUndefined(template), options);
  	  }
  	
  	  function getTemplate(template, isUrl, options) {
  	    var templatePromise = undefined;
  	    if (angular.isFunction(template)) {
  	      templatePromise = $q.when(template(options));
  	    } else {
  	      templatePromise = $q.when(template);
  	    }
  	
  	    if (!isUrl) {
  	      return templatePromise;
  	    } else {
  	      var _ret = (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 _ret === "object") {
  	        return _ret.v;
  	      }
  	    }
  	  }
  	
  	  function transcludeInWrappers(options) {
  	    var wrapper = getWrapperOption(options);
  	
  	    return function transcludeTemplate(template) {
  	      if (!wrapper.length) {
  	        return $q.when(template);
  	      }
  	
  	      wrapper.forEach(function (wrapper) {
  	        formlyUsability.checkWrapper(wrapper, options);
  	        wrapper.validateOptions && wrapper.validateOptions(options);
  	        runApiCheck(wrapper, 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 = angular.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) {
  	    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 this 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 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) {
  	      if (type.validateOptions) {
  	        type.validateOptions(options);
  	      }
  	      runApiCheck(type, options);
  	    }
  	  }
  	
  	  function checkFieldGroupApi(options) {
  	    formlyApiCheck["throw"](formlyApiCheck.fieldGroup, options, {
  	      prefix: "formly-field directive",
  	      url: "formly-field-directive-validation-failed"
  	    });
  	  }
  	
  	  function runApiCheck(_ref, options) {
  	    var apiCheck = _ref.apiCheck;
  	    var apiCheckInstance = _ref.apiCheckInstance;
  	    var apiCheckFunction = _ref.apiCheckFunction;
  	    var apiCheckOptions = _ref.apiCheckOptions;
  	
  	    if (!apiCheck) {
  	      return;
  	    }
  	    var instance = apiCheckInstance || formlyApiCheck;
  	    var fn = apiCheckFunction || "warn";
  	    var shape = instance.shape(apiCheck);
  	    instance[fn](shape, options, apiCheckOptions || {
  	      prefix: "formly-field " + name,
  	      url: formlyApiCheck.config.output.docsBaseUrl + "formly-field-type-apicheck-failed"
  	    });
  	  }
  	}
  	formlyField.$inject = ["$http", "$q", "$compile", "$templateCache", "formlyConfig", "formlyValidationMessages", "formlyApiCheck", "formlyUtil", "formlyUsability", "formlyWarn"];
  
  /***/ },
  /* 11 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	module.exports = formlyFocus;
  	
  	// @ngInject
  	function formlyFocus($timeout, $document) {
  	  /* jshint -W052 */
  	  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) {
  	        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();
  	            }
  	          }
  	        }
  	      });
  	    }
  	  };
  	}
  	formlyFocus.$inject = ["$timeout", "$document"];
  
  /***/ },
  /* 12 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
  	
  	var _toConsumableArray = function (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 _slice = Array.prototype.slice;
  	
  	var angular = _interopRequire(__webpack_require__(15));
  	
  	module.exports = formlyForm;
  	
  	/**
  	 * @ngdoc directive
  	 * @name formlyForm
  	 * @restrict E
  	 */
  	// @ngInject
  	function formlyForm(formlyUsability, $parse, formlyApiCheck, formlyConfig) {
  	  var currentFormId = 1;
  	  return {
  	    restrict: "E",
  	    template: function formlyFormGetTemplate(el, attrs) {
  	      /* jshint -W033 */ // this because jshint is broken I guess...
  	      var rootEl = getRootEl();
  	      var fieldRootEl = getFieldRootEl();
  	      var formId = "formly_" + currentFormId++;
  	      var parentFormAttributes = undefined;
  	      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               fields=\"fields\"\n               form=\"" + formId + "\"\n               form-id=\"" + formId + "\"\n               form-state=\"options.formState\"\n               index=\"$index\">\n          </" + fieldRootEl + ">\n          <div ng-transclude></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 (angular.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 = "{{::'formly_' + " + bindName + "}}";
  	        }
  	        return formName;
  	      }
  	
  	      function copyAttributes(attributes) {
  	        var excluded = ["model", "form", "fields", "options", "name", "role", "class"];
  	        var arrayAttrs = [];
  	        angular.forEach(attributes, function (_ref) {
  	          var nodeName = _ref.nodeName;
  	          var nodeValue = _ref.nodeValue;
  	
  	          if (nodeName !== "undefined" && excluded.indexOf(nodeName) === -1) {
  	            arrayAttrs.push("" + toKebabCase(nodeName) + "=\"" + nodeValue + "\"");
  	          }
  	        });
  	        return arrayAttrs.join(" ");
  	      }
  	
  	      function toKebabCase(string) {
  	        if (string) {
  	          return string.replace(/([A-Z])/g, function ($1) {
  	            return "-" + $1.toLowerCase();
  	          });
  	        } else {
  	          return "";
  	        }
  	      }
  	    },
  	    replace: true,
  	    transclude: true,
  	    scope: {
  	      fields: "=",
  	      model: "=",
  	      form: "=?",
  	      options: "=?"
  	    },
  	    controller: /* @ngInject */["$scope", "formlyUtil", function FormlyFormController($scope, formlyUtil) {
  	      setupOptions();
  	      $scope.model = $scope.model || {};
  	      $scope.fields = $scope.fields || [];
  	
  	      angular.forEach($scope.fields, attachKey); // attaches a key based on the index if a key isn't specified
  	      angular.forEach($scope.fields, setupWatchers); // setup watchers for all fields
  	
  	      // watch the model and evaluate watch expressions that depend on it.
  	      $scope.$watch("model", onModelOrFormStateChange, true);
  	      if ($scope.options.formState) {
  	        $scope.$watch("options.formState", onModelOrFormStateChange, true);
  	      }
  	
  	      function onModelOrFormStateChange() {
  	        angular.forEach($scope.fields, function runFieldExpressionProperties(field, index) {
  	          /*jshint -W030 */
  	          var model = field.model || $scope.model;
  	          field.runExpressions && field.runExpressions(model);
  	          if (field.hideExpression) {
  	            // can't use hide with expressionProperties reliably
  	            var val = model[field.key];
  	            // this makes it closer to what a regular expressionProperty would be
  	            var extraLocals = {
  	              options: field,
  	              index: index,
  	              formState: $scope.options.formState,
  	              formId: $scope.formId
  	            };
  	            field.hide = formlyUtil.formlyEval($scope, field.hideExpression, val, val, extraLocals);
  	          }
  	        });
  	      }
  	
  	      function setupOptions() {
  	        formlyApiCheck["throw"]([formlyApiCheck.formOptionsApi.optional], [$scope.options], { prefix: "formly-form options check" });
  	        $scope.options = $scope.options || {};
  	        $scope.options.formState = $scope.options.formState || {};
  	
  	        angular.extend($scope.options, {
  	          updateInitialValue: updateInitialValue,
  	          resetModel: resetModel
  	        });
  	      }
  	
  	      function updateInitialValue() {
  	        angular.forEach($scope.fields, function (field) {
  	          if (isFieldGroup(field)) {
  	            field.options.updateInitialValue();
  	          } else {
  	            field.updateInitialValue();
  	          }
  	        });
  	      }
  	
  	      function resetModel() {
  	        angular.forEach($scope.fields, function (field) {
  	          if (isFieldGroup(field)) {
  	            field.options.resetModel();
  	          } else {
  	            field.resetModel();
  	          }
  	        });
  	      }
  	
  	      function attachKey(field, index) {
  	        if (!isFieldGroup(field)) {
  	          field.key = field.key || index || 0;
  	        }
  	      }
  	
  	      function setupWatchers(field, index) {
  	        if (isFieldGroup(field) || !angular.isDefined(field.watcher)) {
  	          return;
  	        }
  	        var watchers = field.watcher;
  	        if (!angular.isArray(watchers)) {
  	          watchers = [watchers];
  	        }
  	        angular.forEach(watchers, function setupWatcher(watcher) {
  	          if (!angular.isDefined(watcher.listener)) {
  	            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 = watcher.expression || "model['" + field.key + "']";
  	        if (angular.isFunction(watchExpression)) {
  	          // 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;
  	        }
  	        return watchExpression;
  	      }
  	
  	      function getWatchListener(watcher, field, index) {
  	        var watchListener = watcher.listener;
  	        if (angular.isFunction(watchListener)) {
  	          // 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 args = modifyArgs.apply(undefined, [watcher, index].concat(_slice.call(arguments)));
  	            return originalListener.apply(undefined, _toConsumableArray(args));
  	          };
  	          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 isFieldGroup(field) {
  	        return field && !!field.fieldGroup;
  	      }
  	    }],
  	    link: function link(scope, el, attrs) {
  	      if (attrs.form) {
  	        var formId = attrs.name;
  	        scope.formId = formId;
  	        $parse(attrs.form).assign(scope.$parent, scope[formId]);
  	      }
  	
  	      // chrome autocomplete lameness
  	      // see https://code.google.com/p/chromium/issues/detail?id=468153#c14
  	      // ლ(ಠ益ಠლ)   (╯°□°)╯︵ ┻━┻    (◞‸◟；)
  	      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);
  	      }
  	    }
  	  };
  	}
  	formlyForm.$inject = ["formlyUsability", "$parse", "formlyApiCheck", "formlyConfig"];
  
  /***/ },
  /* 13 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
  	
  	var angular = _interopRequire(__webpack_require__(15));
  	
  	module.exports = addFormlyNgModelAttrsManipulator;
  	
  	// @ngInject
  	function addFormlyNgModelAttrsManipulator(formlyConfig) {
  	  if (formlyConfig.extras.disableNgModelAttrsManipulator) {
  	    return;
  	  }
  	  formlyConfig.templateManipulators.preWrapper.push(ngModelAttrsManipulator);
  	
  	  function ngModelAttrsManipulator(template, options, scope) {
  	    /* jshint maxcomplexity:6 */
  	    var el = document.createElement("div");
  	    var data = options.data;
  	    if (data.skipNgModelAttrsManipulator === true) {
  	      return template;
  	    }
  	    el.innerHTML = template;
  	    var modelNodes = el.querySelectorAll("[ng-model]");
  	    if (!modelNodes || !modelNodes.length) {
  	      return template;
  	    }
  	
  	    addIfNotPresent(modelNodes, "id", scope.id);
  	    addIfNotPresent(modelNodes, "name", scope.id);
  	
  	    addValidation();
  	    addModelOptions();
  	    addTemplateOptionsAttrs();
  	
  	    return el.innerHTML;
  	
  	    function addValidation() {
  	      if (angular.isDefined(options.validators) || angular.isDefined(options.validation.messages)) {
  	        addIfNotPresent(modelNodes, "formly-custom-validation", "");
  	      }
  	    }
  	
  	    function addModelOptions() {
  	      if (angular.isDefined(options.modelOptions)) {
  	        addIfNotPresent(modelNodes, "ng-model-options", "options.modelOptions");
  	        if (options.modelOptions.getterSetter) {
  	          angular.forEach(modelNodes, function (node) {
  	            node.setAttribute("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
  	      angular.extend(ngModelAttributes, options.ngModelAttrs);
  	
  	      // Feel free to make this more simple :-)
  	      angular.forEach(ngModelAttributes, function (val, name) {
  	        /* jshint maxcomplexity:14 */
  	        var attrVal = undefined;
  	        var attrName = undefined;
  	        var ref = "options.templateOptions['" + name + "']";
  	        var toVal = to[name];
  	        var epVal = getEpValue(ep, name);
  	
  	        var inTo = angular.isDefined(toVal);
  	        var inEp = angular.isDefined(epVal);
  	        if (val.value) {
  	          // I realize this looks backwards, but it's right, trust me...
  	          attrName = val.value;
  	          attrVal = name;
  	        } else if (val.expression && inTo) {
  	          attrName = val.expression;
  	          if (angular.isString(to[name])) {
  	            attrVal = "$eval(" + ref + ")";
  	          } else if (angular.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 = "{{" + ref + "}}";
  	        } else if (val.attribute && inTo) {
  	          attrName = val.attribute;
  	          attrVal = toVal;
  	        } else if (val.boolean) {
  	          if (inTo && !inEp && toVal) {
  	            attrName = val.boolean;
  	            attrVal = true;
  	          } else {}
  	        } else if (val.bound && inTo) {
  	          attrName = val.bound;
  	          attrVal = ref;
  	        }
  	
  	        if (angular.isDefined(attrName) && angular.isDefined(attrVal)) {
  	          addIfNotPresent(modelNodes, attrName, attrVal);
  	        }
  	      });
  	    }
  	  }
  	
  	  // Utility functions
  	  function getBuiltInAttributes() {
  	    var ngModelAttributes = {
  	      focus: {
  	        attribute: "formly-focus"
  	      }
  	    };
  	    var boundOnly = [];
  	    var bothBooleanAndBound = ["required", "disabled"];
  	    var bothAttributeAndBound = ["pattern", "minlength"];
  	    var expressionOnly = ["change", "keydown", "keyup", "keypress", "click", "focus", "blur"];
  	    var attributeOnly = ["placeholder", "min", "max", "tabindex", "type"];
  	    if (formlyConfig.extras.ngModelAttrsManipulatorPreferUnbound) {
  	      bothAttributeAndBound.push("maxlength");
  	    } else {
  	      boundOnly.push("maxlength");
  	    }
  	
  	    angular.forEach(boundOnly, function (item) {
  	      ngModelAttributes[item] = { bound: "ng-" + item };
  	    });
  	
  	    angular.forEach(bothBooleanAndBound, function (item) {
  	      ngModelAttributes[item] = { boolean: item, bound: "ng-" + item };
  	    });
  	
  	    angular.forEach(bothAttributeAndBound, function (item) {
  	      ngModelAttributes[item] = { attribute: item, bound: "ng-" + item };
  	    });
  	
  	    angular.forEach(expressionOnly, function (item) {
  	      var propName = "on" + item.substr(0, 1).toUpperCase() + item.substr(1);
  	      ngModelAttributes[propName] = { expression: "ng-" + item };
  	    });
  	
  	    angular.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) {
  	    angular.forEach(nodes, function (node) {
  	      if (!node.getAttribute(attr)) {
  	        node.setAttribute(attr, val);
  	      }
  	    });
  	  }
  	}
  	addFormlyNgModelAttrsManipulator.$inject = ["formlyConfig"];
  
  	// jshint -W035
  	// 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
  
  /***/ },
  /* 14 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	module.exports = addCustomTags;
  	
  	// @ngInject
  	function addCustomTags($document) {
  	  if ($document && $document.get) {
  	    (function () {
  	      //IE8 check ->
  	      // http://stackoverflow.com/questions/10964966/detect-ie-version-prior-to-v9-in-javascript/10965203#10965203
  	      var document = $document.get(0);
  	      var div = document.createElement("div");
  	      div.innerHTML = "<!--[if lt IE 9]><i></i><![endif]-->";
  	      var isIeLessThan9 = div.getElementsByTagName("i").length === 1;
  	
  	      if (isIeLessThan9) {
  	        //add the custom elements that we need for formly
  	        var customElements = ["formly-field", "formly-form", "formly-custom-validation", "formly-focus", "formly-transpose"];
  	        angular.forEach(customElements, function (el) {
  	          document.createElement(el);
  	        });
  	      }
  	    })();
  	  }
  	}
  	addCustomTags.$inject = ["$document"];
  
  /***/ },
  /* 15 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
  	
  	// some versions of angular don't export the angular module properly,
  	// so we get it from window in this case.
  	
  	var angular = _interopRequire(__webpack_require__(17));
  	
  	if (!angular.version) {
  	  angular = window.angular;
  	}
  	module.exports = angular;
  
  /***/ },
  /* 16 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = __WEBPACK_EXTERNAL_MODULE_16__;
  
  /***/ },
  /* 17 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = __WEBPACK_EXTERNAL_MODULE_17__;
  
  /***/ },
  /* 18 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	var _interopRequire = function (obj) { return obj && obj.__esModule ? obj["default"] : obj; };
  	
  	var angular = _interopRequire(__webpack_require__(15));
  	
  	module.exports = { formlyEval: formlyEval, getFieldId: getFieldId, reverseDeepMerge: reverseDeepMerge, findByNodeName: findByNodeName, arrayify: arrayify, extendFunction: extendFunction };
  	
  	function formlyEval(scope, expression, $modelValue, $viewValue, extraLocals) {
  	  if (angular.isFunction(expression)) {
  	    return expression($viewValue, $modelValue, scope, extraLocals);
  	  } else {
  	    return scope.$eval(expression, angular.extend({ $viewValue: $viewValue, $modelValue: $modelValue }, extraLocals));
  	  }
  	}
  	
  	function getFieldId(formId, options, index) {
  	  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) {
  	  angular.forEach(arguments, function (src, index) {
  	    if (!index) {
  	      return;
  	    }
  	    angular.forEach(src, function (val, prop) {
  	      if (!angular.isDefined(dest[prop])) {
  	        dest[prop] = angular.copy(val);
  	      } else if (objAndSameType(dest[prop], val)) {
  	        reverseDeepMerge(dest[prop], val);
  	      }
  	    });
  	  });
  	}
  	
  	function objAndSameType(obj1, obj2) {
  	  return angular.isObject(obj1) && angular.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 = angular.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 && !angular.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);
  	    });
  	  };
  	}
  
  /***/ }
  /******/ ])
  });
  ;
  //# sourceMappingURL=formly.js.map