vui-design/dist/vui-design.js

A high quality UI Toolkit based on Vue.js

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory(require("vue"));
	else if(typeof define === 'function' && define.amd)
		define("vui-design", ["vue"], factory);
	else if(typeof exports === 'object')
		exports["vui-design"] = factory(require("vue"));
	else
		root["vui-design"] = factory(root["Vue"]);
})(typeof self !== 'undefined' ? self : this, function(__WEBPACK_EXTERNAL_MODULE_14__) {
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] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = 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;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "/dist/";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 87);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_object_keys__ = __webpack_require__(12);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_object_keys___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_object_keys__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_typeof__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_typeof___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_typeof__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_core_js_number_is_integer__ = __webpack_require__(116);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_core_js_number_is_integer___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_core_js_number_is_integer__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_core_js_object_get_prototype_of__ = __webpack_require__(25);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_core_js_object_get_prototype_of___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_core_js_object_get_prototype_of__);




var env = process && process.env && 'production';

var funProto = Function.prototype;
var objProto = Object.prototype;
var getPrototypeOf = __WEBPACK_IMPORTED_MODULE_3_babel_runtime_core_js_object_get_prototype_of___default.a;
var objToString = objProto.toString;
var hasOwnProperty = objProto.hasOwnProperty;
var funToString = funProto.toString;

var noop = function noop() {};
var has = function has(object, property) {
  return hasOwnProperty.call(object, property);
};

var isInteger = __WEBPACK_IMPORTED_MODULE_2_babel_runtime_core_js_number_is_integer___default.a || function (value) {
  return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
};
var isFunction = function isFunction(value) {
  return objToString.call(value) === "[object Function]" || typeof value === "function";
};
var isElement = function isElement(value) {
  return value && value instanceof window.Node && value.nodeType === 1;
};
var isDate = function isDate(value) {
  return objToString.call(value) === "[object Date]";
};
var isArray = Array.isArray || function (value) {
  return objToString.call(value) === "[object Array]";
};
var isPlainObject = function isPlainObject(value) {
  if (!value || objToString.call(value) !== "[object Object]") {
    return false;
  }

  var prototype = getPrototypeOf(value);

  if (prototype === null) {
    return true;
  }

  var constructor = has(prototype, "constructor") && prototype.constructor;

  return typeof constructor === "function" && funToString.call(constructor) === funToString.call(Object);
};

var warn = void 0;

if (env === "production") {
  warn = noop;
} else {
  var hasConsole = typeof console !== "undefined";

  warn = typeof console === "undefined" ? noop : function (message) {
    return console.warn("[VuePropTypes warn]: " + message);
  };
}

var getType = function getType(fn) {
  var type = fn !== null && fn !== undefined ? fn.type ? fn.type : fn : null;
  var match = type && type.toString().match(/^\s*function (\w+)/);

  return match && match[1];
};

var getNativeType = function getNativeType(value) {
  if (value === null || value === undefined) {
    return null;
  }

  var match = value.constructor.toString().match(/^\s*function (\w+)/);

  return match && match[1];
};

var withRequired = function withRequired(type) {
  Object.defineProperty(type, "isRequired", {
    enumerable: false,
    get: function get() {
      this.required = true;

      return this;
    }
  });
};

var withDefault = function withDefault(type) {
  Object.defineProperty(type, "def", {
    enumerable: false,
    writable: false,
    value: function value(def) {
      if (def === undefined && this.default === undefined) {
        this.default = undefined;
        return this;
      }

      if (!isFunction(def) && !validateType(this, def)) {
        warn(this.vuePropTypesName + " - invalid default value: " + def, def);

        return this;
      }

      this.default = isArray(def) || isPlainObject(def) ? function () {
        return def;
      } : def;

      return this;
    }
  });
};

var toType = function toType(name, object) {
  Object.defineProperty(object, "vuePropTypesName", {
    enumerable: false,
    writable: false,
    value: name
  });

  withRequired(object);
  withDefault(object);

  if (isFunction(object.validator)) {
    object.validator = object.validator.bind(object);
  }

  return object;
};

var validateType = function validateType(type, value) {
  var silent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

  var typeToCheck = type;
  var boolean = true;
  var expectedType = void 0;

  if (!isPlainObject(type)) {
    typeToCheck = {
      type: type
    };
  }

  var namePrefix = typeToCheck.vuePropTypesName ? typeToCheck.vuePropTypesName + " - " : "";

  if (has(typeToCheck, "type") && typeToCheck.type !== null) {
    if (isArray(typeToCheck.type)) {
      boolean = typeToCheck.type.some(function (type) {
        return validateType(type, value, true);
      });
      expectedType = typeToCheck.type.map(function (type) {
        return getType(type);
      }).join(" or ");
    } else {
      expectedType = getType(typeToCheck);

      if (expectedType === "element") {
        boolean = isElement(value);
      } else if (expectedType === "Date") {
        boolean = isDate(value);
      } else if (expectedType === "Array") {
        boolean = isArray(value);
      } else if (expectedType === "Object") {
        boolean = isPlainObject(value);
      } else if (expectedType === "Boolean" || expectedType === "String" || expectedType === "Number" || expectedType === "Function") {
        boolean = getNativeType(value) === expectedType;
      } else {
        boolean = value instanceof typeToCheck.type;
      }
    }
  }

  if (!boolean) {
    silent === false && warn(namePrefix + "value " + value + " should be of type " + expectedType);

    return false;
  }

  if (has(typeToCheck, "validator") && isFunction(typeToCheck.validator)) {
    boolean = typeToCheck.validator(value);

    if (!boolean && silent === false) {
      warn(namePrefix + "custom validation failed");
    }

    return boolean;
  }

  return boolean;
};

var VuePropTypes = {
  get any() {
    return toType("any", {
      type: null
    });
  },

  get bool() {
    return toType("boolean", {
      type: Boolean
    }).def(defaults.bool);
  },

  get string() {
    return toType("string", {
      type: String
    }).def(defaults.string);
  },

  get number() {
    return toType("number", {
      type: Number
    }).def(defaults.number);
  },

  get integer() {
    return toType("integer", {
      type: Number,
      validator: function validator(value) {
        return isInteger(value);
      }
    }).def(defaults.integer);
  },

  get func() {
    return toType("function", {
      type: Function
    }).def(defaults.func);
  },

  get element() {
    return toType("element", {
      type: HTMLElement
    }).def(defaults.element);
  },

  get date() {
    return toType("date", {
      type: Date
    }).def(defaults.date);
  },

  get array() {
    return toType("array", {
      type: Array
    }).def(defaults.array);
  },

  get object() {
    return toType("object", {
      type: Object
    }).def(defaults.object);
  },

  get symbol() {
    return toType("symbol", {
      type: null,
      validator: function validator(value) {
        return (typeof value === "undefined" ? "undefined" : __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_typeof___default()(value)) === "symbol";
      }
    });
  },

  custom: function custom(_validator) {
    var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "custom validation failed";

    if (!isFunction(_validator)) {
      throw new TypeError("[VuePropTypes error]: You must provide a function as argument");
    }

    return toType(_validator.name || "<<anonymous function>>", {
      validator: function validator() {
        var boolean = _validator.apply(undefined, arguments);

        if (!boolean) {
          warn(this.vuePropTypesName + " - " + message);
        }

        return boolean;
      }
    });
  },
  oneOf: function oneOf(array) {
    if (!isArray(array)) {
      throw new TypeError("[VuePropTypes error]: You must provide an array as argument");
    }

    var message = "oneOf - value should be one of [" + array.join(", ") + "]";
    var allowedTypes = array.reduce(function (result, value) {
      if (value !== null && value !== undefined) {
        result.indexOf(value.constructor) === -1 && result.push(value.constructor);
      }

      return result;
    }, []);

    return toType("oneOf", {
      type: allowedTypes.length > 0 ? allowedTypes : null,
      validator: function validator(value) {
        var boolean = array.indexOf(value) !== -1;

        if (!boolean) {
          warn(message);
        }

        return boolean;
      }
    });
  },
  instanceOf: function instanceOf(Constructor) {
    return toType("instanceOf", {
      type: Constructor
    });
  },
  oneOfType: function oneOfType(array) {
    if (!isArray(array)) {
      throw new TypeError("[VuePropTypes error]: You must provide an array as argument");
    }

    var hasCustomValidators = false;

    var checks = array.reduce(function (result, type) {
      if (isPlainObject(type)) {
        if (type.vuePropTypesName === "oneOf") {
          return result.concat(type.type || []);
        }

        if (type.type && !isFunction(type.validator)) {
          if (isArray(type.type)) {
            return result.concat(type.type);
          }

          result.push(type.type);
        } else if (isFunction(type.validator)) {
          hasCustomValidators = true;
        }

        return result;
      }

      result.push(type);

      return result;
    }, []);

    if (!hasCustomValidators) {
      return toType("oneOfType", {
        type: checks
      }).def(undefined);
    }

    var class2types = array.map(function (type) {
      if (type && isArray(type.type)) {
        return type.type.map(getType);
      }

      return getType(type);
    }).reduce(function (result, type) {
      return result.concat(isArray(type) ? type : [type]);
    }, []).join(", ");

    return this.custom(function oneOfType(value) {
      var boolean = array.some(function (type) {
        if (type.vuePropTypesName === "oneOf") {
          return type.type ? validateType(type.type, value, true) : true;
        }

        return validateType(type, value, true);
      });

      if (!boolean) {
        warn("oneOfType - value type should be one of [" + class2types + "]");
      }

      return boolean;
    }).def(undefined);
  },
  arrayOf: function arrayOf(type) {
    return toType("arrayOf", {
      type: Array,
      validator: function validator(array) {
        var boolean = array.every(function (value) {
          return validateType(type, value);
        });

        if (!boolean) {
          warn("arrayOf - value must be an array of " + getType(type));
        }

        return boolean;
      }
    });
  },
  objectOf: function objectOf(type) {
    return toType("objectOf", {
      type: Object,
      validator: function validator(object) {
        var boolean = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_object_keys___default()(object).every(function (key) {
          return validateType(type, object[key]);
        });

        if (!boolean) {
          warn("objectOf - value must be an object of " + getType(type));
        }

        return boolean;
      }
    });
  },
  shape: function shape(object) {
    var keys = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_object_keys___default()(object);
    var requiredKeys = keys.filter(function (key) {
      return object[key] && object[key].required === true;
    });
    var type = toType("shape", {
      type: Object,
      validator: function validator(value) {
        var _this = this;

        if (!isPlainObject(value)) {
          return false;
        }

        var valueKeys = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_object_keys___default()(value);

        if (requiredKeys.length > 0 && requiredKeys.some(function (requiredKey) {
          return valueKeys.indexOf(requiredKey) === -1;
        })) {
          warn("shape - at least one of required properties [" + requiredKeys.join(", ") + "] is not present");

          return false;
        }

        return valueKeys.every(function (key) {
          if (keys.indexOf(key) === -1) {
            if (_this.vuePropTypesIsLoose === true) {
              return true;
            }

            warn("shape - object is missing " + key + " property");

            return false;
          }

          var type = object[key];

          return validateType(type, value[key]);
        });
      }
    });

    Object.defineProperty(type, "vuePropTypesIsLoose", {
      enumerable: false,
      writable: true,
      value: false
    });

    Object.defineProperty(type, "loose", {
      enumerable: false,
      get: function get() {
        this.vuePropTypesIsLoose = true;

        return this;
      }
    });

    return type;
  }
};

var createDefaultTypes = function createDefaultTypes() {
  return {
    bool: undefined,
    string: undefined,
    number: undefined,
    integer: undefined,
    func: undefined,
    element: undefined,
    date: undefined,
    array: undefined,
    object: undefined
  };
};

var defaults = createDefaultTypes();

Object.defineProperty(VuePropTypes, "sensibleDefaults", {
  enumerable: false,
  set: function set(value) {
    if (value === false) {
      defaults = {};
    } else if (value === true) {
      defaults = createDefaultTypes();
    } else if (isPlainObject(value)) {
      defaults = value;
    }
  },
  get: function get() {
    return defaults;
  }
});

/* harmony default export */ __webpack_exports__["a"] = (VuePropTypes);
/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(56)))

/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


exports.__esModule = true;

var _defineProperty = __webpack_require__(74);

var _defineProperty2 = _interopRequireDefault(_defineProperty);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = function (obj, key, value) {
  if (key in obj) {
    (0, _defineProperty2.default)(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
};

/***/ }),
/* 2 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* unused harmony export isServer */
/* unused harmony export isVNode */
/* unused harmony export isUndefined */
/* unused harmony export isNull */
/* unused harmony export isNaN */
/* unused harmony export isNumber */
/* unused harmony export isInteger */
/* unused harmony export isDecimal */
/* unused harmony export isNegative */
/* unused harmony export isPositive */
/* unused harmony export isFinite */
/* unused harmony export isInfinite */
/* unused harmony export isString */
/* unused harmony export isChar */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return isBoolean; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return isFunction; });
/* unused harmony export isRegExp */
/* unused harmony export isDate */
/* unused harmony export isArguments */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return isArray; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return isObject; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return isPlainObject; });
/* unused harmony export isPromise */
/* unused harmony export isElement */
/* unused harmony export isError */
/* unused harmony export isEmpty */
/* unused harmony export isExisty */
/* unused harmony export isFalsy */
/* unused harmony export isTruthy */
/* unused harmony export isEffective */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return isMergeableObject; });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_typeof__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_typeof___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_typeof__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_symbol_for__ = __webpack_require__(106);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_symbol_for___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_symbol_for__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_core_js_symbol__ = __webpack_require__(68);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_core_js_symbol___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_core_js_symbol__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_core_js_object_get_own_property_names__ = __webpack_require__(73);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_core_js_object_get_own_property_names___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_core_js_object_get_own_property_names__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_core_js_object_get_prototype_of__ = __webpack_require__(25);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_core_js_object_get_prototype_of___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_core_js_object_get_prototype_of__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_vue__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_vue___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_vue__);







var funProto = Function.prototype;
var objProto = Object.prototype;

var getPrototypeOf = __WEBPACK_IMPORTED_MODULE_4_babel_runtime_core_js_object_get_prototype_of___default.a;
var getOwnPropertyNames = __WEBPACK_IMPORTED_MODULE_3_babel_runtime_core_js_object_get_own_property_names___default.a;

var objToString = objProto.toString;
var hasOwnProperty = objProto.hasOwnProperty;
var funToString = funProto.toString;

var canUseSymbol = typeof __WEBPACK_IMPORTED_MODULE_2_babel_runtime_core_js_symbol___default.a === "function" && __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_symbol_for___default.a;
var reactElementType = canUseSymbol ? __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_symbol_for___default()("react.element") : 0xeac7;

// 检查是否运行于服务器端
var isServer = __WEBPACK_IMPORTED_MODULE_5_vue___default.a.prototype.$isServer;

// 检查给定的值是否是 VNode
var isVNode = function isVNode(node) {
  return node !== null && (typeof node === "undefined" ? "undefined" : __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_typeof___default()(node)) === "object" && hasOwnProperty.call(node, "componentOptions");
};

// 检查给定的值是否是 undefined
var isUndefined = function isUndefined(value) {
  return value === void 0;
};

// 检查给定的值是否是 null
var isNull = function isNull(value) {
  return value === null;
};

// 检查给定的值是否是 NaN
// 这和原生的 isNaN 函数不一样，如果变量是 undefined，原生的 isNaN 函数也会返回 true
var isNaN = function isNaN(value) {
  return window.isNaN(value) && value !== value;
};

// 检查给定的值是否是数值
var isNumber = function isNumber(value) {
  return objToString.call(value) === "[object Number]" && !isNaN(value);
};

// 检查给定的值是否是整数
var isInteger = function isInteger(value) {
  return isNumber(value) && value % 1 === 0;
};

// 检查给定的值是否是小数
var isDecimal = function isDecimal(value) {
  return isNumber(value) && value % 1 !== 0;
};

// 检查给定的值是否是负数
var isNegative = function isNegative(value) {
  return isNumber(value) && value < 0;
};

// 检查给定的值是否是正数
var isPositive = function isPositive(value) {
  return isNumber(value) && value > 0;
};

// 检查给定的值是否是有限数
var isFinite = window.isFinite || function (value) {
  return !isInfinite(value) && !isNaN(value);
};

// 检查给定的值是否是无限数
var isInfinite = function isInfinite(value) {
  return value === Infinity || value === -Infinity;
};

// 检查给定的值是否是字符串
var isString = function isString(value) {
  return objToString.call(value) === "[object String]";
};

// 检查给定的值是否是 Char 字符
var isChar = function isChar(value) {
  return isString(value) && value.length === 1;
};

// 检查给定的值是否是布尔值
var isBoolean = function isBoolean(value) {
  return value === true || value === false || objToString.call(value) === "[object Boolean]";
};

// 检查给定的值是否是函数
var isFunction = function isFunction(value) {
  return objToString.call(value) === "[object Function]" || typeof value === "function";
};

// 检查给定的值是否是正则表达式
var isRegExp = function isRegExp(value) {
  return objToString.call(value) === "[object RegExp]";
};

// 检查给定的值是否是日期对象
var isDate = function isDate(value) {
  return objToString.call(value) === "[object Date]";
};

// 检查给定的值是否是参数对象
var isArguments = function isArguments(value) {
  return objToString.call(value) === "[object Arguments]" || isObject(value) && "callee" in value;
};

// 检查给定的值是否是数组
var isArray = Array.isArray || function (value) {
  return objToString.call(value) === "[object Array]";
};

// 检查给定的值是否是对象
var isObject = function isObject(value) {
  return !!value && (typeof value === "undefined" ? "undefined" : __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_typeof___default()(value)) === "object";
};

// 检查给定的值是否是纯对象，纯对象是指通过 {} 或 new Object() 声明的对象
var isPlainObject = function isPlainObject(value) {
  if (!value || objToString.call(value) !== "[object Object]") {
    return false;
  }

  var prototype = getPrototypeOf(value);

  if (prototype === null) {
    return true;
  }

  var constructor = hasOwnProperty.call(prototype, "constructor") && prototype.constructor;

  return typeof constructor === "function" && funToString.call(constructor) === funToString.call(Object);
};

// 检查给定的值是否是 Promise 对象
function isPromise(value) {
  return objToString.call(value) === "[object Promise]";
};

// 检查给定的值是否是 HTMLElement 元素
var isElement = function isElement(value) {
  return value && value instanceof window.Node && value.nodeType === 1;
};

// 检查给定的值是否是错误元素
var isError = function isError(value) {
  return objToString.call(value) === "[object Error]";
};

// 检查给定的值是否为空，可用于判断参数列表、数组、对象或字符串是否为空
var isEmpty = function isEmpty(value) {
  if (isObject(value)) {
    var length = getOwnPropertyNames(value).length;

    if (length === 0 || length === 1 && isArray(value) || length === 2 && isArguments(value)) {
      return true;
    }

    return false;
  }

  return value === "";
};

// 检查给定的值是否存在
var isExisty = function isExisty(value) {
  return value != null;
};

// 检查给定的值是否为假值
var isFalsy = function isFalsy(value) {
  return !value;
};

// 检查给定的值是否为真值
var isTruthy = function isTruthy(value) {
  return !isFalsy(value);
};

// 
function isEffective(value) {
  return value !== null && value !== undefined && value !== "";
};

// 检查给定的值是否可以用于合并
var isMergeableObject = function isMergeableObject(value) {
  return isObject(value) && !(isRegExp(value) || isDate(value) || isReactElement(value));
};

// 
/* harmony default export */ __webpack_exports__["a"] = ({
  server: isServer,
  vnode: isVNode,
  undefined: isUndefined,
  null: isNull,
  nan: isNaN,
  number: isNumber,
  integer: isInteger,
  decimal: isDecimal,
  negative: isNegative,
  positive: isPositive,
  finite: isFinite,
  infinite: isInfinite,
  string: isString,
  char: isChar,
  boolean: isBoolean,
  function: isFunction,
  regexp: isRegExp,
  date: isDate,
  arguments: isArguments,
  array: isArray,
  object: isObject,
  plainObject: isPlainObject,
  json: isPlainObject,
  promise: isPromise,
  element: isElement,
  error: isError,
  empty: isEmpty,
  existy: isExisty,
  falsy: isFalsy,
  truthy: isTruthy,
  effective: isEffective,
  mergeableObject: isMergeableObject
});

/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


exports.__esModule = true;

var _assign = __webpack_require__(110);

var _assign2 = _interopRequireDefault(_assign);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = _assign2.default || function (target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i];

    for (var key in source) {
      if (Object.prototype.hasOwnProperty.call(source, key)) {
        target[key] = source[key];
      }
    }
  }

  return target;
};

/***/ }),
/* 4 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Buffer) {/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_object_get_own_property_names__ = __webpack_require__(73);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_object_get_own_property_names___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_object_get_own_property_names__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_object_define_property__ = __webpack_require__(74);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_object_define_property___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_object_define_property__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_core_js_object_get_own_property_symbols__ = __webpack_require__(147);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_core_js_object_get_own_property_symbols___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_core_js_object_get_own_property_symbols__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_core_js_object_get_own_property_descriptor__ = __webpack_require__(149);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_core_js_object_get_own_property_descriptor___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_core_js_object_get_own_property_descriptor__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_core_js_object_get_prototype_of__ = __webpack_require__(25);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_core_js_object_get_prototype_of___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_core_js_object_get_prototype_of__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_core_js_object_create__ = __webpack_require__(152);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_core_js_object_create___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_core_js_object_create__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_typeof__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_typeof___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_typeof__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__is__ = __webpack_require__(2);









function isInstanceOf(value, type) {
  return type != null && value instanceof type;
}

function getRegExpFlags(value) {
  var flags = "";

  if (value.global) {
    flags += "g";
  }

  if (value.ignoreCase) {
    flags += "i";
  }

  if (value.multiline) {
    flags += "m";
  }

  return flags;
}

var Map = window.Map || function () {};
var Set = window.Set || function () {};
var Promise = window.Promise || function () {};

function clone(parent, circular, depth, prototype, includeNonEnumerable) {
  if ((typeof circular === "undefined" ? "undefined" : __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_typeof___default()(circular)) === "object") {
    circular = circular.circular;
    depth = circular.depth;
    prototype = circular.prototype;
    includeNonEnumerable = circular.includeNonEnumerable;
  }

  var allParents = [];
  var allChildren = [];
  var useBuffer = typeof Buffer != "undefined";

  if (typeof circular == "undefined") {
    circular = true;
  }

  if (typeof depth == "undefined") {
    depth = Infinity;
  }

  function copy(parent, depth) {
    if (parent === null) {
      return null;
    }

    if (depth === 0) {
      return parent;
    }

    var proto;
    var child;

    if ((typeof parent === "undefined" ? "undefined" : __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_typeof___default()(parent)) != "object") {
      return parent;
    }

    if (isInstanceOf(parent, Map)) {
      child = new Map();
    } else if (isInstanceOf(parent, Set)) {
      child = new Set();
    } else if (isInstanceOf(parent, Promise)) {
      child = new Promise(function (resolve, reject) {
        parent.then(function (value) {
          resolve(copy(value, depth - 1));
        }, function (error) {
          reject(copy(error, depth - 1));
        });
      });
    } else if (__WEBPACK_IMPORTED_MODULE_7__is__["a" /* default */].array(parent)) {
      child = [];
    } else if (__WEBPACK_IMPORTED_MODULE_7__is__["a" /* default */].regexp(parent)) {
      child = new RegExp(parent.source, getRegExpFlags(parent));

      if (parent.lastIndex) {
        child.lastIndex = parent.lastIndex;
      }
    } else if (__WEBPACK_IMPORTED_MODULE_7__is__["a" /* default */].date(parent)) {
      child = new Date(parent.getTime());
    } else if (useBuffer && Buffer.isBuffer(parent)) {
      if (Buffer.from) {
        child = Buffer.from(parent);
      } else {
        child = new Buffer(parent.length);
        parent.copy(child);
      }

      return child;
    } else if (isInstanceOf(parent, Error)) {
      child = __WEBPACK_IMPORTED_MODULE_5_babel_runtime_core_js_object_create___default()(parent);
    } else {
      if (typeof prototype == "undefined") {
        proto = __WEBPACK_IMPORTED_MODULE_4_babel_runtime_core_js_object_get_prototype_of___default()(parent);
      } else {
        proto = prototype;
      }

      child = __WEBPACK_IMPORTED_MODULE_5_babel_runtime_core_js_object_create___default()(proto);
    }

    if (circular) {
      var index = allParents.indexOf(parent);

      if (index != -1) {
        return allChildren[index];
      }

      allParents.push(parent);
      allChildren.push(child);
    }

    if (isInstanceOf(parent, Map)) {
      parent.forEach(function (value, key) {
        var newKey = copy(key, depth - 1);
        var newValue = copy(value, depth - 1);

        child.set(newKey, newValue);
      });
    }

    if (isInstanceOf(parent, Set)) {
      parent.forEach(function (value) {
        var entry = copy(value, depth - 1);

        child.add(entry);
      });
    }

    for (var i in parent) {
      var attrs = __WEBPACK_IMPORTED_MODULE_3_babel_runtime_core_js_object_get_own_property_descriptor___default()(parent, i);

      if (attrs) {
        child[i] = copy(parent[i], depth - 1);
      }

      try {
        var objProperty = __WEBPACK_IMPORTED_MODULE_3_babel_runtime_core_js_object_get_own_property_descriptor___default()(parent, i);

        if (objProperty.set === "undefined") {
          continue;
        }

        child[i] = copy(parent[i], depth - 1);
      } catch (e) {
        if (e instanceof TypeError) {
          continue;
        } else if (e instanceof ReferenceError) {
          continue;
        }
      }
    }

    if (__WEBPACK_IMPORTED_MODULE_2_babel_runtime_core_js_object_get_own_property_symbols___default.a) {
      var symbols = __WEBPACK_IMPORTED_MODULE_2_babel_runtime_core_js_object_get_own_property_symbols___default()(parent);

      for (var i = 0; i < symbols.length; i++) {
        var symbol = symbols[i];
        var descriptor = __WEBPACK_IMPORTED_MODULE_3_babel_runtime_core_js_object_get_own_property_descriptor___default()(parent, symbol);

        if (descriptor && !descriptor.enumerable && !includeNonEnumerable) {
          continue;
        }

        child[symbol] = copy(parent[symbol], depth - 1);

        __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_object_define_property___default()(child, symbol, descriptor);
      }
    }

    if (includeNonEnumerable) {
      var allPropertyNames = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_object_get_own_property_names___default()(parent);

      for (var i = 0; i < allPropertyNames.length; i++) {
        var propertyName = allPropertyNames[i];
        var descriptor = __WEBPACK_IMPORTED_MODULE_3_babel_runtime_core_js_object_get_own_property_descriptor___default()(parent, propertyName);

        if (descriptor && descriptor.enumerable) {
          continue;
        }

        child[propertyName] = copy(parent[propertyName], depth - 1);

        __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_object_define_property___default()(child, propertyName, descriptor);
      }
    }

    return child;
  }

  return copy(parent, depth);
};

clone.clonePrototype = function clonePrototype(parent) {
  if (parent === null) {
    return null;
  }

  var c = function c() {};

  c.prototype = parent;

  return new c();
};

/* harmony default export */ __webpack_exports__["a"] = (clone);
/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(143).Buffer))

/***/ }),
/* 5 */
/***/ (function(module, exports) {

var core = module.exports = { version: '2.6.10' };
if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef


/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {

var global = __webpack_require__(7);
var core = __webpack_require__(5);
var ctx = __webpack_require__(15);
var hide = __webpack_require__(16);
var has = __webpack_require__(19);
var PROTOTYPE = 'prototype';

var $export = function (type, name, source) {
  var IS_FORCED = type & $export.F;
  var IS_GLOBAL = type & $export.G;
  var IS_STATIC = type & $export.S;
  var IS_PROTO = type & $export.P;
  var IS_BIND = type & $export.B;
  var IS_WRAP = type & $export.W;
  var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});
  var expProto = exports[PROTOTYPE];
  var target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE];
  var key, own, out;
  if (IS_GLOBAL) source = name;
  for (key in source) {
    // contains in native
    own = !IS_FORCED && target && target[key] !== undefined;
    if (own && has(exports, key)) continue;
    // export native or passed
    out = own ? target[key] : source[key];
    // prevent global pollution for namespaces
    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
    // bind timers to global for call from export context
    : IS_BIND && own ? ctx(out, global)
    // wrap global constructors for prevent change them in library
    : IS_WRAP && target[key] == out ? (function (C) {
      var F = function (a, b, c) {
        if (this instanceof C) {
          switch (arguments.length) {
            case 0: return new C();
            case 1: return new C(a);
            case 2: return new C(a, b);
          } return new C(a, b, c);
        } return C.apply(this, arguments);
      };
      F[PROTOTYPE] = C[PROTOTYPE];
      return F;
    // make static versions for prototype methods
    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%
    if (IS_PROTO) {
      (exports.virtual || (exports.virtual = {}))[key] = out;
      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%
      if (type & $export.R && expProto && !expProto[key]) hide(expProto, key, out);
    }
  }
};
// type bitmap
$export.F = 1;   // forced
$export.G = 2;   // global
$export.S = 4;   // static
$export.P = 8;   // proto
$export.B = 16;  // bind
$export.W = 32;  // wrap
$export.U = 64;  // safe
$export.R = 128; // real proto method for `library`
module.exports = $export;


/***/ }),
/* 7 */
/***/ (function(module, exports) {

// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
var global = module.exports = typeof window != 'undefined' && window.Math == Math
  ? window : typeof self != 'undefined' && self.Math == Math ? self
  // eslint-disable-next-line no-new-func
  : Function('return this')();
if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef


/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {

var store = __webpack_require__(43)('wks');
var uid = __webpack_require__(34);
var Symbol = __webpack_require__(7).Symbol;
var USE_SYMBOL = typeof Symbol == 'function';

var $exports = module.exports = function (name) {
  return store[name] || (store[name] =
    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
};

$exports.store = store;


/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {

var anObject = __webpack_require__(13);
var IE8_DOM_DEFINE = __webpack_require__(63);
var toPrimitive = __webpack_require__(45);
var dP = Object.defineProperty;

exports.f = __webpack_require__(11) ? Object.defineProperty : function defineProperty(O, P, Attributes) {
  anObject(O);
  P = toPrimitive(P, true);
  anObject(Attributes);
  if (IE8_DOM_DEFINE) try {
    return dP(O, P, Attributes);
  } catch (e) { /* empty */ }
  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
  if ('value' in Attributes) O[P] = Attributes.value;
  return O;
};


/***/ }),
/* 10 */
/***/ (function(module, exports) {

module.exports = function (it) {
  return typeof it === 'object' ? it !== null : typeof it === 'function';
};


/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {

// Thank's IE8 for his funny defineProperty
module.exports = !__webpack_require__(20)(function () {
  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
});


/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = { "default": __webpack_require__(91), __esModule: true };

/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(10);
module.exports = function (it) {
  if (!isObject(it)) throw TypeError(it + ' is not an object!');
  return it;
};


/***/ }),
/* 14 */
/***/ (function(module, exports) {

module.exports = __WEBPACK_EXTERNAL_MODULE_14__;

/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {

// optional / simple context binding
var aFunction = __webpack_require__(27);
module.exports = function (fn, that, length) {
  aFunction(fn);
  if (that === undefined) return fn;
  switch (length) {
    case 1: return function (a) {
      return fn.call(that, a);
    };
    case 2: return function (a, b) {
      return fn.call(that, a, b);
    };
    case 3: return function (a, b, c) {
      return fn.call(that, a, b, c);
    };
  }
  return function (/* ...args */) {
    return fn.apply(that, arguments);
  };
};


/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {

var dP = __webpack_require__(9);
var createDesc = __webpack_require__(28);
module.exports = __webpack_require__(11) ? function (object, key, value) {
  return dP.f(object, key, createDesc(1, value));
} : function (object, key, value) {
  object[key] = value;
  return object;
};


/***/ }),
/* 17 */
/***/ (function(module, exports) {

var nestRE = /^(attrs|props|on|nativeOn|class|style|hook)$/

module.exports = function mergeJSXProps (objs) {
  return objs.reduce(function (a, b) {
    var aa, bb, key, nestedKey, temp
    for (key in b) {
      aa = a[key]
      bb = b[key]
      if (aa && nestRE.test(key)) {
        // normalize class
        if (key === 'class') {
          if (typeof aa === 'string') {
            temp = aa
            a[key] = aa = {}
            aa[temp] = true
          }
          if (typeof bb === 'string') {
            temp = bb
            b[key] = bb = {}
            bb[temp] = true
          }
        }
        if (key === 'on' || key === 'nativeOn' || key === 'hook') {
          // merge functions
          for (nestedKey in bb) {
            aa[nestedKey] = mergeFn(aa[nestedKey], bb[nestedKey])
          }
        } else if (Array.isArray(aa)) {
          a[key] = aa.concat(bb)
        } else if (Array.isArray(bb)) {
          a[key] = [aa].concat(bb)
        } else {
          for (nestedKey in bb) {
            aa[nestedKey] = bb[nestedKey]
          }
        }
      } else {
        a[key] = b[key]
      }
    }
    return a
  }, {})
}

function mergeFn (a, b) {
  return function () {
    a && a.apply(this, arguments)
    b && b.apply(this, arguments)
  }
}


/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {

// 7.1.13 ToObject(argument)
var defined = __webpack_require__(41);
module.exports = function (it) {
  return Object(defined(it));
};


/***/ }),
/* 19 */
/***/ (function(module, exports) {

var hasOwnProperty = {}.hasOwnProperty;
module.exports = function (it, key) {
  return hasOwnProperty.call(it, key);
};


/***/ }),
/* 20 */
/***/ (function(module, exports) {

module.exports = function (exec) {
  try {
    return !!exec();
  } catch (e) {
    return true;
  }
};


/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {

// to indexed object, toObject with fallback for non-array-like ES3 strings
var IObject = __webpack_require__(46);
var defined = __webpack_require__(41);
module.exports = function (it) {
  return IObject(defined(it));
};


/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


exports.__esModule = true;

var _iterator = __webpack_require__(95);

var _iterator2 = _interopRequireDefault(_iterator);

var _symbol = __webpack_require__(68);

var _symbol2 = _interopRequireDefault(_symbol);

var _typeof = typeof _symbol2.default === "function" && typeof _iterator2.default === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof _symbol2.default === "function" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj; };

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = typeof _symbol2.default === "function" && _typeof(_iterator2.default) === "symbol" ? function (obj) {
  return typeof obj === "undefined" ? "undefined" : _typeof(obj);
} : function (obj) {
  return obj && typeof _symbol2.default === "function" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj === "undefined" ? "undefined" : _typeof(obj);
};

/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $at = __webpack_require__(97)(true);

// 21.1.3.27 String.prototype[@@iterator]()
__webpack_require__(49)(String, 'String', function (iterated) {
  this._t = String(iterated); // target
  this._i = 0;                // next index
// 21.1.5.2.1 %StringIteratorPrototype%.next()
}, function () {
  var O = this._t;
  var index = this._i;
  var point;
  if (index >= O.length) return { value: undefined, done: true };
  point = $at(O, index);
  this._i += point.length;
  return { value: point, done: false };
});


/***/ }),
/* 24 */
/***/ (function(module, exports) {

module.exports = {};


/***/ }),
/* 25 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = { "default": __webpack_require__(89), __esModule: true };

/***/ }),
/* 26 */
/***/ (function(module, exports) {

module.exports = true;


/***/ }),
/* 27 */
/***/ (function(module, exports) {

module.exports = function (it) {
  if (typeof it != 'function') throw TypeError(it + ' is not a function!');
  return it;
};


/***/ }),
/* 28 */
/***/ (function(module, exports) {

module.exports = function (bitmap, value) {
  return {
    enumerable: !(bitmap & 1),
    configurable: !(bitmap & 2),
    writable: !(bitmap & 4),
    value: value
  };
};


/***/ }),
/* 29 */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.14 / 15.2.3.14 Object.keys(O)
var $keys = __webpack_require__(64);
var enumBugKeys = __webpack_require__(48);

module.exports = Object.keys || function keys(O) {
  return $keys(O, enumBugKeys);
};


/***/ }),
/* 30 */
/***/ (function(module, exports) {

var toString = {}.toString;

module.exports = function (it) {
  return toString.call(it).slice(8, -1);
};


/***/ }),
/* 31 */
/***/ (function(module, exports, __webpack_require__) {

var def = __webpack_require__(9).f;
var has = __webpack_require__(19);
var TAG = __webpack_require__(8)('toStringTag');

module.exports = function (it, tag, stat) {
  if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });
};


/***/ }),
/* 32 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(100);
var global = __webpack_require__(7);
var hide = __webpack_require__(16);
var Iterators = __webpack_require__(24);
var TO_STRING_TAG = __webpack_require__(8)('toStringTag');

var DOMIterables = ('CSSRuleList,CSSStyleDeclaration,CSSValueList,ClientRectList,DOMRectList,DOMStringList,' +
  'DOMTokenList,DataTransferItemList,FileList,HTMLAllCollection,HTMLCollection,HTMLFormElement,HTMLSelectElement,' +
  'MediaList,MimeTypeArray,NamedNodeMap,NodeList,PaintRequestList,Plugin,PluginArray,SVGLengthList,SVGNumberList,' +
  'SVGPathSegList,SVGPointList,SVGStringList,SVGTransformList,SourceBufferList,StyleSheetList,TextTrackCueList,' +
  'TextTrackList,TouchList').split(',');

for (var i = 0; i < DOMIterables.length; i++) {
  var NAME = DOMIterables[i];
  var Collection = global[NAME];
  var proto = Collection && Collection.prototype;
  if (proto && !proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME);
  Iterators[NAME] = Iterators.Array;
}


/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {

var ctx = __webpack_require__(15);
var call = __webpack_require__(75);
var isArrayIter = __webpack_require__(76);
var anObject = __webpack_require__(13);
var toLength = __webpack_require__(36);
var getIterFn = __webpack_require__(58);
var BREAK = {};
var RETURN = {};
var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {
  var iterFn = ITERATOR ? function () { return iterable; } : getIterFn(iterable);
  var f = ctx(fn, that, entries ? 2 : 1);
  var index = 0;
  var length, step, iterator, result;
  if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');
  // fast case for arrays with default iterator
  if (isArrayIt