!function () {
    function _get() {
        if (typeof Reflect !== "undefined" && Reflect.get) {
            _get = Reflect.get;
        } else {
            _get = function _get(target, property, receiver) {
                var base = _superPropBase(target, property);
                if (!base)
                    return;
                var desc = Object.getOwnPropertyDescriptor(base, property);
                if (desc.get) {
                    return desc.get.call(arguments.length < 3 ? target : receiver);
                }
                return desc.value;
            }
                ;
        }
        return _get.apply(this, arguments);
    }

    function set(e, r, t, o) {
        return (set = "undefined" != typeof Reflect && Reflect.set ? Reflect.set : function (e, r, t, o) {
            var i, f = _superPropBase(e, r);
            if (f) {
                if ((i = Object.getOwnPropertyDescriptor(f, r)).set) return i.set.call(o, t), !0;
                if (!i.writable) return !1;
            }
            if (i = Object.getOwnPropertyDescriptor(o, r)) {
                if (!i.writable) return !1;
                i.value = t, Object.defineProperty(o, r, i);
            } else _defineProperty(o, r, t);
            return !0;
        })(e, r, t, o);
    }

    function _set(target, property, value, receiver, isStrict) {
        var s = set(target, property, value, receiver || target); if (!s && isStrict) {
            throw new Error('failed to set property');
        } return value;
    }

    function _superPropBase(object, property) {
        while (!Object.prototype.hasOwnProperty.call(object, property)) {
            object = _getPrototypeOf(object);
            if (object === null)
                break;
        }
        return object;
    }
    function _inherits(subClass, superClass) {
        if (typeof superClass !== "function" && superClass !== null) {
            throw new TypeError("Super expression must either be null or a function");
        }
        subClass.prototype = Object.create(superClass && superClass.prototype, {
            constructor: {
                value: subClass,
                writable: true,
                configurable: true
            }
        });
        Object.defineProperty(subClass, "prototype", {
            writable: false
        });
        if (superClass)
            _setPrototypeOf(subClass, superClass);
    }
    function _createForOfIteratorHelper(r, e) {
        var t;
        if ("undefined" == typeof Symbol || null == r[Symbol.iterator]) {
            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 = r[Symbol.iterator]();
            },
            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;
                }
            }
        };
    }
    function _setPrototypeOf(o, p) {
        _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
            o.__proto__ = p;
            return o;
        }
            ;
        return _setPrototypeOf(o, p);
    }
    function _createSuper(Derived) {
        var hasNativeReflectConstruct = _isNativeReflectConstruct();
        return function _createSuperInternal() {
            var Super = _getPrototypeOf(Derived), result;
            if (hasNativeReflectConstruct) {
                var NewTarget = _getPrototypeOf(this).constructor;
                result = Reflect.construct(Super, arguments, NewTarget);
            } else {
                result = Super.apply(this, arguments);
            }
            return _possibleConstructorReturn(this, result);
        }
            ;
    }
    function _possibleConstructorReturn(self, call) {
        if (call && (_typeof(call) === "object" || typeof call === "function")) {
            return call;
        } else if (call !== void 0) {
            throw new TypeError("Derived constructors may only return object or undefined");
        }
        return _assertThisInitialized(self);
    }
    function _assertThisInitialized(self) {
        if (self === void 0) {
            throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
        }
        return self;
    }
    function _isNativeReflectConstruct() {
        if (typeof Reflect === "undefined" || !Reflect.construct)
            return false;
        if (Reflect.construct.sham)
            return false;
        if (typeof Proxy === "function")
            return true;
        try {
            Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () { }));
            return true;
        } catch (e) {
            return false;
        }
    }
    function _getPrototypeOf(o) {
        _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
            return o.__proto__ || Object.getPrototypeOf(o);
        }
            ;
        return _getPrototypeOf(o);
    }

    function _defineProperty(obj, key, value) {
        if (key in obj) {
            Object.defineProperty(obj, key, {
                value: value,
                enumerable: true,
                configurable: true,
                writable: true
            });
        } else {
            obj[key] = value;
        }
        return obj;
    }
    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;
            Object.defineProperty(target, descriptor.key, descriptor);
        }
    }
    function _createClass(Constructor, protoProps, staticProps) {
        if (protoProps)
            _defineProperties(Constructor.prototype, protoProps);
        if (staticProps)
            _defineProperties(Constructor, staticProps);
        Object.defineProperty(Constructor, "prototype", {
            writable: false
        });
        return Constructor;
    }

    function _typeof(obj) {
        return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
            return typeof obj;
        }
            : function (obj) {
                return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
            }
            ,
            _typeof(obj);
    }
    function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : {
            default: obj
        };
    }
    function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
            throw new TypeError("Cannot call a class as a function");
        }
    }
    function _regeneratorRuntime() {
        _regeneratorRuntime = function () {
            return t;
        };
        var t = { name: "_regenerator" },
            e = Object.prototype, a = e.hasOwnProperty, n = "function" == typeof Symbol ? Symbol : {}, i = n.iterator || "@@iterator", s = n.asyncIterator || "@@asyncIterator", r = n.toStringTag || "@@toStringTag";
        function o(t, e, a) {
            return Object.defineProperty(t, e, {
                value: a,
                enumerable: !0,
                configurable: !0,
                writable: !0
            }), t[e];
        }
        try {
            o({}, "");
        } catch (t) {
            o = function (t, e, a) {
                return t[e] = a;
            };
        }
        function c(t, e, a, n) {
            var i = e && e.prototype instanceof h ? e : h, s = Object.create(i.prototype), r = new L(n || []);
            return s._invoke = function (t, e, a) {
                var n = "suspendedStart";
                return function (i, s) {
                    if ("executing" === n) throw new Error("Generator is already running");
                    if ("completed" === n) {
                        if ("throw" === i) throw s;
                        return T();
                    }
                    for (a.method = i, a.arg = s; ;) {
                        var r = a.delegate;
                        if (r) {
                            var o = k(r, a);
                            if (o) {
                                if (o === u) continue;
                                return o;
                            }
                        }
                        if ("next" === a.method) a.sent = a._sent = a.arg; else if ("throw" === a.method) {
                            if ("suspendedStart" === n) throw n = "completed", a.arg;
                            a.dispatchException(a.arg);
                        } else "return" === a.method && a.abrupt("return", a.arg);
                        n = "executing";
                        var c = l(t, e, a);
                        if ("normal" === c.type) {
                            if (n = a.done ? "completed" : "suspendedYield", c.arg === u) continue;
                            return {
                                value: c.arg,
                                done: a.done
                            };
                        }
                        "throw" === c.type && (n = "completed", a.method = "throw", a.arg = c.arg);
                    }
                };
            }(t, a, r), s;
        }
        function l(t, e, a) {
            try {
                return {
                    type: "normal",
                    arg: t.call(e, a)
                };
            } catch (t) {
                return {
                    type: "throw",
                    arg: t
                };
            }
        }
        t.wrap = c;
        var u = {};
        function h() { }
        function d() { }
        function f() { }
        var _ = {};
        o(_, i, function () {
            return this;
        });
        var m = Object.getPrototypeOf, g = m && m(m(S([])));
        g && g !== e && a.call(g, i) && (_ = g);
        var p = f.prototype = h.prototype = Object.create(_);
        function v(t) {
            ["next", "throw", "return"].forEach(function (e) {
                o(t, e, function (t) {
                    return this._invoke(e, t);
                });
            });
        }
        function y(t, e) {
            var n;
            this._invoke = function (i, s) {
                function r() {
                    return new e(function (n, r) {
                        !function n(i, s, r, o) {
                            var c = l(t[i], t, s);
                            if ("throw" !== c.type) {
                                var u = c.arg, h = u.value;
                                return h && "object" == _typeof(h) && a.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
                                    n("next", t, r, o);
                                }, function (t) {
                                    n("throw", t, r, o);
                                }) : e.resolve(h).then(function (t) {
                                    u.value = t, r(u);
                                }, function (t) {
                                    return n("throw", t, r, o);
                                });
                            }
                            o(c.arg);
                        }(i, s, n, r);
                    });
                }
                return n = n ? n.then(r, r) : r();
            };
        }
        function k(t, e) {
            var a = t.iterator[e.method];
            if (void 0 === a) {
                if (e.delegate = null, "throw" === e.method) {
                    if (t.iterator.return && (e.method = "return", e.arg = void 0, k(t, e), "throw" === e.method)) return u;
                    e.method = "throw", e.arg = new TypeError("The iterator does not provide a 'throw' method");
                }
                return u;
            }
            var n = l(a, t.iterator, e.arg);
            if ("throw" === n.type) return e.method = "throw", e.arg = n.arg, e.delegate = null,
                u;
            var i = n.arg;
            return i ? i.done ? (e[t.resultName] = i.value, e.next = t.nextLoc, "return" !== e.method && (e.method = "next",
                e.arg = void 0), e.delegate = null, u) : i : (e.method = "throw", e.arg = new TypeError("iterator result is not an object"),
                    e.delegate = null, u);
        }
        function C(t) {
            var e = {
                tryLoc: t[0]
            };
            1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]),
                this.tryEntries.push(e);
        }
        function I(t) {
            var e = t.completion || {};
            e.type = "normal", delete e.arg, t.completion = e;
        }
        function L(t) {
            this.tryEntries = [{
                tryLoc: "root"
            }], t.forEach(C, this), this.reset(!0);
        }
        function S(t) {
            if (t) {
                var e = t[i];
                if (e) return e.call(t);
                if ("function" == typeof t.next) return t;
                if (!isNaN(t.length)) {
                    var n = -1, s = function e() {
                        for (; ++n < t.length;) if (a.call(t, n)) return e.value = t[n], e.done = !1, e;
                        return e.value = void 0, e.done = !0, e;
                    };
                    return s.next = s;
                }
            }
            return {
                next: T
            };
        }
        function T() {
            return {
                value: void 0,
                done: !0
            };
        }
        return d.prototype = f, o(p, "constructor", f), o(f, "constructor", d), d.displayName = o(f, r, "GeneratorFunction"),
            t.isGeneratorFunction = function (t) {
                var e = "function" == typeof t && t.constructor;
                return !!e && (e === d || "GeneratorFunction" === (e.displayName || e.name));
            }, t.mark = function (t) {
                return Object.setPrototypeOf ? Object.setPrototypeOf(t, f) : (t.__proto__ = f, o(t, r, "GeneratorFunction")),
                    t.prototype = Object.create(p), t;
            }, t.awrap = function (t) {
                return {
                    __await: t
                };
            }, v(y.prototype), o(y.prototype, s, function () {
                return this;
            }), t.AsyncIterator = y, t.async = function (e, a, n, i, s) {
                void 0 === s && (s = Promise);
                var r = new y(c(e, a, n, i), s);
                return t.isGeneratorFunction(a) ? r : r.next().then(function (t) {
                    return t.done ? t.value : r.next();
                });
            }, v(p), o(p, r, "Generator"), o(p, i, function () {
                return this;
            }), o(p, "toString", function () {
                return "[object Generator]";
            }), t.keys = function (t) {
                var e = [];
                for (var a in t) e.push(a);
                return e.reverse(), function a() {
                    for (; e.length;) {
                        var n = e.pop();
                        if (n in t) return a.value = n, a.done = !1, a;
                    }
                    return a.done = !0, a;
                };
            }, t.values = S, L.prototype = {
                constructor: L,
                reset: function (t) {
                    if (this.prev = 0, this.next = 0, this.sent = this._sent = void 0, this.done = !1,
                        this.delegate = null, this.method = "next", this.arg = void 0, this.tryEntries.forEach(I),
                        !t) for (var e in this) "t" === e.charAt(0) && a.call(this, e) && !isNaN(+e.slice(1)) && (this[e] = void 0);
                },
                stop: function () {
                    this.done = !0;
                    var t = this.tryEntries[0].completion;
                    if ("throw" === t.type) throw t.arg;
                    return this.rval;
                },
                dispatchException: function (t) {
                    if (this.done) throw t;
                    var e = this;
                    function n(a, n) {
                        return r.type = "throw", r.arg = t, e.next = a, n && (e.method = "next", e.arg = void 0),
                            !!n;
                    }
                    for (var i = this.tryEntries.length - 1; i >= 0; --i) {
                        var s = this.tryEntries[i], r = s.completion;
                        if ("root" === s.tryLoc) return n("end");
                        if (s.tryLoc <= this.prev) {
                            var o = a.call(s, "catchLoc"), c = a.call(s, "finallyLoc");
                            if (o && c) {
                                if (this.prev < s.catchLoc) return n(s.catchLoc, !0);
                                if (this.prev < s.finallyLoc) return n(s.finallyLoc);
                            } else if (o) {
                                if (this.prev < s.catchLoc) return n(s.catchLoc, !0);
                            } else {
                                if (!c) throw new Error("try statement without catch or finally");
                                if (this.prev < s.finallyLoc) return n(s.finallyLoc);
                            }
                        }
                    }
                },
                abrupt: function (t, e) {
                    for (var n = this.tryEntries.length - 1; n >= 0; --n) {
                        var i = this.tryEntries[n];
                        if (i.tryLoc <= this.prev && a.call(i, "finallyLoc") && this.prev < i.finallyLoc) {
                            var s = i;
                            break;
                        }
                    }
                    s && ("break" === t || "continue" === t) && s.tryLoc <= e && e <= s.finallyLoc && (s = null);
                    var r = s ? s.completion : {};
                    return r.type = t, r.arg = e, s ? (this.method = "next", this.next = s.finallyLoc,
                        u) : this.complete(r);
                },
                complete: function (t, e) {
                    if ("throw" === t.type) throw t.arg;
                    return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg,
                        this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e),
                        u;
                },
                finish: function (t) {
                    for (var e = this.tryEntries.length - 1; e >= 0; --e) {
                        var a = this.tryEntries[e];
                        if (a.finallyLoc === t) return this.complete(a.completion, a.afterLoc), I(a), u;
                    }
                },
                catch: function (t) {
                    for (var e = this.tryEntries.length - 1; e >= 0; --e) {
                        var a = this.tryEntries[e];
                        if (a.tryLoc === t) {
                            var n = a.completion;
                            if ("throw" === n.type) {
                                var i = n.arg;
                                I(a);
                            }
                            return i;
                        }
                    }
                    throw new Error("illegal catch attempt");
                },
                delegateYield: function (t, e, a) {
                    return this.delegate = {
                        iterator: S(t),
                        resultName: e,
                        nextLoc: a
                    }, "next" === this.method && (this.arg = void 0), u;
                }
            }, t;
    }

    function asyncGeneratorStep(n, e, r, t, o, a, c) {
        try {
            var i = n[a](c), u = i.value;
        } catch (n) {
            return void r(n);
        }
        i.done ? e(u) : Promise.resolve(u).then(t, o);
    }

    function _asyncToGenerator(n) {
        return function () {
            var e = this, r = arguments;
            return new Promise(function (t, o) {
                var a = n.apply(e, r);
                function c(n) {
                    asyncGeneratorStep(a, t, o, c, i, "next", n);
                }
                function i(n) {
                    asyncGeneratorStep(a, t, o, c, i, "throw", n);
                }
                c(void 0);
            });
        };
    }



    const cache = {
        "get": _get,
        "set": _set,
        "inherits": _inherits,
        "superPropBase": _superPropBase,
        "createForOfIteratorHelper": _createForOfIteratorHelper,
        "createSuper": _createSuper,
        "possibleConstructorReturn": _possibleConstructorReturn,
        "isNativeReflectConstruct": _isNativeReflectConstruct,
        "setPrototypeOf": _setPrototypeOf,
        "getPrototypeOf": _getPrototypeOf,
        "defineProperties": _defineProperties,
        "createClass": _createClass,
        "typeof": _typeof,
        "interopRequireDefault": _interopRequireDefault,
        "classCallCheck": _classCallCheck,
        "assertThisInitialized": _assertThisInitialized,
        "regenerator": _regeneratorRuntime(),
        "defineProperty": _defineProperty,
        "asyncToGenerator": _asyncToGenerator,
        "Arrayincludes": !function () {
            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;
                    var i, o, a = 0 | e, u = Math.max(0 <= a ? a : n - Math.abs(a), 0);
                    for (; u < n;) {
                        if ((i = t[u]) === (o = r) || "number" == typeof i && "number" == typeof o && isNaN(i) && isNaN(o)) return !0;
                        u++;
                    }
                    return !1;
                }
            });
        }()
    };
    function basename(path, extName) {
        const index = path.indexOf('?');
        if (index > 0) {
            path = path.substring(0, index);
        }
        const reg = /(\/|\\)([^\/\\]+)$/g;
        const result = reg.exec(path.replace(/(\/|\\)$/, ''));
        if (!result) {
            return path;
        }
        const baseName = result[2];
        if (extName && path.substring(path.length - extName.length).toLowerCase() === extName.toLowerCase()) {
            return baseName.substring(0, baseName.length - extName.length);
        }
        return baseName;
    }
    function extname(path) {
        const temp = /(\.[^\.\/\?\\]*)(\?.*)?$/.exec(path);
        return temp ? temp[1] : '';
    }

    window.babel_require = function (name) {
        name = basename(name, extname(name)).replace(/_/g, "");
        for (const [k, v] of Object.entries(cache)) {
            if (name == k) {
                return v;
            }
        }
        throw new Error("cannot find module ".concat(name));
    };

}()
