text: (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory();
  	else if(typeof define === 'function' && define.amd)
  		define([], factory);
  	else if(typeof exports === 'object')
  		exports["Tractor"] = factory();
  	else
  		root["Tractor"] = factory();
  })(this, function() {
  return /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			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 = "";
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = 11);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // Thank's IE8 for his funny defineProperty
  module.exports = !__webpack_require__(4)(function () {
    return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
  });
  
  
  /***/ }),
  /* 1 */
  /***/ (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
  
  
  /***/ }),
  /* 2 */
  /***/ (function(module, exports) {
  
  var core = module.exports = { version: '2.5.1' };
  if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef
  
  
  /***/ }),
  /* 3 */
  /***/ (function(module, exports) {
  
  module.exports = function (it) {
    return typeof it === 'object' ? it !== null : typeof it === 'function';
  };
  
  
  /***/ }),
  /* 4 */
  /***/ (function(module, exports) {
  
  module.exports = function (exec) {
    try {
      return !!exec();
    } catch (e) {
      return true;
    }
  };
  
  
  /***/ }),
  /* 5 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var global = __webpack_require__(1);
  var core = __webpack_require__(2);
  var ctx = __webpack_require__(15);
  var hide = __webpack_require__(17);
  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 && key in exports) 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;
  
  
  /***/ }),
  /* 6 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var anObject = __webpack_require__(18);
  var IE8_DOM_DEFINE = __webpack_require__(19);
  var toPrimitive = __webpack_require__(21);
  var dP = Object.defineProperty;
  
  exports.f = __webpack_require__(0) ? 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;
  };
  
  
  /***/ }),
  /* 7 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // to indexed object, toObject with fallback for non-array-like ES3 strings
  var IObject = __webpack_require__(8);
  var defined = __webpack_require__(9);
  module.exports = function (it) {
    return IObject(defined(it));
  };
  
  
  /***/ }),
  /* 8 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // fallback for non-array-like ES3 and non-enumerable old V8 strings
  var cof = __webpack_require__(27);
  // eslint-disable-next-line no-prototype-builtins
  module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
    return cof(it) == 'String' ? it.split('') : Object(it);
  };
  
  
  /***/ }),
  /* 9 */
  /***/ (function(module, exports) {
  
  // 7.2.1 RequireObjectCoercible(argument)
  module.exports = function (it) {
    if (it == undefined) throw TypeError("Can't call method on  " + it);
    return it;
  };
  
  
  /***/ }),
  /* 10 */
  /***/ (function(module, exports) {
  
  // 7.1.4 ToInteger
  var ceil = Math.ceil;
  var floor = Math.floor;
  module.exports = function (it) {
    return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
  };
  
  
  /***/ }),
  /* 11 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var _assign = __webpack_require__(12);
  
  var _assign2 = _interopRequireDefault(_assign);
  
  var _classCallCheck2 = __webpack_require__(38);
  
  var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
  
  var _createClass2 = __webpack_require__(39);
  
  var _createClass3 = _interopRequireDefault(_createClass2);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  var TRACTOR_TOUCHING = 'tractor-touching';
  var TRACTOR_LESS = 'tractor-less';
  var TRACTOR_GREATER = 'tractor-greater';
  var TRACTOR_REFRESHING = 'tractor-refreshing';
  
  var Tractor = function () {
    function Tractor(options) {
      (0, _classCallCheck3.default)(this, Tractor);
  
      (0, _assign2.default)(this, {
        scroller: 'body', // 滚动容器
        enableDragLoading: false, // 开启下拉加载
        enableScrollLoading: false, // 开启滚动加载
        avoidHorizontalSliding: false, // 开启避免横向滑屏
        dragThreshold: 40, // 下拉加载阈值
        scrollThreshold: 40, // 滚动加载阈值
        onDragStart: null, // 下拉开始
        onDragLessThreshold: null, // 下拉中，但还没到刷新阀阈值
        onDragGreaterThreshold: null, // 下拉中，已经达到刷新阈值
        onDragDone: null, // 下拉结束
        onScrollToThreshold: null // 滚动到阈值
      }, options);
  
      this.translate = 0; // 下拉容器偏移值
      this.scrollerLoading = false; // 是否已经触发滚动加载状态
      this.scroller = document.querySelector(this.scroller);
  
      if (this.enableDragLoading) Tractor._initDrag.call(this);
      if (this.enableScrollLoading) Tractor._initScroll.call(this);
    }
  
    (0, _createClass3.default)(Tractor, null, [{
      key: '_initDrag',
      value: function _initDrag() {
        var isTouchStart = false; // 是否已经触发下拉条件
        var isDragStart = false; // 是否已经开始下拉
        var thresholdState = false; // 是否下拉到阈值，用来触发 hook 的标识
        var startX = 0; // 下拉 touchstart 时的点坐标 x
        var startY = 0; // 下拉 touchstart 时的点坐标 y
  
        // 监听下拉
        this.scroller.addEventListener('touchstart', touchStart.bind(this), false);
        this.scroller.addEventListener('touchmove', touchMove.bind(this), false);
        this.scroller.addEventListener('touchend', touchEnd.bind(this), false);
  
        function touchStart(event) {
          // 只有当容器视图处于最顶部的时候才能触发下拉事件
          if (this.scroller.scrollTop <= 0) {
            isTouchStart = true;
            startX = event.changedTouches[0].pageX;
            startY = event.changedTouches[0].pageY;
          }
        }
  
        function touchMove(event) {
          // return false 会阻止默认事件
          if (!isTouchStart) return;
  
          // 手指在屏幕移动的距离
          var distance = event.changedTouches[0].pageY - startY;
          if (distance > 0) {
            // 下拉时容器偏移的距离
            this.translate = Math.pow(distance, 0.85);
          } else {
            // 为了避免多次给元素设置样式属性
            if (this.translate !== 0) {
              this.translate = 0;
              elTransform(this.scroller, 'translate3d(0, ' + this.translate + 'px, 0)');
            }
          }
  
          // 避免横向滑屏
          if (this.avoidHorizontalSliding) {
            var diffDistance = Math.abs(event.touches[0].pageX - startX) - Math.abs(event.touches[0].pageY - startY);
            if (diffDistance > 0) return false;
          }
  
          if (distance > 0) {
            event.preventDefault();
            this.scroller.classList.add(TRACTOR_TOUCHING);
  
            // 触发下拉开始 hook
            if (!isDragStart) {
              isDragStart = true;
              if (this.onDragStart) this.onDragStart();
            }
  
            if (this.translate <= this.dragThreshold) {
              // 容器偏移值未达到下拉加载（刷新）阈值
  
              if (this.scroller.classList.contains(TRACTOR_GREATER)) this.scroller.classList.remove(TRACTOR_GREATER);
              if (!this.scroller.classList.contains(TRACTOR_LESS)) this.scroller.classList.add(TRACTOR_LESS);
  
              // 触发下拉未达到阈值状态 hook
              if (!thresholdState) {
                thresholdState = !thresholdState;
                if (this.onDragLessThreshold) this.onDragLessThreshold();
              }
            } else {
              // 容器偏移值已达到下拉加载（刷新）阈值
  
              if (this.scroller.classList.contains(TRACTOR_LESS)) this.scroller.classList.remove(TRACTOR_LESS);
              if (!this.scroller.classList.contains(TRACTOR_GREATER)) this.scroller.classList.add(TRACTOR_GREATER);
  
              // 触发下拉已达到阈值状态 hook
              if (thresholdState) {
                thresholdState = !thresholdState;
                this.onDragGreaterThreshold();
              }
            }
  
            elTransform(this.scroller, 'translate3d(0, ' + this.translate + 'px, 0)');
          }
        }
  
        function touchEnd(event) {
          if (!isTouchStart) return;
  
          // 下拉结束还原状态
          isDragStart = false;
          isTouchStart = false;
  
          this.scroller.classList.remove(TRACTOR_TOUCHING);
  
          if (this.translate <= this.dragThreshold) {
            this.scroller.classList.remove(TRACTOR_LESS);
            translateScroller.apply(this, [300, 0]);
          } else {
            this.scroller.classList.remove(TRACTOR_GREATER);
            this.scroller.classList.add(TRACTOR_REFRESHING);
            translateScroller.apply(this, [100, this.dragThreshold]);
  
            // 触发下拉加载（刷新）完成 hook
            this.onDragDone();
          }
        }
      }
    }, {
      key: '_initScroll',
      value: function _initScroll() {
        this.scroller.addEventListener('scroll', scrolling.bind(this), false);
  
        function scrolling() {
          if (this.scrollerLoading) return;
  
          var _scroller = this.scroller,
              scrollHeight = _scroller.scrollHeight,
              scrollTop = _scroller.scrollTop;
  
          var scrollerHeight = this.scroller.getBoundingClientRect().height;
          var scrollThreshold = scrollHeight - scrollerHeight - scrollTop;
  
          // 达到滚动加载阈值
          if (scrollThreshold <= this.scrollThreshold) {
            this.scrollerLoading = true;
            if (this.onScrollToThreshold) this.onScrollToThreshold(); // hook
          }
        }
      }
    }]);
    return Tractor;
  }();
  
  (0, _assign2.default)(Tractor.prototype, {
    dragLoadingDone: function dragLoadingDone() {
      this.scroller.classList.remove(TRACTOR_REFRESHING);
      translateScroller.apply(this, [300, 0]);
    },
    scrollLoadingDone: function scrollLoadingDone() {
      this.scrollerLoading = false;
    }
  });
  
  function translateScroller(consuming, threshold) {
    window.requestAnimationFrame(translateRAF.bind(this));
  
    var time = 0;
    function translateRAF(timestamp) {
      if (!time) time = timestamp;
      var remain = this.translate - this.translate * (timestamp - time) / consuming;
      if (remain < threshold) remain = this.translate = threshold;
  
      elTransform(this.scroller, 'translate3d(0, ' + remain + 'px, 0)');
  
      if (remain > threshold) window.requestAnimationFrame(translateRAF.bind(this));
    }
  }
  
  function elTransform(el, transform) {
    var elStyle = el.style;
    elStyle.webkitTransform = elStyle.MozTransform = elStyle.transform = transform;
  }
  
  module.exports = Tractor;
  
  /***/ }),
  /* 12 */
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = { "default": __webpack_require__(13), __esModule: true };
  
  /***/ }),
  /* 13 */
  /***/ (function(module, exports, __webpack_require__) {
  
  __webpack_require__(14);
  module.exports = __webpack_require__(2).Object.assign;
  
  
  /***/ }),
  /* 14 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 19.1.3.1 Object.assign(target, source)
  var $export = __webpack_require__(5);
  
  $export($export.S + $export.F, 'Object', { assign: __webpack_require__(23) });
  
  
  /***/ }),
  /* 15 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // optional / simple context binding
  var aFunction = __webpack_require__(16);
  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) {
  
  module.exports = function (it) {
    if (typeof it != 'function') throw TypeError(it + ' is not a function!');
    return it;
  };
  
  
  /***/ }),
  /* 17 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var dP = __webpack_require__(6);
  var createDesc = __webpack_require__(22);
  module.exports = __webpack_require__(0) ? function (object, key, value) {
    return dP.f(object, key, createDesc(1, value));
  } : function (object, key, value) {
    object[key] = value;
    return object;
  };
  
  
  /***/ }),
  /* 18 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var isObject = __webpack_require__(3);
  module.exports = function (it) {
    if (!isObject(it)) throw TypeError(it + ' is not an object!');
    return it;
  };
  
  
  /***/ }),
  /* 19 */
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = !__webpack_require__(0) && !__webpack_require__(4)(function () {
    return Object.defineProperty(__webpack_require__(20)('div'), 'a', { get: function () { return 7; } }).a != 7;
  });
  
  
  /***/ }),
  /* 20 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var isObject = __webpack_require__(3);
  var document = __webpack_require__(1).document;
  // typeof document.createElement is 'object' in old IE
  var is = isObject(document) && isObject(document.createElement);
  module.exports = function (it) {
    return is ? document.createElement(it) : {};
  };
  
  
  /***/ }),
  /* 21 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 7.1.1 ToPrimitive(input [, PreferredType])
  var isObject = __webpack_require__(3);
  // instead of the ES6 spec version, we didn't implement @@toPrimitive case
  // and the second argument - flag - preferred type is a string
  module.exports = function (it, S) {
    if (!isObject(it)) return it;
    var fn, val;
    if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
    if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;
    if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
    throw TypeError("Can't convert object to primitive value");
  };
  
  
  /***/ }),
  /* 22 */
  /***/ (function(module, exports) {
  
  module.exports = function (bitmap, value) {
    return {
      enumerable: !(bitmap & 1),
      configurable: !(bitmap & 2),
      writable: !(bitmap & 4),
      value: value
    };
  };
  
  
  /***/ }),
  /* 23 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  // 19.1.2.1 Object.assign(target, source, ...)
  var getKeys = __webpack_require__(24);
  var gOPS = __webpack_require__(35);
  var pIE = __webpack_require__(36);
  var toObject = __webpack_require__(37);
  var IObject = __webpack_require__(8);
  var $assign = Object.assign;
  
  // should work with symbols and should have deterministic property order (V8 bug)
  module.exports = !$assign || __webpack_require__(4)(function () {
    var A = {};
    var B = {};
    // eslint-disable-next-line no-undef
    var S = Symbol();
    var K = 'abcdefghijklmnopqrst';
    A[S] = 7;
    K.split('').forEach(function (k) { B[k] = k; });
    return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
  }) ? function assign(target, source) { // eslint-disable-line no-unused-vars
    var T = toObject(target);
    var aLen = arguments.length;
    var index = 1;
    var getSymbols = gOPS.f;
    var isEnum = pIE.f;
    while (aLen > index) {
      var S = IObject(arguments[index++]);
      var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S);
      var length = keys.length;
      var j = 0;
      var key;
      while (length > j) if (isEnum.call(S, key = keys[j++])) T[key] = S[key];
    } return T;
  } : $assign;
  
  
  /***/ }),
  /* 24 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 19.1.2.14 / 15.2.3.14 Object.keys(O)
  var $keys = __webpack_require__(25);
  var enumBugKeys = __webpack_require__(34);
  
  module.exports = Object.keys || function keys(O) {
    return $keys(O, enumBugKeys);
  };
  
  
  /***/ }),
  /* 25 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var has = __webpack_require__(26);
  var toIObject = __webpack_require__(7);
  var arrayIndexOf = __webpack_require__(28)(false);
  var IE_PROTO = __webpack_require__(31)('IE_PROTO');
  
  module.exports = function (object, names) {
    var O = toIObject(object);
    var i = 0;
    var result = [];
    var key;
    for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key);
    // Don't enum bug & hidden keys
    while (names.length > i) if (has(O, key = names[i++])) {
      ~arrayIndexOf(result, key) || result.push(key);
    }
    return result;
  };
  
  
  /***/ }),
  /* 26 */
  /***/ (function(module, exports) {
  
  var hasOwnProperty = {}.hasOwnProperty;
  module.exports = function (it, key) {
    return hasOwnProperty.call(it, key);
  };
  
  
  /***/ }),
  /* 27 */
  /***/ (function(module, exports) {
  
  var toString = {}.toString;
  
  module.exports = function (it) {
    return toString.call(it).slice(8, -1);
  };
  
  
  /***/ }),
  /* 28 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // false -> Array#indexOf
  // true  -> Array#includes
  var toIObject = __webpack_require__(7);
  var toLength = __webpack_require__(29);
  var toAbsoluteIndex = __webpack_require__(30);
  module.exports = function (IS_INCLUDES) {
    return function ($this, el, fromIndex) {
      var O = toIObject($this);
      var length = toLength(O.length);
      var index = toAbsoluteIndex(fromIndex, length);
      var value;
      // Array#includes uses SameValueZero equality algorithm
      // eslint-disable-next-line no-self-compare
      if (IS_INCLUDES && el != el) while (length > index) {
        value = O[index++];
        // eslint-disable-next-line no-self-compare
        if (value != value) return true;
      // Array#indexOf ignores holes, Array#includes - not
      } else for (;length > index; index++) if (IS_INCLUDES || index in O) {
        if (O[index] === el) return IS_INCLUDES || index || 0;
      } return !IS_INCLUDES && -1;
    };
  };
  
  
  /***/ }),
  /* 29 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 7.1.15 ToLength
  var toInteger = __webpack_require__(10);
  var min = Math.min;
  module.exports = function (it) {
    return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
  };
  
  
  /***/ }),
  /* 30 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var toInteger = __webpack_require__(10);
  var max = Math.max;
  var min = Math.min;
  module.exports = function (index, length) {
    index = toInteger(index);
    return index < 0 ? max(index + length, 0) : min(index, length);
  };
  
  
  /***/ }),
  /* 31 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var shared = __webpack_require__(32)('keys');
  var uid = __webpack_require__(33);
  module.exports = function (key) {
    return shared[key] || (shared[key] = uid(key));
  };
  
  
  /***/ }),
  /* 32 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var global = __webpack_require__(1);
  var SHARED = '__core-js_shared__';
  var store = global[SHARED] || (global[SHARED] = {});
  module.exports = function (key) {
    return store[key] || (store[key] = {});
  };
  
  
  /***/ }),
  /* 33 */
  /***/ (function(module, exports) {
  
  var id = 0;
  var px = Math.random();
  module.exports = function (key) {
    return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
  };
  
  
  /***/ }),
  /* 34 */
  /***/ (function(module, exports) {
  
  // IE 8- don't enum bug keys
  module.exports = (
    'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
  ).split(',');
  
  
  /***/ }),
  /* 35 */
  /***/ (function(module, exports) {
  
  exports.f = Object.getOwnPropertySymbols;
  
  
  /***/ }),
  /* 36 */
  /***/ (function(module, exports) {
  
  exports.f = {}.propertyIsEnumerable;
  
  
  /***/ }),
  /* 37 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // 7.1.13 ToObject(argument)
  var defined = __webpack_require__(9);
  module.exports = function (it) {
    return Object(defined(it));
  };
  
  
  /***/ }),
  /* 38 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  exports.__esModule = true;
  
  exports.default = function (instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  };
  
  /***/ }),
  /* 39 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  exports.__esModule = true;
  
  var _defineProperty = __webpack_require__(40);
  
  var _defineProperty2 = _interopRequireDefault(_defineProperty);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  exports.default = function () {
    function defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        (0, _defineProperty2.default)(target, descriptor.key, descriptor);
      }
    }
  
    return function (Constructor, protoProps, staticProps) {
      if (protoProps) defineProperties(Constructor.prototype, protoProps);
      if (staticProps) defineProperties(Constructor, staticProps);
      return Constructor;
    };
  }();
  
  /***/ }),
  /* 40 */
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = { "default": __webpack_require__(41), __esModule: true };
  
  /***/ }),
  /* 41 */
  /***/ (function(module, exports, __webpack_require__) {
  
  __webpack_require__(42);
  var $Object = __webpack_require__(2).Object;
  module.exports = function defineProperty(it, key, desc) {
    return $Object.defineProperty(it, key, desc);
  };
  
  
  /***/ }),
  /* 42 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var $export = __webpack_require__(5);
  // 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)
  $export($export.S + $export.F * !__webpack_require__(0), 'Object', { defineProperty: __webpack_require__(6).f });
  
  
  /***/ })
  /******/ ]);
  });
  