Initial commit

js/@babel/runtime/helpers/Arrayincludes.js

@@ -0,0 +1,13 @@
+Array.prototype.includes || Object.defineProperty(Array.prototype, "includes", {
+  value: function(r, e) {
+    if (null == this) throw new TypeError('"this" is null or not defined');
+    var t = Object(this),
+      n = t.length >>> 0;
+    if (0 == n) return !1;
+    for (var i, o, a = 0 | e, u = Math.max(0 <= a ? a : n - Math.abs(a), 0); u < n;) {
+      if ((i = t[u]) === (o = r) || "number" == typeof i && "number" == typeof o && isNaN(i) && isNaN(o)) return !0;
+      u++
+    }
+    return !1
+  }
+});

js/@babel/runtime/helpers/arrayLikeToArray.js

@@ -0,0 +1,6 @@
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = new Array(a); e < a; e++) n[e] = r[e];
+  return n
+}
+module.exports = _arrayLikeToArray;

js/@babel/runtime/helpers/arrayWithoutHoles.js

@@ -0,0 +1,6 @@
+var arrayLikeToArray = require("./arrayLikeToArray");
+
+function _arrayWithoutHoles(r) {
+  if (Array.isArray(r)) return arrayLikeToArray(r)
+}
+module.exports = _arrayWithoutHoles;

js/@babel/runtime/helpers/createForOfIteratorHelper.js

@@ -0,0 +1,50 @@
+var unsupportedIterableToArray = require("./unsupportedIterableToArray");
+
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var n = 0,
+        o = function() {};
+      return {
+        s: o,
+        n: function() {
+          return n >= r.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: r[n++]
+          }
+        },
+        e: function(r) {
+          throw r
+        },
+        f: o
+      }
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")
+  }
+  var a, u = !0,
+    i = !1;
+  return {
+    s: function() {
+      t = t.call(r)
+    },
+    n: function() {
+      var r = t.next();
+      return u = r.done, r
+    },
+    e: function(r) {
+      i = !0, a = r
+    },
+    f: function() {
+      try {
+        u || null == t.return || t.return()
+      } finally {
+        if (i) throw a
+      }
+    }
+  }
+}
+module.exports = _createForOfIteratorHelper;

js/@babel/runtime/helpers/defineProperty.js

@@ -0,0 +1,11 @@
+var toPropertyKey = require("./toPropertyKey");
+
+function _defineProperty(e, r, t) {
+  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e
+}
+module.exports = _defineProperty;

js/@babel/runtime/helpers/iterableToArray.js

@@ -0,0 +1,4 @@
+function _iterableToArray(r) {
+  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r)
+}
+module.exports = _iterableToArray;

js/@babel/runtime/helpers/nonIterableSpread.js

@@ -0,0 +1,4 @@
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")
+}
+module.exports = _nonIterableSpread;

js/@babel/runtime/helpers/toConsumableArray.js

@@ -0,0 +1,9 @@
+var arrayWithoutHoles = require("./arrayWithoutHoles"),
+  iterableToArray = require("./iterableToArray"),
+  unsupportedIterableToArray = require("./unsupportedIterableToArray"),
+  nonIterableSpread = require("./nonIterableSpread");
+
+function _toConsumableArray(r) {
+  return arrayWithoutHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableSpread()
+}
+module.exports = _toConsumableArray;

js/@babel/runtime/helpers/toPrimitive.js

@@ -0,0 +1,13 @@
+var _typeof = require("./typeof");
+
+function _toPrimitive(r, t) {
+  if ("object" !== _typeof(r) || null === r) return r;
+  var e = r[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(r, t || "default");
+    if ("object" !== _typeof(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.")
+  }
+  return ("string" === t ? String : Number)(r)
+}
+module.exports = _toPrimitive;

js/@babel/runtime/helpers/toPropertyKey.js

@@ -0,0 +1,8 @@
+var _typeof = require("./typeof"),
+  toPrimitive = require("./toPrimitive");
+
+function _toPropertyKey(r) {
+  var t = toPrimitive(r, "string");
+  return "symbol" === _typeof(t) ? t : String(t)
+}
+module.exports = _toPropertyKey;

js/@babel/runtime/helpers/typeof.js

@@ -0,0 +1,23 @@
+/*
+* 为了解决 TypeError: _typeofX is not a function 问题， 使用了注入该段代码， 这样只能解决部分问题
+* 但是默认有一劳永逸解决的方法，如果你遇到这该类型报错
+* 请按操作执行:  右上角点击“详情”=>“本地设置”=>“将JS编译成ES5”=>取消勾选
+* */
+
+function _typeof2(o) {
+  return (_typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  })(o);
+}
+
+function _typeof(o) {
+  return "function" == typeof Symbol && "symbol" === _typeof2(Symbol.iterator) ? module.exports = _typeof = function (o) {
+    return _typeof2(o);
+  } : module.exports = _typeof = function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : _typeof2(o);
+  }, _typeof(o);
+}
+
+module.exports = _typeof;

js/@babel/runtime/helpers/unsupportedIterableToArray.js

@@ -0,0 +1,10 @@
+var arrayLikeToArray = require("./arrayLikeToArray");
+
+function _unsupportedIterableToArray(r, e) {
+  if (r) {
+    if ("string" == typeof r) return arrayLikeToArray(r, e);
+    var t = Object.prototype.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, e) : void 0
+  }
+}
+module.exports = _unsupportedIterableToArray;