@signalplus/params-about 0.1.2 → 0.1.3

package/lib/umd/index.js

@@ -0,0 +1,4861 @@
+/**
+ * Bundle of @signalplus/params-about
+ * Generated: 2022-04-07
+ * Version: 0.1.2
+ * License: MIT
+ * Author: 2631541504@qq.com
+ */
+
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('antd'), require('react-dom')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react', 'antd', 'react-dom'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ParamsAbout = {}, global.React, global.antd, global.ReactDOM));
+})(this, (function (exports, React, antd, ReactDOM) { 'use strict';
+
+  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+  function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+      Object.keys(e).forEach(function (k) {
+        if (k !== 'default') {
+          var d = Object.getOwnPropertyDescriptor(e, k);
+          Object.defineProperty(n, k, d.get ? d : {
+            enumerable: true,
+            get: function () { return e[k]; }
+          });
+        }
+      });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+  }
+
+  var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+  var React__namespace = /*#__PURE__*/_interopNamespace(React);
+  var ReactDOM__default = /*#__PURE__*/_interopDefaultLegacy(ReactDOM);
+
+  function _defineProperty$2(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 ownKeys$2(object, enumerableOnly) {
+    var keys = Object.keys(object);
+
+    if (Object.getOwnPropertySymbols) {
+      var symbols = Object.getOwnPropertySymbols(object);
+      if (enumerableOnly) symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+      keys.push.apply(keys, symbols);
+    }
+
+    return keys;
+  }
+
+  function _objectSpread2$2(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i] != null ? arguments[i] : {};
+
+      if (i % 2) {
+        ownKeys$2(Object(source), true).forEach(function (key) {
+          _defineProperty$2(target, key, source[key]);
+        });
+      } else if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+      } else {
+        ownKeys$2(Object(source)).forEach(function (key) {
+          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+      }
+    }
+
+    return target;
+  }
+
+  function _classCallCheck$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+
+  function _defineProperties$1(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$1(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties$1(Constructor, staticProps);
+    return Constructor;
+  }
+
+  function _assertThisInitialized(self) {
+    if (self === void 0) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+
+    return self;
+  }
+
+  function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+      o.__proto__ = p;
+      return o;
+    };
+
+    return _setPrototypeOf(o, p);
+  }
+
+  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
+      }
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+  }
+
+  function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+      return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+  }
+
+  function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+
+    try {
+      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  function _typeof$1(obj) {
+    "@babel/helpers - typeof";
+
+    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+      _typeof$1 = function _typeof(obj) {
+        return typeof obj;
+      };
+    } else {
+      _typeof$1 = function _typeof(obj) {
+        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+      };
+    }
+
+    return _typeof$1(obj);
+  }
+
+  function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof$1(call) === "object" || typeof call === "function")) {
+      return call;
+    }
+
+    return _assertThisInitialized(self);
+  }
+
+  function _createSuper(Derived) {
+    return function () {
+      var Super = _getPrototypeOf(Derived),
+          result;
+
+      if (_isNativeReflectConstruct()) {
+        var NewTarget = _getPrototypeOf(this).constructor;
+        result = Reflect.construct(Super, arguments, NewTarget);
+      } else {
+        result = Super.apply(this, arguments);
+      }
+
+      return _possibleConstructorReturn(this, result);
+    };
+  }
+
+  exports.ParamType = void 0;
+
+  (function (ParamType) {
+    ParamType[ParamType["ParamGroup"] = -1] = "ParamGroup";
+    ParamType[ParamType["Number"] = 1] = "Number";
+    ParamType[ParamType["Percentage"] = 2] = "Percentage";
+    ParamType[ParamType["Bool"] = 3] = "Bool";
+    ParamType[ParamType["NumberRange"] = 4] = "NumberRange";
+    ParamType[ParamType["PercentageRange"] = 5] = "PercentageRange";
+    ParamType[ParamType["ExpiryLimit"] = 6] = "ExpiryLimit";
+    ParamType[ParamType["Expiry"] = 7] = "Expiry";
+    ParamType[ParamType["Phone"] = 8] = "Phone";
+  })(exports.ParamType || (exports.ParamType = {}));
+
+  function _arrayWithHoles$1(arr) {
+    if (Array.isArray(arr)) return arr;
+  }
+
+  function _iterableToArrayLimit$1(arr, i) {
+    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _e = undefined;
+
+    try {
+      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+        _arr.push(_s.value);
+
+        if (i && _arr.length === i) break;
+      }
+    } catch (err) {
+      _d = true;
+      _e = err;
+    } finally {
+      try {
+        if (!_n && _i["return"] != null) _i["return"]();
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+
+    return _arr;
+  }
+
+  function _arrayLikeToArray$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+
+    for (var i = 0, arr2 = new Array(len); i < len; i++) {
+      arr2[i] = arr[i];
+    }
+
+    return arr2;
+  }
+
+  function _unsupportedIterableToArray$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen);
+  }
+
+  function _nonIterableRest$1() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+
+  function _slicedToArray$1(arr, i) {
+    return _arrayWithHoles$1(arr) || _iterableToArrayLimit$1(arr, i) || _unsupportedIterableToArray$1(arr, i) || _nonIterableRest$1();
+  }
+
+  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+  function createCommonjsModule(fn, module) {
+  	return module = { exports: {} }, fn(module, module.exports), module.exports;
+  }
+
+  var classnames = createCommonjsModule(function (module) {
+    /*!
+      Copyright (c) 2018 Jed Watson.
+      Licensed under the MIT License (MIT), see
+      http://jedwatson.github.io/classnames
+    */
+
+    /* global define */
+    (function () {
+
+      var hasOwn = {}.hasOwnProperty;
+
+      function classNames() {
+        var classes = [];
+
+        for (var i = 0; i < arguments.length; i++) {
+          var arg = arguments[i];
+          if (!arg) continue;
+          var argType = typeof arg;
+
+          if (argType === 'string' || argType === 'number') {
+            classes.push(arg);
+          } else if (Array.isArray(arg)) {
+            if (arg.length) {
+              var inner = classNames.apply(null, arg);
+
+              if (inner) {
+                classes.push(inner);
+              }
+            }
+          } else if (argType === 'object') {
+            if (arg.toString === Object.prototype.toString) {
+              for (var key in arg) {
+                if (hasOwn.call(arg, key) && arg[key]) {
+                  classes.push(key);
+                }
+              }
+            } else {
+              classes.push(arg.toString());
+            }
+          }
+        }
+
+        return classes.join(' ');
+      }
+
+      if (module.exports) {
+        classNames.default = classNames;
+        module.exports = classNames;
+      } else {
+        window.classNames = classNames;
+      }
+    })();
+  });
+
+  var dayjs_min = createCommonjsModule(function (module, exports) {
+    !function (t, e) {
+      module.exports = e() ;
+    }(commonjsGlobal, function () {
+
+      var t = 1e3,
+          e = 6e4,
+          n = 36e5,
+          r = "millisecond",
+          i = "second",
+          s = "minute",
+          u = "hour",
+          a = "day",
+          o = "week",
+          f = "month",
+          h = "quarter",
+          c = "year",
+          d = "date",
+          $ = "Invalid Date",
+          l = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/,
+          y = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,
+          M = {
+        name: "en",
+        weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),
+        months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_")
+      },
+          m = function (t, e, n) {
+        var r = String(t);
+        return !r || r.length >= e ? t : "" + Array(e + 1 - r.length).join(n) + t;
+      },
+          g = {
+        s: m,
+        z: function (t) {
+          var e = -t.utcOffset(),
+              n = Math.abs(e),
+              r = Math.floor(n / 60),
+              i = n % 60;
+          return (e <= 0 ? "+" : "-") + m(r, 2, "0") + ":" + m(i, 2, "0");
+        },
+        m: function t(e, n) {
+          if (e.date() < n.date()) return -t(n, e);
+          var r = 12 * (n.year() - e.year()) + (n.month() - e.month()),
+              i = e.clone().add(r, f),
+              s = n - i < 0,
+              u = e.clone().add(r + (s ? -1 : 1), f);
+          return +(-(r + (n - i) / (s ? i - u : u - i)) || 0);
+        },
+        a: function (t) {
+          return t < 0 ? Math.ceil(t) || 0 : Math.floor(t);
+        },
+        p: function (t) {
+          return {
+            M: f,
+            y: c,
+            w: o,
+            d: a,
+            D: d,
+            h: u,
+            m: s,
+            s: i,
+            ms: r,
+            Q: h
+          }[t] || String(t || "").toLowerCase().replace(/s$/, "");
+        },
+        u: function (t) {
+          return void 0 === t;
+        }
+      },
+          v = "en",
+          D = {};
+
+      D[v] = M;
+
+      var p = function (t) {
+        return t instanceof _;
+      },
+          S = function t(e, n, r) {
+        var i;
+        if (!e) return v;
+
+        if ("string" == typeof e) {
+          var s = e.toLowerCase();
+          D[s] && (i = s), n && (D[s] = n, i = s);
+          var u = e.split("-");
+          if (!i && u.length > 1) return t(u[0]);
+        } else {
+          var a = e.name;
+          D[a] = e, i = a;
+        }
+
+        return !r && i && (v = i), i || !r && v;
+      },
+          w = function (t, e) {
+        if (p(t)) return t.clone();
+        var n = "object" == typeof e ? e : {};
+        return n.date = t, n.args = arguments, new _(n);
+      },
+          O = g;
+
+      O.l = S, O.i = p, O.w = function (t, e) {
+        return w(t, {
+          locale: e.$L,
+          utc: e.$u,
+          x: e.$x,
+          $offset: e.$offset
+        });
+      };
+
+      var _ = function () {
+        function M(t) {
+          this.$L = S(t.locale, null, !0), this.parse(t);
+        }
+
+        var m = M.prototype;
+        return m.parse = function (t) {
+          this.$d = function (t) {
+            var e = t.date,
+                n = t.utc;
+            if (null === e) return new Date(NaN);
+            if (O.u(e)) return new Date();
+            if (e instanceof Date) return new Date(e);
+
+            if ("string" == typeof e && !/Z$/i.test(e)) {
+              var r = e.match(l);
+
+              if (r) {
+                var i = r[2] - 1 || 0,
+                    s = (r[7] || "0").substring(0, 3);
+                return n ? new Date(Date.UTC(r[1], i, r[3] || 1, r[4] || 0, r[5] || 0, r[6] || 0, s)) : new Date(r[1], i, r[3] || 1, r[4] || 0, r[5] || 0, r[6] || 0, s);
+              }
+            }
+
+            return new Date(e);
+          }(t), this.$x = t.x || {}, this.init();
+        }, m.init = function () {
+          var t = this.$d;
+          this.$y = t.getFullYear(), this.$M = t.getMonth(), this.$D = t.getDate(), this.$W = t.getDay(), this.$H = t.getHours(), this.$m = t.getMinutes(), this.$s = t.getSeconds(), this.$ms = t.getMilliseconds();
+        }, m.$utils = function () {
+          return O;
+        }, m.isValid = function () {
+          return !(this.$d.toString() === $);
+        }, m.isSame = function (t, e) {
+          var n = w(t);
+          return this.startOf(e) <= n && n <= this.endOf(e);
+        }, m.isAfter = function (t, e) {
+          return w(t) < this.startOf(e);
+        }, m.isBefore = function (t, e) {
+          return this.endOf(e) < w(t);
+        }, m.$g = function (t, e, n) {
+          return O.u(t) ? this[e] : this.set(n, t);
+        }, m.unix = function () {
+          return Math.floor(this.valueOf() / 1e3);
+        }, m.valueOf = function () {
+          return this.$d.getTime();
+        }, m.startOf = function (t, e) {
+          var n = this,
+              r = !!O.u(e) || e,
+              h = O.p(t),
+              $ = function (t, e) {
+            var i = O.w(n.$u ? Date.UTC(n.$y, e, t) : new Date(n.$y, e, t), n);
+            return r ? i : i.endOf(a);
+          },
+              l = function (t, e) {
+            return O.w(n.toDate()[t].apply(n.toDate("s"), (r ? [0, 0, 0, 0] : [23, 59, 59, 999]).slice(e)), n);
+          },
+              y = this.$W,
+              M = this.$M,
+              m = this.$D,
+              g = "set" + (this.$u ? "UTC" : "");
+
+          switch (h) {
+            case c:
+              return r ? $(1, 0) : $(31, 11);
+
+            case f:
+              return r ? $(1, M) : $(0, M + 1);
+
+            case o:
+              var v = this.$locale().weekStart || 0,
+                  D = (y < v ? y + 7 : y) - v;
+              return $(r ? m - D : m + (6 - D), M);
+
+            case a:
+            case d:
+              return l(g + "Hours", 0);
+
+            case u:
+              return l(g + "Minutes", 1);
+
+            case s:
+              return l(g + "Seconds", 2);
+
+            case i:
+              return l(g + "Milliseconds", 3);
+
+            default:
+              return this.clone();
+          }
+        }, m.endOf = function (t) {
+          return this.startOf(t, !1);
+        }, m.$set = function (t, e) {
+          var n,
+              o = O.p(t),
+              h = "set" + (this.$u ? "UTC" : ""),
+              $ = (n = {}, n[a] = h + "Date", n[d] = h + "Date", n[f] = h + "Month", n[c] = h + "FullYear", n[u] = h + "Hours", n[s] = h + "Minutes", n[i] = h + "Seconds", n[r] = h + "Milliseconds", n)[o],
+              l = o === a ? this.$D + (e - this.$W) : e;
+
+          if (o === f || o === c) {
+            var y = this.clone().set(d, 1);
+            y.$d[$](l), y.init(), this.$d = y.set(d, Math.min(this.$D, y.daysInMonth())).$d;
+          } else $ && this.$d[$](l);
+
+          return this.init(), this;
+        }, m.set = function (t, e) {
+          return this.clone().$set(t, e);
+        }, m.get = function (t) {
+          return this[O.p(t)]();
+        }, m.add = function (r, h) {
+          var d,
+              $ = this;
+          r = Number(r);
+
+          var l = O.p(h),
+              y = function (t) {
+            var e = w($);
+            return O.w(e.date(e.date() + Math.round(t * r)), $);
+          };
+
+          if (l === f) return this.set(f, this.$M + r);
+          if (l === c) return this.set(c, this.$y + r);
+          if (l === a) return y(1);
+          if (l === o) return y(7);
+          var M = (d = {}, d[s] = e, d[u] = n, d[i] = t, d)[l] || 1,
+              m = this.$d.getTime() + r * M;
+          return O.w(m, this);
+        }, m.subtract = function (t, e) {
+          return this.add(-1 * t, e);
+        }, m.format = function (t) {
+          var e = this,
+              n = this.$locale();
+          if (!this.isValid()) return n.invalidDate || $;
+
+          var r = t || "YYYY-MM-DDTHH:mm:ssZ",
+              i = O.z(this),
+              s = this.$H,
+              u = this.$m,
+              a = this.$M,
+              o = n.weekdays,
+              f = n.months,
+              h = function (t, n, i, s) {
+            return t && (t[n] || t(e, r)) || i[n].substr(0, s);
+          },
+              c = function (t) {
+            return O.s(s % 12 || 12, t, "0");
+          },
+              d = n.meridiem || function (t, e, n) {
+            var r = t < 12 ? "AM" : "PM";
+            return n ? r.toLowerCase() : r;
+          },
+              l = {
+            YY: String(this.$y).slice(-2),
+            YYYY: this.$y,
+            M: a + 1,
+            MM: O.s(a + 1, 2, "0"),
+            MMM: h(n.monthsShort, a, f, 3),
+            MMMM: h(f, a),
+            D: this.$D,
+            DD: O.s(this.$D, 2, "0"),
+            d: String(this.$W),
+            dd: h(n.weekdaysMin, this.$W, o, 2),
+            ddd: h(n.weekdaysShort, this.$W, o, 3),
+            dddd: o[this.$W],
+            H: String(s),
+            HH: O.s(s, 2, "0"),
+            h: c(1),
+            hh: c(2),
+            a: d(s, u, !0),
+            A: d(s, u, !1),
+            m: String(u),
+            mm: O.s(u, 2, "0"),
+            s: String(this.$s),
+            ss: O.s(this.$s, 2, "0"),
+            SSS: O.s(this.$ms, 3, "0"),
+            Z: i
+          };
+
+          return r.replace(y, function (t, e) {
+            return e || l[t] || i.replace(":", "");
+          });
+        }, m.utcOffset = function () {
+          return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
+        }, m.diff = function (r, d, $) {
+          var l,
+              y = O.p(d),
+              M = w(r),
+              m = (M.utcOffset() - this.utcOffset()) * e,
+              g = this - M,
+              v = O.m(this, M);
+          return v = (l = {}, l[c] = v / 12, l[f] = v, l[h] = v / 3, l[o] = (g - m) / 6048e5, l[a] = (g - m) / 864e5, l[u] = g / n, l[s] = g / e, l[i] = g / t, l)[y] || g, $ ? v : O.a(v);
+        }, m.daysInMonth = function () {
+          return this.endOf(f).$D;
+        }, m.$locale = function () {
+          return D[this.$L];
+        }, m.locale = function (t, e) {
+          if (!t) return this.$L;
+          var n = this.clone(),
+              r = S(t, e, !0);
+          return r && (n.$L = r), n;
+        }, m.clone = function () {
+          return O.w(this.$d, this);
+        }, m.toDate = function () {
+          return new Date(this.valueOf());
+        }, m.toJSON = function () {
+          return this.isValid() ? this.toISOString() : null;
+        }, m.toISOString = function () {
+          return this.$d.toISOString();
+        }, m.toString = function () {
+          return this.$d.toUTCString();
+        }, M;
+      }(),
+          b = _.prototype;
+
+      return w.prototype = b, [["$ms", r], ["$s", i], ["$m", s], ["$H", u], ["$W", a], ["$M", f], ["$y", c], ["$D", d]].forEach(function (t) {
+        b[t[1]] = function (e) {
+          return this.$g(e, t[0], t[1]);
+        };
+      }), w.extend = function (t, e) {
+        return t.$i || (t(e, _, w), t.$i = !0), w;
+      }, w.locale = S, w.isDayjs = p, w.unix = function (t) {
+        return w(1e3 * t);
+      }, w.en = D[v], w.Ls = D, w.p = {}, w;
+    });
+  });
+
+  var utc = createCommonjsModule(function (module, exports) {
+    !function (t, i) {
+      module.exports = i() ;
+    }(commonjsGlobal, function () {
+
+      var t = "minute",
+          i = /[+-]\d\d(?::?\d\d)?/g,
+          e = /([+-]|\d\d)/g;
+      return function (s, f, n) {
+        var u = f.prototype;
+        n.utc = function (t) {
+          var i = {
+            date: t,
+            utc: !0,
+            args: arguments
+          };
+          return new f(i);
+        }, u.utc = function (i) {
+          var e = n(this.toDate(), {
+            locale: this.$L,
+            utc: !0
+          });
+          return i ? e.add(this.utcOffset(), t) : e;
+        }, u.local = function () {
+          return n(this.toDate(), {
+            locale: this.$L,
+            utc: !1
+          });
+        };
+        var o = u.parse;
+
+        u.parse = function (t) {
+          t.utc && (this.$u = !0), this.$utils().u(t.$offset) || (this.$offset = t.$offset), o.call(this, t);
+        };
+
+        var r = u.init;
+
+        u.init = function () {
+          if (this.$u) {
+            var t = this.$d;
+            this.$y = t.getUTCFullYear(), this.$M = t.getUTCMonth(), this.$D = t.getUTCDate(), this.$W = t.getUTCDay(), this.$H = t.getUTCHours(), this.$m = t.getUTCMinutes(), this.$s = t.getUTCSeconds(), this.$ms = t.getUTCMilliseconds();
+          } else r.call(this);
+        };
+
+        var a = u.utcOffset;
+
+        u.utcOffset = function (s, f) {
+          var n = this.$utils().u;
+          if (n(s)) return this.$u ? 0 : n(this.$offset) ? a.call(this) : this.$offset;
+          if ("string" == typeof s && (s = function (t) {
+            void 0 === t && (t = "");
+            var s = t.match(i);
+            if (!s) return null;
+            var f = ("" + s[0]).match(e) || ["-", 0, 0],
+                n = f[0],
+                u = 60 * +f[1] + +f[2];
+            return 0 === u ? 0 : "+" === n ? u : -u;
+          }(s), null === s)) return this;
+          var u = Math.abs(s) <= 16 ? 60 * s : s,
+              o = this;
+          if (f) return o.$offset = u, o.$u = 0 === s, o;
+
+          if (0 !== s) {
+            var r = this.$u ? this.toDate().getTimezoneOffset() : -1 * this.utcOffset();
+            (o = this.local().add(u + r, t)).$offset = u, o.$x.$localOffset = r;
+          } else o = this.utc();
+
+          return o;
+        };
+
+        var h = u.format;
+        u.format = function (t) {
+          var i = t || (this.$u ? "YYYY-MM-DDTHH:mm:ss[Z]" : "");
+          return h.call(this, i);
+        }, u.valueOf = function () {
+          var t = this.$utils().u(this.$offset) ? 0 : this.$offset + (this.$x.$localOffset || new Date().getTimezoneOffset());
+          return this.$d.valueOf() - 6e4 * t;
+        }, u.isUTC = function () {
+          return !!this.$u;
+        }, u.toISOString = function () {
+          return this.toDate().toISOString();
+        }, u.toString = function () {
+          return this.toDate().toUTCString();
+        };
+        var l = u.toDate;
+
+        u.toDate = function (t) {
+          return "s" === t && this.$offset ? n(this.format("YYYY-MM-DD HH:mm:ss:SSS")).toDate() : l.call(this);
+        };
+
+        var c = u.diff;
+
+        u.diff = function (t, i, e) {
+          if (t && this.$u === t.$u) return c.call(this, t, i, e);
+          var s = this.local(),
+              f = n(t).local();
+          return c.call(s, f, i, e);
+        };
+      };
+    });
+  });
+
+  dayjs_min.extend(utc);
+  function formatNum(val) {
+    var num = parseFloat(val);
+    return isNaN(num) ? undefined : num;
+  }
+  function isNullLike(val) {
+    return val === undefined || val === null;
+  }
+  function emptyValidator(val, enableEmpty) {
+    return !enableEmpty && (isNullLike(val) || val instanceof Array && !val.length || typeof val === 'string' && !val) ? 'Should not be empty' : '';
+  }
+  function numRangeValidator(val, enableEmpty) {
+    var error = emptyValidator(val === null || val === void 0 ? void 0 : val.min, enableEmpty);
+
+    if (error) {
+      // return { min: error }
+      return "Min: ".concat(error);
+    }
+
+    error = emptyValidator(val === null || val === void 0 ? void 0 : val.max, enableEmpty);
+
+    if (error) {
+      // return { max: error }
+      return "Max: ".concat(error);
+    }
+
+    return val.min > val.max ? 'Max should bigger than Min' : '';
+  }
+  function expiryValidator(val, enableEmpty) {
+    var error = emptyValidator(val, enableEmpty);
+    if (error) return error;
+    var $val = dayjs_min(val, 'DDMMMYY').format('DDMMMYY').toUpperCase();
+    if ($val !== val) return 'Out of format';
+    return '';
+  }
+  function expiriesValidator(val) {
+    for (var i = 0; i < val.length; i++) {
+      var error = expiryValidator(val[i]);
+
+      if (error) {
+        // return { [i]: error }
+        return "The ".concat(i + 1, "th item: ").concat(error);
+      }
+    }
+
+    return '';
+  }
+  function keyValidator(val) {
+    var error = emptyValidator(val);
+    if (error) return error;
+    return /^[_.a-zA-Z0-9]+$/.test(val) ? '' : 'Out of format: should be a combination of the following chars `_.0-9a-zA-Z`';
+  }
+  function isExpired(val) {
+    if (!val) return false;
+    var now = dayjs_min();
+    var expireTime = dayjs_min.utc("".concat(val, " 8:00"), 'DDMMMYY 8:00');
+    return now >= expireTime;
+  }
+  function validatorCvt(validator, form) {
+    return function (_, val) {
+      var $form = form === null || form === void 0 ? void 0 : form();
+      var error = validator(val, $form === null || $form === void 0 ? void 0 : $form.getFieldsValue());
+      if (!error) return Promise.resolve();
+
+      var traverse = function traverse(obj) {
+        if (typeof obj === 'string' && obj) return Promise.reject(new Error(obj));
+
+        if (obj && _typeof$1(obj) === 'object') {
+          for (var key in obj) {
+            var res = traverse(obj[key]);
+            if (res) return res;
+          }
+        }
+      };
+
+      return traverse(error) || Promise.resolve();
+    };
+  }
+
+  var Bool = /*#__PURE__*/function (_PureComponent) {
+    _inherits(Bool, _PureComponent);
+
+    var _super = _createSuper(Bool);
+
+    function Bool() {
+      var _this;
+
+      _classCallCheck$1(this, Bool);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _super.call.apply(_super, [this].concat(args));
+
+      _defineProperty$2(_assertThisInitialized(_this), "options", [{
+        label: 'TRUE',
+        value: true
+      }, {
+        label: 'FALSE',
+        value: false
+      }]);
+
+      _defineProperty$2(_assertThisInitialized(_this), "RadioChecked", /*#__PURE__*/React__default["default"].createElement("svg", {
+        width: "16",
+        height: "17",
+        viewBox: "0 0 16 17",
+        fill: "none",
+        xmlns: "http://www.w3.org/2000/svg"
+      }, /*#__PURE__*/React__default["default"].createElement("g", {
+        clipPath: "url(#clip0_0_7934)"
+      }, /*#__PURE__*/React__default["default"].createElement("circle", {
+        cx: "8",
+        cy: "8.5",
+        r: "7.5",
+        fill: "none",
+        stroke: "currentColor"
+      }), /*#__PURE__*/React__default["default"].createElement("circle", {
+        cx: "8",
+        cy: "8.5",
+        r: "4",
+        fill: "currentColor"
+      })), /*#__PURE__*/React__default["default"].createElement("defs", null, /*#__PURE__*/React__default["default"].createElement("clipPath", {
+        id: "clip0_0_7934"
+      }, /*#__PURE__*/React__default["default"].createElement("rect", {
+        width: "16",
+        height: "16",
+        fill: "white",
+        transform: "translate(0 0.5)"
+      })))));
+
+      _defineProperty$2(_assertThisInitialized(_this), "RadioUnchecked", /*#__PURE__*/React__default["default"].createElement("svg", {
+        width: "16",
+        height: "17",
+        viewBox: "0 0 16 17",
+        fill: "none",
+        xmlns: "http://www.w3.org/2000/svg"
+      }, /*#__PURE__*/React__default["default"].createElement("circle", {
+        cx: "8",
+        cy: "8.5",
+        r: "7.5",
+        fill: "none",
+        stroke: "currentColor"
+      })));
+
+      _defineProperty$2(_assertThisInitialized(_this), "onChange", function (val) {
+        var _this$props$onChange, _this$props, _this$props$onBlur, _this$props2;
+
+        (_this$props$onChange = (_this$props = _this.props).onChange) === null || _this$props$onChange === void 0 ? void 0 : _this$props$onChange.call(_this$props, val);
+        (_this$props$onBlur = (_this$props2 = _this.props).onBlur) === null || _this$props$onBlur === void 0 ? void 0 : _this$props$onBlur.call(_this$props2);
+      });
+
+      return _this;
+    }
+
+    _createClass$1(Bool, [{
+      key: "render",
+      value: function render() {
+        var _this2 = this;
+
+        return /*#__PURE__*/React__default["default"].createElement("div", {
+          className: classnames('param-bool', {
+            readonly: this.props.readonly
+          }, this.props.className),
+          style: this.props.style
+        }, this.props.readonly ? /*#__PURE__*/React__default["default"].createElement("span", {
+          className: "param-bool-val"
+        }, !isNullLike(this.props.value) ? String(this.props.value).toUpperCase() : '-') : this.options.map(function (it) {
+          var active = it.value === _this2.props.value;
+          return /*#__PURE__*/React__default["default"].createElement("div", {
+            key: String(it.value),
+            className: classnames('param-bool-option', {
+              active: active
+            }),
+            onClick: _this2.onChange.bind(null, it.value)
+          }, active ? _this2.RadioChecked : _this2.RadioUnchecked, it.label);
+        }));
+      }
+    }]);
+
+    return Bool;
+  }(React.PureComponent);
+
+  /*
+   *  big.js v6.1.1
+   *  A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic.
+   *  Copyright (c) 2021 Michael Mclaughlin
+   *  https://github.com/MikeMcl/big.js/LICENCE.md
+   */
+
+  /************************************** EDITABLE DEFAULTS *****************************************/
+  // The default values below must be integers within the stated ranges.
+
+  /*
+   * The maximum number of decimal places (DP) of the results of operations involving division:
+   * div and sqrt, and pow with negative exponents.
+   */
+  var DP = 20,
+      // 0 to MAX_DP
+
+  /*
+   * The rounding mode (RM) used when rounding to the above decimal places.
+   *
+   *  0  Towards zero (i.e. truncate, no rounding).       (ROUND_DOWN)
+   *  1  To nearest neighbour. If equidistant, round up.  (ROUND_HALF_UP)
+   *  2  To nearest neighbour. If equidistant, to even.   (ROUND_HALF_EVEN)
+   *  3  Away from zero.                                  (ROUND_UP)
+   */
+  RM = 1,
+      // 0, 1, 2 or 3
+  // The maximum value of DP and Big.DP.
+  MAX_DP = 1E6,
+      // 0 to 1000000
+  // The maximum magnitude of the exponent argument to the pow method.
+  MAX_POWER = 1E6,
+      // 1 to 1000000
+
+  /*
+   * The negative exponent (NE) at and beneath which toString returns exponential notation.
+   * (JavaScript numbers: -7)
+   * -1000000 is the minimum recommended exponent value of a Big.
+   */
+  NE = -7,
+      // 0 to -1000000
+
+  /*
+   * The positive exponent (PE) at and above which toString returns exponential notation.
+   * (JavaScript numbers: 21)
+   * 1000000 is the maximum recommended exponent value of a Big, but this limit is not enforced.
+   */
+  PE = 21,
+      // 0 to 1000000
+
+  /*
+   * When true, an error will be thrown if a primitive number is passed to the Big constructor,
+   * or if valueOf is called, or if toNumber is called on a Big which cannot be converted to a
+   * primitive number without a loss of precision.
+   */
+  STRICT = false,
+      // true or false
+
+  /**************************************************************************************************/
+  // Error messages.
+  NAME = '[big.js] ',
+      INVALID = NAME + 'Invalid ',
+      INVALID_DP = INVALID + 'decimal places',
+      INVALID_RM = INVALID + 'rounding mode',
+      DIV_BY_ZERO = NAME + 'Division by zero',
+      // The shared prototype object.
+  P = {},
+      UNDEFINED = void 0,
+      NUMERIC = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;
+  /*
+   * Create and return a Big constructor.
+   */
+
+  function _Big_() {
+    /*
+     * The Big constructor and exported function.
+     * Create and return a new instance of a Big number object.
+     *
+     * n {number|string|Big} A numeric value.
+     */
+    function Big(n) {
+      var x = this; // Enable constructor usage without new.
+
+      if (!(x instanceof Big)) return n === UNDEFINED ? _Big_() : new Big(n); // Duplicate.
+
+      if (n instanceof Big) {
+        x.s = n.s;
+        x.e = n.e;
+        x.c = n.c.slice();
+      } else {
+        if (typeof n !== 'string') {
+          if (Big.strict === true) {
+            throw TypeError(INVALID + 'number');
+          } // Minus zero?
+
+
+          n = n === 0 && 1 / n < 0 ? '-0' : String(n);
+        }
+
+        parse(x, n);
+      } // Retain a reference to this Big constructor.
+      // Shadow Big.prototype.constructor which points to Object.
+
+
+      x.constructor = Big;
+    }
+
+    Big.prototype = P;
+    Big.DP = DP;
+    Big.RM = RM;
+    Big.NE = NE;
+    Big.PE = PE;
+    Big.strict = STRICT;
+    Big.roundDown = 0;
+    Big.roundHalfUp = 1;
+    Big.roundHalfEven = 2;
+    Big.roundUp = 3;
+    return Big;
+  }
+  /*
+   * Parse the number or string value passed to a Big constructor.
+   *
+   * x {Big} A Big number instance.
+   * n {number|string} A numeric value.
+   */
+
+
+  function parse(x, n) {
+    var e, i, nl;
+
+    if (!NUMERIC.test(n)) {
+      throw Error(INVALID + 'number');
+    } // Determine sign.
+
+
+    x.s = n.charAt(0) == '-' ? (n = n.slice(1), -1) : 1; // Decimal point?
+
+    if ((e = n.indexOf('.')) > -1) n = n.replace('.', ''); // Exponential form?
+
+    if ((i = n.search(/e/i)) > 0) {
+      // Determine exponent.
+      if (e < 0) e = i;
+      e += +n.slice(i + 1);
+      n = n.substring(0, i);
+    } else if (e < 0) {
+      // Integer.
+      e = n.length;
+    }
+
+    nl = n.length; // Determine leading zeros.
+
+    for (i = 0; i < nl && n.charAt(i) == '0';) ++i;
+
+    if (i == nl) {
+      // Zero.
+      x.c = [x.e = 0];
+    } else {
+      // Determine trailing zeros.
+      for (; nl > 0 && n.charAt(--nl) == '0';);
+
+      x.e = e - i - 1;
+      x.c = []; // Convert string to array of digits without leading/trailing zeros.
+
+      for (e = 0; i <= nl;) x.c[e++] = +n.charAt(i++);
+    }
+
+    return x;
+  }
+  /*
+   * Round Big x to a maximum of sd significant digits using rounding mode rm.
+   *
+   * x {Big} The Big to round.
+   * sd {number} Significant digits: integer, 0 to MAX_DP inclusive.
+   * rm {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
+   * [more] {boolean} Whether the result of division was truncated.
+   */
+
+
+  function round(x, sd, rm, more) {
+    var xc = x.c;
+    if (rm === UNDEFINED) rm = x.constructor.RM;
+
+    if (rm !== 0 && rm !== 1 && rm !== 2 && rm !== 3) {
+      throw Error(INVALID_RM);
+    }
+
+    if (sd < 1) {
+      more = rm === 3 && (more || !!xc[0]) || sd === 0 && (rm === 1 && xc[0] >= 5 || rm === 2 && (xc[0] > 5 || xc[0] === 5 && (more || xc[1] !== UNDEFINED)));
+      xc.length = 1;
+
+      if (more) {
+        // 1, 0.1, 0.01, 0.001, 0.0001 etc.
+        x.e = x.e - sd + 1;
+        xc[0] = 1;
+      } else {
+        // Zero.
+        xc[0] = x.e = 0;
+      }
+    } else if (sd < xc.length) {
+      // xc[sd] is the digit after the digit that may be rounded up.
+      more = rm === 1 && xc[sd] >= 5 || rm === 2 && (xc[sd] > 5 || xc[sd] === 5 && (more || xc[sd + 1] !== UNDEFINED || xc[sd - 1] & 1)) || rm === 3 && (more || !!xc[0]); // Remove any digits after the required precision.
+
+      xc.length = sd--; // Round up?
+
+      if (more) {
+        // Rounding up may mean the previous digit has to be rounded up.
+        for (; ++xc[sd] > 9;) {
+          xc[sd] = 0;
+
+          if (!sd--) {
+            ++x.e;
+            xc.unshift(1);
+          }
+        }
+      } // Remove trailing zeros.
+
+
+      for (sd = xc.length; !xc[--sd];) xc.pop();
+    }
+
+    return x;
+  }
+  /*
+   * Return a string representing the value of Big x in normal or exponential notation.
+   * Handles P.toExponential, P.toFixed, P.toJSON, P.toPrecision, P.toString and P.valueOf.
+   */
+
+
+  function stringify(x, doExponential, isNonzero) {
+    var e = x.e,
+        s = x.c.join(''),
+        n = s.length; // Exponential notation?
+
+    if (doExponential) {
+      s = s.charAt(0) + (n > 1 ? '.' + s.slice(1) : '') + (e < 0 ? 'e' : 'e+') + e; // Normal notation.
+    } else if (e < 0) {
+      for (; ++e;) s = '0' + s;
+
+      s = '0.' + s;
+    } else if (e > 0) {
+      if (++e > n) {
+        for (e -= n; e--;) s += '0';
+      } else if (e < n) {
+        s = s.slice(0, e) + '.' + s.slice(e);
+      }
+    } else if (n > 1) {
+      s = s.charAt(0) + '.' + s.slice(1);
+    }
+
+    return x.s < 0 && isNonzero ? '-' + s : s;
+  } // Prototype/instance methods
+
+  /*
+   * Return a new Big whose value is the absolute value of this Big.
+   */
+
+
+  P.abs = function () {
+    var x = new this.constructor(this);
+    x.s = 1;
+    return x;
+  };
+  /*
+   * Return 1 if the value of this Big is greater than the value of Big y,
+   *       -1 if the value of this Big is less than the value of Big y, or
+   *        0 if they have the same value.
+   */
+
+
+  P.cmp = function (y) {
+    var isneg,
+        x = this,
+        xc = x.c,
+        yc = (y = new x.constructor(y)).c,
+        i = x.s,
+        j = y.s,
+        k = x.e,
+        l = y.e; // Either zero?
+
+    if (!xc[0] || !yc[0]) return !xc[0] ? !yc[0] ? 0 : -j : i; // Signs differ?
+
+    if (i != j) return i;
+    isneg = i < 0; // Compare exponents.
+
+    if (k != l) return k > l ^ isneg ? 1 : -1;
+    j = (k = xc.length) < (l = yc.length) ? k : l; // Compare digit by digit.
+
+    for (i = -1; ++i < j;) {
+      if (xc[i] != yc[i]) return xc[i] > yc[i] ^ isneg ? 1 : -1;
+    } // Compare lengths.
+
+
+    return k == l ? 0 : k > l ^ isneg ? 1 : -1;
+  };
+  /*
+   * Return a new Big whose value is the value of this Big divided by the value of Big y, rounded,
+   * if necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
+   */
+
+
+  P.div = function (y) {
+    var x = this,
+        Big = x.constructor,
+        a = x.c,
+        // dividend
+    b = (y = new Big(y)).c,
+        // divisor
+    k = x.s == y.s ? 1 : -1,
+        dp = Big.DP;
+
+    if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {
+      throw Error(INVALID_DP);
+    } // Divisor is zero?
+
+
+    if (!b[0]) {
+      throw Error(DIV_BY_ZERO);
+    } // Dividend is 0? Return +-0.
+
+
+    if (!a[0]) {
+      y.s = k;
+      y.c = [y.e = 0];
+      return y;
+    }
+
+    var bl,
+        bt,
+        n,
+        cmp,
+        ri,
+        bz = b.slice(),
+        ai = bl = b.length,
+        al = a.length,
+        r = a.slice(0, bl),
+        // remainder
+    rl = r.length,
+        q = y,
+        // quotient
+    qc = q.c = [],
+        qi = 0,
+        p = dp + (q.e = x.e - y.e) + 1; // precision of the result
+
+    q.s = k;
+    k = p < 0 ? 0 : p; // Create version of divisor with leading zero.
+
+    bz.unshift(0); // Add zeros to make remainder as long as divisor.
+
+    for (; rl++ < bl;) r.push(0);
+
+    do {
+      // n is how many times the divisor goes into current remainder.
+      for (n = 0; n < 10; n++) {
+        // Compare divisor and remainder.
+        if (bl != (rl = r.length)) {
+          cmp = bl > rl ? 1 : -1;
+        } else {
+          for (ri = -1, cmp = 0; ++ri < bl;) {
+            if (b[ri] != r[ri]) {
+              cmp = b[ri] > r[ri] ? 1 : -1;
+              break;
+            }
+          }
+        } // If divisor < remainder, subtract divisor from remainder.
+
+
+        if (cmp < 0) {
+          // Remainder can't be more than 1 digit longer than divisor.
+          // Equalise lengths using divisor with extra leading zero?
+          for (bt = rl == bl ? b : bz; rl;) {
+            if (r[--rl] < bt[rl]) {
+              ri = rl;
+
+              for (; ri && !r[--ri];) r[ri] = 9;
+
+              --r[ri];
+              r[rl] += 10;
+            }
+
+            r[rl] -= bt[rl];
+          }
+
+          for (; !r[0];) r.shift();
+        } else {
+          break;
+        }
+      } // Add the digit n to the result array.
+
+
+      qc[qi++] = cmp ? n : ++n; // Update the remainder.
+
+      if (r[0] && cmp) r[rl] = a[ai] || 0;else r = [a[ai]];
+    } while ((ai++ < al || r[0] !== UNDEFINED) && k--); // Leading zero? Do not remove if result is simply zero (qi == 1).
+
+
+    if (!qc[0] && qi != 1) {
+      // There can't be more than one zero.
+      qc.shift();
+      q.e--;
+      p--;
+    } // Round?
+
+
+    if (qi > p) round(q, p, Big.RM, r[0] !== UNDEFINED);
+    return q;
+  };
+  /*
+   * Return true if the value of this Big is equal to the value of Big y, otherwise return false.
+   */
+
+
+  P.eq = function (y) {
+    return this.cmp(y) === 0;
+  };
+  /*
+   * Return true if the value of this Big is greater than the value of Big y, otherwise return
+   * false.
+   */
+
+
+  P.gt = function (y) {
+    return this.cmp(y) > 0;
+  };
+  /*
+   * Return true if the value of this Big is greater than or equal to the value of Big y, otherwise
+   * return false.
+   */
+
+
+  P.gte = function (y) {
+    return this.cmp(y) > -1;
+  };
+  /*
+   * Return true if the value of this Big is less than the value of Big y, otherwise return false.
+   */
+
+
+  P.lt = function (y) {
+    return this.cmp(y) < 0;
+  };
+  /*
+   * Return true if the value of this Big is less than or equal to the value of Big y, otherwise
+   * return false.
+   */
+
+
+  P.lte = function (y) {
+    return this.cmp(y) < 1;
+  };
+  /*
+   * Return a new Big whose value is the value of this Big minus the value of Big y.
+   */
+
+
+  P.minus = P.sub = function (y) {
+    var i,
+        j,
+        t,
+        xlty,
+        x = this,
+        Big = x.constructor,
+        a = x.s,
+        b = (y = new Big(y)).s; // Signs differ?
+
+    if (a != b) {
+      y.s = -b;
+      return x.plus(y);
+    }
+
+    var xc = x.c.slice(),
+        xe = x.e,
+        yc = y.c,
+        ye = y.e; // Either zero?
+
+    if (!xc[0] || !yc[0]) {
+      if (yc[0]) {
+        y.s = -b;
+      } else if (xc[0]) {
+        y = new Big(x);
+      } else {
+        y.s = 1;
+      }
+
+      return y;
+    } // Determine which is the bigger number. Prepend zeros to equalise exponents.
+
+
+    if (a = xe - ye) {
+      if (xlty = a < 0) {
+        a = -a;
+        t = xc;
+      } else {
+        ye = xe;
+        t = yc;
+      }
+
+      t.reverse();
+
+      for (b = a; b--;) t.push(0);
+
+      t.reverse();
+    } else {
+      // Exponents equal. Check digit by digit.
+      j = ((xlty = xc.length < yc.length) ? xc : yc).length;
+
+      for (a = b = 0; b < j; b++) {
+        if (xc[b] != yc[b]) {
+          xlty = xc[b] < yc[b];
+          break;
+        }
+      }
+    } // x < y? Point xc to the array of the bigger number.
+
+
+    if (xlty) {
+      t = xc;
+      xc = yc;
+      yc = t;
+      y.s = -y.s;
+    }
+    /*
+     * Append zeros to xc if shorter. No need to add zeros to yc if shorter as subtraction only
+     * needs to start at yc.length.
+     */
+
+
+    if ((b = (j = yc.length) - (i = xc.length)) > 0) for (; b--;) xc[i++] = 0; // Subtract yc from xc.
+
+    for (b = i; j > a;) {
+      if (xc[--j] < yc[j]) {
+        for (i = j; i && !xc[--i];) xc[i] = 9;
+
+        --xc[i];
+        xc[j] += 10;
+      }
+
+      xc[j] -= yc[j];
+    } // Remove trailing zeros.
+
+
+    for (; xc[--b] === 0;) xc.pop(); // Remove leading zeros and adjust exponent accordingly.
+
+
+    for (; xc[0] === 0;) {
+      xc.shift();
+      --ye;
+    }
+
+    if (!xc[0]) {
+      // n - n = +0
+      y.s = 1; // Result must be zero.
+
+      xc = [ye = 0];
+    }
+
+    y.c = xc;
+    y.e = ye;
+    return y;
+  };
+  /*
+   * Return a new Big whose value is the value of this Big modulo the value of Big y.
+   */
+
+
+  P.mod = function (y) {
+    var ygtx,
+        x = this,
+        Big = x.constructor,
+        a = x.s,
+        b = (y = new Big(y)).s;
+
+    if (!y.c[0]) {
+      throw Error(DIV_BY_ZERO);
+    }
+
+    x.s = y.s = 1;
+    ygtx = y.cmp(x) == 1;
+    x.s = a;
+    y.s = b;
+    if (ygtx) return new Big(x);
+    a = Big.DP;
+    b = Big.RM;
+    Big.DP = Big.RM = 0;
+    x = x.div(y);
+    Big.DP = a;
+    Big.RM = b;
+    return this.minus(x.times(y));
+  };
+  /*
+   * Return a new Big whose value is the value of this Big plus the value of Big y.
+   */
+
+
+  P.plus = P.add = function (y) {
+    var e,
+        k,
+        t,
+        x = this,
+        Big = x.constructor;
+    y = new Big(y); // Signs differ?
+
+    if (x.s != y.s) {
+      y.s = -y.s;
+      return x.minus(y);
+    }
+
+    var xe = x.e,
+        xc = x.c,
+        ye = y.e,
+        yc = y.c; // Either zero?
+
+    if (!xc[0] || !yc[0]) {
+      if (!yc[0]) {
+        if (xc[0]) {
+          y = new Big(x);
+        } else {
+          y.s = x.s;
+        }
+      }
+
+      return y;
+    }
+
+    xc = xc.slice(); // Prepend zeros to equalise exponents.
+    // Note: reverse faster than unshifts.
+
+    if (e = xe - ye) {
+      if (e > 0) {
+        ye = xe;
+        t = yc;
+      } else {
+        e = -e;
+        t = xc;
+      }
+
+      t.reverse();
+
+      for (; e--;) t.push(0);
+
+      t.reverse();
+    } // Point xc to the longer array.
+
+
+    if (xc.length - yc.length < 0) {
+      t = yc;
+      yc = xc;
+      xc = t;
+    }
+
+    e = yc.length; // Only start adding at yc.length - 1 as the further digits of xc can be left as they are.
+
+    for (k = 0; e; xc[e] %= 10) k = (xc[--e] = xc[e] + yc[e] + k) / 10 | 0; // No need to check for zero, as +x + +y != 0 && -x + -y != 0
+
+
+    if (k) {
+      xc.unshift(k);
+      ++ye;
+    } // Remove trailing zeros.
+
+
+    for (e = xc.length; xc[--e] === 0;) xc.pop();
+
+    y.c = xc;
+    y.e = ye;
+    return y;
+  };
+  /*
+   * Return a Big whose value is the value of this Big raised to the power n.
+   * If n is negative, round to a maximum of Big.DP decimal places using rounding
+   * mode Big.RM.
+   *
+   * n {number} Integer, -MAX_POWER to MAX_POWER inclusive.
+   */
+
+
+  P.pow = function (n) {
+    var x = this,
+        one = new x.constructor('1'),
+        y = one,
+        isneg = n < 0;
+
+    if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER) {
+      throw Error(INVALID + 'exponent');
+    }
+
+    if (isneg) n = -n;
+
+    for (;;) {
+      if (n & 1) y = y.times(x);
+      n >>= 1;
+      if (!n) break;
+      x = x.times(x);
+    }
+
+    return isneg ? one.div(y) : y;
+  };
+  /*
+   * Return a new Big whose value is the value of this Big rounded to a maximum precision of sd
+   * significant digits using rounding mode rm, or Big.RM if rm is not specified.
+   *
+   * sd {number} Significant digits: integer, 1 to MAX_DP inclusive.
+   * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
+   */
+
+
+  P.prec = function (sd, rm) {
+    if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {
+      throw Error(INVALID + 'precision');
+    }
+
+    return round(new this.constructor(this), sd, rm);
+  };
+  /*
+   * Return a new Big whose value is the value of this Big rounded to a maximum of dp decimal places
+   * using rounding mode rm, or Big.RM if rm is not specified.
+   * If dp is negative, round to an integer which is a multiple of 10**-dp.
+   * If dp is not specified, round to 0 decimal places.
+   *
+   * dp? {number} Integer, -MAX_DP to MAX_DP inclusive.
+   * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
+   */
+
+
+  P.round = function (dp, rm) {
+    if (dp === UNDEFINED) dp = 0;else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP) {
+      throw Error(INVALID_DP);
+    }
+    return round(new this.constructor(this), dp + this.e + 1, rm);
+  };
+  /*
+   * Return a new Big whose value is the square root of the value of this Big, rounded, if
+   * necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
+   */
+
+
+  P.sqrt = function () {
+    var r,
+        c,
+        t,
+        x = this,
+        Big = x.constructor,
+        s = x.s,
+        e = x.e,
+        half = new Big('0.5'); // Zero?
+
+    if (!x.c[0]) return new Big(x); // Negative?
+
+    if (s < 0) {
+      throw Error(NAME + 'No square root');
+    } // Estimate.
+
+
+    s = Math.sqrt(x + ''); // Math.sqrt underflow/overflow?
+    // Re-estimate: pass x coefficient to Math.sqrt as integer, then adjust the result exponent.
+
+    if (s === 0 || s === 1 / 0) {
+      c = x.c.join('');
+      if (!(c.length + e & 1)) c += '0';
+      s = Math.sqrt(c);
+      e = ((e + 1) / 2 | 0) - (e < 0 || e & 1);
+      r = new Big((s == 1 / 0 ? '5e' : (s = s.toExponential()).slice(0, s.indexOf('e') + 1)) + e);
+    } else {
+      r = new Big(s + '');
+    }
+
+    e = r.e + (Big.DP += 4); // Newton-Raphson iteration.
+
+    do {
+      t = r;
+      r = half.times(t.plus(x.div(t)));
+    } while (t.c.slice(0, e).join('') !== r.c.slice(0, e).join(''));
+
+    return round(r, (Big.DP -= 4) + r.e + 1, Big.RM);
+  };
+  /*
+   * Return a new Big whose value is the value of this Big times the value of Big y.
+   */
+
+
+  P.times = P.mul = function (y) {
+    var c,
+        x = this,
+        Big = x.constructor,
+        xc = x.c,
+        yc = (y = new Big(y)).c,
+        a = xc.length,
+        b = yc.length,
+        i = x.e,
+        j = y.e; // Determine sign of result.
+
+    y.s = x.s == y.s ? 1 : -1; // Return signed 0 if either 0.
+
+    if (!xc[0] || !yc[0]) {
+      y.c = [y.e = 0];
+      return y;
+    } // Initialise exponent of result as x.e + y.e.
+
+
+    y.e = i + j; // If array xc has fewer digits than yc, swap xc and yc, and lengths.
+
+    if (a < b) {
+      c = xc;
+      xc = yc;
+      yc = c;
+      j = a;
+      a = b;
+      b = j;
+    } // Initialise coefficient array of result with zeros.
+
+
+    for (c = new Array(j = a + b); j--;) c[j] = 0; // Multiply.
+    // i is initially xc.length.
+
+
+    for (i = b; i--;) {
+      b = 0; // a is yc.length.
+
+      for (j = a + i; j > i;) {
+        // Current sum of products at this digit position, plus carry.
+        b = c[j] + yc[i] * xc[j - i - 1] + b;
+        c[j--] = b % 10; // carry
+
+        b = b / 10 | 0;
+      }
+
+      c[j] = b;
+    } // Increment result exponent if there is a final carry, otherwise remove leading zero.
+
+
+    if (b) ++y.e;else c.shift(); // Remove trailing zeros.
+
+    for (i = c.length; !c[--i];) c.pop();
+
+    y.c = c;
+    return y;
+  };
+  /*
+   * Return a string representing the value of this Big in exponential notation rounded to dp fixed
+   * decimal places using rounding mode rm, or Big.RM if rm is not specified.
+   *
+   * dp? {number} Decimal places: integer, 0 to MAX_DP inclusive.
+   * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
+   */
+
+
+  P.toExponential = function (dp, rm) {
+    var x = this,
+        n = x.c[0];
+
+    if (dp !== UNDEFINED) {
+      if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {
+        throw Error(INVALID_DP);
+      }
+
+      x = round(new x.constructor(x), ++dp, rm);
+
+      for (; x.c.length < dp;) x.c.push(0);
+    }
+
+    return stringify(x, true, !!n);
+  };
+  /*
+   * Return a string representing the value of this Big in normal notation rounded to dp fixed
+   * decimal places using rounding mode rm, or Big.RM if rm is not specified.
+   *
+   * dp? {number} Decimal places: integer, 0 to MAX_DP inclusive.
+   * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
+   *
+   * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.
+   * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.
+   */
+
+
+  P.toFixed = function (dp, rm) {
+    var x = this,
+        n = x.c[0];
+
+    if (dp !== UNDEFINED) {
+      if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {
+        throw Error(INVALID_DP);
+      }
+
+      x = round(new x.constructor(x), dp + x.e + 1, rm); // x.e may have changed if the value is rounded up.
+
+      for (dp = dp + x.e + 1; x.c.length < dp;) x.c.push(0);
+    }
+
+    return stringify(x, false, !!n);
+  };
+  /*
+   * Return a string representing the value of this Big.
+   * Return exponential notation if this Big has a positive exponent equal to or greater than
+   * Big.PE, or a negative exponent equal to or less than Big.NE.
+   * Omit the sign for negative zero.
+   */
+
+
+  P.toJSON = P.toString = function () {
+    var x = this,
+        Big = x.constructor;
+    return stringify(x, x.e <= Big.NE || x.e >= Big.PE, !!x.c[0]);
+  };
+  /*
+   * Return the value of this Big as a primitve number.
+   */
+
+
+  P.toNumber = function () {
+    var n = Number(stringify(this, true, true));
+
+    if (this.constructor.strict === true && !this.eq(n.toString())) {
+      throw Error(NAME + 'Imprecise conversion');
+    }
+
+    return n;
+  };
+  /*
+   * Return a string representing the value of this Big rounded to sd significant digits using
+   * rounding mode rm, or Big.RM if rm is not specified.
+   * Use exponential notation if sd is less than the number of digits necessary to represent
+   * the integer part of the value in normal notation.
+   *
+   * sd {number} Significant digits: integer, 1 to MAX_DP inclusive.
+   * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
+   */
+
+
+  P.toPrecision = function (sd, rm) {
+    var x = this,
+        Big = x.constructor,
+        n = x.c[0];
+
+    if (sd !== UNDEFINED) {
+      if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {
+        throw Error(INVALID + 'precision');
+      }
+
+      x = round(new Big(x), sd, rm);
+
+      for (; x.c.length < sd;) x.c.push(0);
+    }
+
+    return stringify(x, sd <= x.e || x.e <= Big.NE || x.e >= Big.PE, !!n);
+  };
+  /*
+   * Return a string representing the value of this Big.
+   * Return exponential notation if this Big has a positive exponent equal to or greater than
+   * Big.PE, or a negative exponent equal to or less than Big.NE.
+   * Include the sign for negative zero.
+   */
+
+
+  P.valueOf = function () {
+    var x = this,
+        Big = x.constructor;
+
+    if (Big.strict === true) {
+      throw Error(NAME + 'valueOf disallowed');
+    }
+
+    return stringify(x, x.e <= Big.NE || x.e >= Big.PE, true);
+  }; // Export
+
+
+  var Big = _Big_(); /// <reference types="https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/master/types/big.js/index.d.ts" />
+
+  var NumCvt = /*#__PURE__*/function () {
+    function NumCvt() {
+      _classCallCheck$1(this, NumCvt);
+    }
+
+    _createClass$1(NumCvt, null, [{
+      key: "show",
+      value: function show(val, isPercentage) {
+        if (val && isPercentage) return Big(val).times(100).valueOf();
+        return String(val !== null && val !== void 0 ? val : '');
+      }
+    }, {
+      key: "emit",
+      value: function emit(val, isPercentage) {
+        if (!val) return undefined;
+        if (!isPercentage) return +val;
+        return +Big(val).div(100);
+      }
+    }]);
+
+    return NumCvt;
+  }();
+
+  function initState(props) {
+    return {
+      preProps: props,
+      tempValue: NumCvt.show(props.value, props.isPercentage)
+    };
+  }
+
+  var Num = /*#__PURE__*/function (_PureComponent) {
+    _inherits(Num, _PureComponent);
+
+    var _super = _createSuper(Num);
+
+    function Num() {
+      var _this;
+
+      _classCallCheck$1(this, Num);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _super.call.apply(_super, [this].concat(args));
+
+      _defineProperty$2(_assertThisInitialized(_this), "state", initState(_this.props));
+
+      _defineProperty$2(_assertThisInitialized(_this), "onChange", function (e) {
+        var $value = e.target.value;
+        var $val = $value.replace(/^(-?\d+(\.\d*)?|-?\d*).*$/, '$1');
+        if ($val !== $value) e.target.value = $val;
+        var value = NumCvt.emit($val, _this.props.isPercentage);
+
+        _this.setState(function (pre) {
+          return _objectSpread2$2(_objectSpread2$2({}, pre), {}, {
+            tempValue: e.target.value
+          });
+        }, function () {
+          var _this$props$onChange, _this$props;
+
+          if (value !== _this.props.value) (_this$props$onChange = (_this$props = _this.props).onChange) === null || _this$props$onChange === void 0 ? void 0 : _this$props$onChange.call(_this$props, value);
+        });
+      });
+
+      return _this;
+    }
+
+    _createClass$1(Num, [{
+      key: "render",
+      value: function render() {
+        var _this$state$tempValue;
+
+        return /*#__PURE__*/React__default["default"].createElement("div", {
+          className: classnames('param-number', {
+            readonly: this.props.readonly
+          }, this.props.className),
+          style: this.props.style
+        }, this.props.readonly ? /*#__PURE__*/React__default["default"].createElement("span", {
+          className: "param-number-val"
+        }, (_this$state$tempValue = this.state.tempValue) !== null && _this$state$tempValue !== void 0 ? _this$state$tempValue : '-') : /*#__PURE__*/React__default["default"].createElement("input", {
+          className: "param-number-val",
+          type: "text",
+          placeholder: this.props.placeholder || 'Value',
+          value: this.state.tempValue || '',
+          onChange: this.onChange,
+          onBlur: this.props.onBlur
+        }), this.props.isPercentage && /*#__PURE__*/React__default["default"].createElement("span", {
+          className: "param-number-suffix"
+        }, "%"));
+      }
+    }], [{
+      key: "getDerivedStateFromProps",
+      value: function getDerivedStateFromProps(props, state) {
+        if (props.value !== state.preProps.value && parseFloat(state.tempValue) !== props.value) {
+          state.tempValue = NumCvt.show(props.value, props.isPercentage);
+        }
+
+        return _objectSpread2$2(_objectSpread2$2({}, state), {}, {
+          preProps: props
+        });
+      }
+    }]);
+
+    return Num;
+  }(React.PureComponent);
+
+  var NumRange = /*#__PURE__*/function (_PureComponent) {
+    _inherits(NumRange, _PureComponent);
+
+    var _super = _createSuper(NumRange);
+
+    function NumRange() {
+      var _this;
+
+      _classCallCheck$1(this, NumRange);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _super.call.apply(_super, [this].concat(args));
+
+      _defineProperty$2(_assertThisInitialized(_this), "onChange", function (key, val) {
+        var _this$props$onChange, _this$props;
+
+        var value = _objectSpread2$2({}, _this.props.value);
+
+        value[key] = val;
+        (_this$props$onChange = (_this$props = _this.props).onChange) === null || _this$props$onChange === void 0 ? void 0 : _this$props$onChange.call(_this$props, value);
+      });
+
+      return _this;
+    }
+
+    _createClass$1(NumRange, [{
+      key: "render",
+      value: function render() {
+        var _this$props$value, _this$props$value2;
+
+        return /*#__PURE__*/React__default["default"].createElement("div", {
+          className: classnames('param-number-range', {
+            readonly: this.props.readonly
+          }, this.props.className),
+          style: this.props.style
+        }, /*#__PURE__*/React__default["default"].createElement("span", {
+          className: "param-number-range-prefix"
+        }, "Min"), /*#__PURE__*/React__default["default"].createElement(Num, {
+          placeholder: 'Min',
+          value: (_this$props$value = this.props.value) === null || _this$props$value === void 0 ? void 0 : _this$props$value.min,
+          onChange: this.onChange.bind(null, 'min'),
+          isPercentage: this.props.isPercentage,
+          readonly: this.props.readonly,
+          onBlur: this.props.onBlur
+        }), /*#__PURE__*/React__default["default"].createElement("span", {
+          className: "param-number-range-sep"
+        }, this.props.readonly ? ',' : '-'), /*#__PURE__*/React__default["default"].createElement("span", {
+          className: "param-number-range-prefix"
+        }, "Max"), /*#__PURE__*/React__default["default"].createElement(Num, {
+          placeholder: 'Max',
+          value: (_this$props$value2 = this.props.value) === null || _this$props$value2 === void 0 ? void 0 : _this$props$value2.max,
+          onChange: this.onChange.bind(null, 'max'),
+          isPercentage: this.props.isPercentage,
+          readonly: this.props.readonly,
+          onBlur: this.props.onBlur
+        }));
+      }
+    }]);
+
+    return NumRange;
+  }(React.PureComponent);
+
+  function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray$1(arr);
+  }
+
+  function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
+  }
+
+  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.");
+  }
+
+  function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray$1(arr) || _nonIterableSpread();
+  }
+
+  var IconContext = /*#__PURE__*/React.createContext({});
+
+  function _defineProperty$1(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 ownKeys$1(object, enumerableOnly) {
+    var keys = Object.keys(object);
+
+    if (Object.getOwnPropertySymbols) {
+      var symbols = Object.getOwnPropertySymbols(object);
+      enumerableOnly && (symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      })), keys.push.apply(keys, symbols);
+    }
+
+    return keys;
+  }
+
+  function _objectSpread2$1(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = null != arguments[i] ? arguments[i] : {};
+      i % 2 ? ownKeys$1(Object(source), !0).forEach(function (key) {
+        _defineProperty$1(target, key, source[key]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+
+    return target;
+  }
+
+  function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+  }
+
+  function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+
+    var _s, _e;
+
+    try {
+      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+        _arr.push(_s.value);
+
+        if (i && _arr.length === i) break;
+      }
+    } catch (err) {
+      _d = true;
+      _e = err;
+    } finally {
+      try {
+        if (!_n && _i["return"] != null) _i["return"]();
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+
+    return _arr;
+  }
+
+  function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+
+    for (var i = 0, arr2 = new Array(len); i < len; i++) {
+      arr2[i] = arr[i];
+    }
+
+    return arr2;
+  }
+
+  function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+  }
+
+  function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+
+  function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+  }
+
+  function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+
+    for (i = 0; i < sourceKeys.length; i++) {
+      key = sourceKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      target[key] = source[key];
+    }
+
+    return target;
+  }
+
+  function _objectWithoutProperties(source, excluded) {
+    if (source == null) return {};
+    var target = _objectWithoutPropertiesLoose(source, excluded);
+    var key, i;
+
+    if (Object.getOwnPropertySymbols) {
+      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+      for (i = 0; i < sourceSymbolKeys.length; i++) {
+        key = sourceSymbolKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+        target[key] = source[key];
+      }
+    }
+
+    return target;
+  }
+
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+
+    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);
+  }
+
+  /**
+   * Take input from [0, n] and return it as [0, 1]
+   * @hidden
+   */
+  function bound01(n, max) {
+    if (isOnePointZero(n)) {
+      n = '100%';
+    }
+
+    var isPercent = isPercentage(n);
+    n = max === 360 ? n : Math.min(max, Math.max(0, parseFloat(n))); // Automatically convert percentage into number
+
+    if (isPercent) {
+      n = parseInt(String(n * max), 10) / 100;
+    } // Handle floating point rounding errors
+
+
+    if (Math.abs(n - max) < 0.000001) {
+      return 1;
+    } // Convert into [0, 1] range if it isn't already
+
+
+    if (max === 360) {
+      // If n is a hue given in degrees,
+      // wrap around out-of-range values into [0, 360] range
+      // then convert into [0, 1].
+      n = (n < 0 ? n % max + max : n % max) / parseFloat(String(max));
+    } else {
+      // If n not a hue given in degrees
+      // Convert into [0, 1] range if it isn't already.
+      n = n % max / parseFloat(String(max));
+    }
+
+    return n;
+  }
+  /**
+   * Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1
+   * <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>
+   * @hidden
+   */
+
+  function isOnePointZero(n) {
+    return typeof n === 'string' && n.indexOf('.') !== -1 && parseFloat(n) === 1;
+  }
+  /**
+   * Check to see if string passed in is a percentage
+   * @hidden
+   */
+
+  function isPercentage(n) {
+    return typeof n === 'string' && n.indexOf('%') !== -1;
+  }
+  /**
+   * Return a valid alpha value [0,1] with all invalid values being set to 1
+   * @hidden
+   */
+
+  function boundAlpha(a) {
+    a = parseFloat(a);
+
+    if (isNaN(a) || a < 0 || a > 1) {
+      a = 1;
+    }
+
+    return a;
+  }
+  /**
+   * Replace a decimal with it's percentage value
+   * @hidden
+   */
+
+  function convertToPercentage(n) {
+    if (n <= 1) {
+      return Number(n) * 100 + "%";
+    }
+
+    return n;
+  }
+  /**
+   * Force a hex value to have 2 characters
+   * @hidden
+   */
+
+  function pad2(c) {
+    return c.length === 1 ? '0' + c : String(c);
+  }
+
+  // <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript>
+
+  /**
+   * Handle bounds / percentage checking to conform to CSS color spec
+   * <http://www.w3.org/TR/css3-color/>
+   * *Assumes:* r, g, b in [0, 255] or [0, 1]
+   * *Returns:* { r, g, b } in [0, 255]
+   */
+
+  function rgbToRgb(r, g, b) {
+    return {
+      r: bound01(r, 255) * 255,
+      g: bound01(g, 255) * 255,
+      b: bound01(b, 255) * 255
+    };
+  }
+
+  function hue2rgb(p, q, t) {
+    if (t < 0) {
+      t += 1;
+    }
+
+    if (t > 1) {
+      t -= 1;
+    }
+
+    if (t < 1 / 6) {
+      return p + (q - p) * (6 * t);
+    }
+
+    if (t < 1 / 2) {
+      return q;
+    }
+
+    if (t < 2 / 3) {
+      return p + (q - p) * (2 / 3 - t) * 6;
+    }
+
+    return p;
+  }
+  /**
+   * Converts an HSL color value to RGB.
+   *
+   * *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]
+   * *Returns:* { r, g, b } in the set [0, 255]
+   */
+
+
+  function hslToRgb(h, s, l) {
+    var r;
+    var g;
+    var b;
+    h = bound01(h, 360);
+    s = bound01(s, 100);
+    l = bound01(l, 100);
+
+    if (s === 0) {
+      // achromatic
+      g = l;
+      b = l;
+      r = l;
+    } else {
+      var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+      var p = 2 * l - q;
+      r = hue2rgb(p, q, h + 1 / 3);
+      g = hue2rgb(p, q, h);
+      b = hue2rgb(p, q, h - 1 / 3);
+    }
+
+    return {
+      r: r * 255,
+      g: g * 255,
+      b: b * 255
+    };
+  }
+  /**
+   * Converts an RGB color value to HSV
+   *
+   * *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]
+   * *Returns:* { h, s, v } in [0,1]
+   */
+
+  function rgbToHsv(r, g, b) {
+    r = bound01(r, 255);
+    g = bound01(g, 255);
+    b = bound01(b, 255);
+    var max = Math.max(r, g, b);
+    var min = Math.min(r, g, b);
+    var h = 0;
+    var v = max;
+    var d = max - min;
+    var s = max === 0 ? 0 : d / max;
+
+    if (max === min) {
+      h = 0; // achromatic
+    } else {
+      switch (max) {
+        case r:
+          h = (g - b) / d + (g < b ? 6 : 0);
+          break;
+
+        case g:
+          h = (b - r) / d + 2;
+          break;
+
+        case b:
+          h = (r - g) / d + 4;
+          break;
+      }
+
+      h /= 6;
+    }
+
+    return {
+      h: h,
+      s: s,
+      v: v
+    };
+  }
+  /**
+   * Converts an HSV color value to RGB.
+   *
+   * *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]
+   * *Returns:* { r, g, b } in the set [0, 255]
+   */
+
+  function hsvToRgb(h, s, v) {
+    h = bound01(h, 360) * 6;
+    s = bound01(s, 100);
+    v = bound01(v, 100);
+    var i = Math.floor(h);
+    var f = h - i;
+    var p = v * (1 - s);
+    var q = v * (1 - f * s);
+    var t = v * (1 - (1 - f) * s);
+    var mod = i % 6;
+    var r = [v, q, p, p, t, v][mod];
+    var g = [t, v, v, q, p, p][mod];
+    var b = [p, p, t, v, v, q][mod];
+    return {
+      r: r * 255,
+      g: g * 255,
+      b: b * 255
+    };
+  }
+  /**
+   * Converts an RGB color to hex
+   *
+   * Assumes r, g, and b are contained in the set [0, 255]
+   * Returns a 3 or 6 character hex
+   */
+
+  function rgbToHex(r, g, b, allow3Char) {
+    var hex = [pad2(Math.round(r).toString(16)), pad2(Math.round(g).toString(16)), pad2(Math.round(b).toString(16))]; // Return a 3 character hex if possible
+
+    if (allow3Char && hex[0].startsWith(hex[0].charAt(1)) && hex[1].startsWith(hex[1].charAt(1)) && hex[2].startsWith(hex[2].charAt(1))) {
+      return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
+    }
+
+    return hex.join('');
+  }
+  /** Converts a hex value to a decimal */
+
+  function convertHexToDecimal(h) {
+    return parseIntFromHex(h) / 255;
+  }
+  /** Parse a base-16 hex value into a base-10 integer */
+
+  function parseIntFromHex(val) {
+    return parseInt(val, 16);
+  }
+
+  // https://github.com/bahamas10/css-color-names/blob/master/css-color-names.json
+
+  /**
+   * @hidden
+   */
+  var names = {
+    aliceblue: '#f0f8ff',
+    antiquewhite: '#faebd7',
+    aqua: '#00ffff',
+    aquamarine: '#7fffd4',
+    azure: '#f0ffff',
+    beige: '#f5f5dc',
+    bisque: '#ffe4c4',
+    black: '#000000',
+    blanchedalmond: '#ffebcd',
+    blue: '#0000ff',
+    blueviolet: '#8a2be2',
+    brown: '#a52a2a',
+    burlywood: '#deb887',
+    cadetblue: '#5f9ea0',
+    chartreuse: '#7fff00',
+    chocolate: '#d2691e',
+    coral: '#ff7f50',
+    cornflowerblue: '#6495ed',
+    cornsilk: '#fff8dc',
+    crimson: '#dc143c',
+    cyan: '#00ffff',
+    darkblue: '#00008b',
+    darkcyan: '#008b8b',
+    darkgoldenrod: '#b8860b',
+    darkgray: '#a9a9a9',
+    darkgreen: '#006400',
+    darkgrey: '#a9a9a9',
+    darkkhaki: '#bdb76b',
+    darkmagenta: '#8b008b',
+    darkolivegreen: '#556b2f',
+    darkorange: '#ff8c00',
+    darkorchid: '#9932cc',
+    darkred: '#8b0000',
+    darksalmon: '#e9967a',
+    darkseagreen: '#8fbc8f',
+    darkslateblue: '#483d8b',
+    darkslategray: '#2f4f4f',
+    darkslategrey: '#2f4f4f',
+    darkturquoise: '#00ced1',
+    darkviolet: '#9400d3',
+    deeppink: '#ff1493',
+    deepskyblue: '#00bfff',
+    dimgray: '#696969',
+    dimgrey: '#696969',
+    dodgerblue: '#1e90ff',
+    firebrick: '#b22222',
+    floralwhite: '#fffaf0',
+    forestgreen: '#228b22',
+    fuchsia: '#ff00ff',
+    gainsboro: '#dcdcdc',
+    ghostwhite: '#f8f8ff',
+    goldenrod: '#daa520',
+    gold: '#ffd700',
+    gray: '#808080',
+    green: '#008000',
+    greenyellow: '#adff2f',
+    grey: '#808080',
+    honeydew: '#f0fff0',
+    hotpink: '#ff69b4',
+    indianred: '#cd5c5c',
+    indigo: '#4b0082',
+    ivory: '#fffff0',
+    khaki: '#f0e68c',
+    lavenderblush: '#fff0f5',
+    lavender: '#e6e6fa',
+    lawngreen: '#7cfc00',
+    lemonchiffon: '#fffacd',
+    lightblue: '#add8e6',
+    lightcoral: '#f08080',
+    lightcyan: '#e0ffff',
+    lightgoldenrodyellow: '#fafad2',
+    lightgray: '#d3d3d3',
+    lightgreen: '#90ee90',
+    lightgrey: '#d3d3d3',
+    lightpink: '#ffb6c1',
+    lightsalmon: '#ffa07a',
+    lightseagreen: '#20b2aa',
+    lightskyblue: '#87cefa',
+    lightslategray: '#778899',
+    lightslategrey: '#778899',
+    lightsteelblue: '#b0c4de',
+    lightyellow: '#ffffe0',
+    lime: '#00ff00',
+    limegreen: '#32cd32',
+    linen: '#faf0e6',
+    magenta: '#ff00ff',
+    maroon: '#800000',
+    mediumaquamarine: '#66cdaa',
+    mediumblue: '#0000cd',
+    mediumorchid: '#ba55d3',
+    mediumpurple: '#9370db',
+    mediumseagreen: '#3cb371',
+    mediumslateblue: '#7b68ee',
+    mediumspringgreen: '#00fa9a',
+    mediumturquoise: '#48d1cc',
+    mediumvioletred: '#c71585',
+    midnightblue: '#191970',
+    mintcream: '#f5fffa',
+    mistyrose: '#ffe4e1',
+    moccasin: '#ffe4b5',
+    navajowhite: '#ffdead',
+    navy: '#000080',
+    oldlace: '#fdf5e6',
+    olive: '#808000',
+    olivedrab: '#6b8e23',
+    orange: '#ffa500',
+    orangered: '#ff4500',
+    orchid: '#da70d6',
+    palegoldenrod: '#eee8aa',
+    palegreen: '#98fb98',
+    paleturquoise: '#afeeee',
+    palevioletred: '#db7093',
+    papayawhip: '#ffefd5',
+    peachpuff: '#ffdab9',
+    peru: '#cd853f',
+    pink: '#ffc0cb',
+    plum: '#dda0dd',
+    powderblue: '#b0e0e6',
+    purple: '#800080',
+    rebeccapurple: '#663399',
+    red: '#ff0000',
+    rosybrown: '#bc8f8f',
+    royalblue: '#4169e1',
+    saddlebrown: '#8b4513',
+    salmon: '#fa8072',
+    sandybrown: '#f4a460',
+    seagreen: '#2e8b57',
+    seashell: '#fff5ee',
+    sienna: '#a0522d',
+    silver: '#c0c0c0',
+    skyblue: '#87ceeb',
+    slateblue: '#6a5acd',
+    slategray: '#708090',
+    slategrey: '#708090',
+    snow: '#fffafa',
+    springgreen: '#00ff7f',
+    steelblue: '#4682b4',
+    tan: '#d2b48c',
+    teal: '#008080',
+    thistle: '#d8bfd8',
+    tomato: '#ff6347',
+    turquoise: '#40e0d0',
+    violet: '#ee82ee',
+    wheat: '#f5deb3',
+    white: '#ffffff',
+    whitesmoke: '#f5f5f5',
+    yellow: '#ffff00',
+    yellowgreen: '#9acd32'
+  };
+
+  /**
+   * Given a string or object, convert that input to RGB
+   *
+   * Possible string inputs:
+   * ```
+   * "red"
+   * "#f00" or "f00"
+   * "#ff0000" or "ff0000"
+   * "#ff000000" or "ff000000"
+   * "rgb 255 0 0" or "rgb (255, 0, 0)"
+   * "rgb 1.0 0 0" or "rgb (1, 0, 0)"
+   * "rgba (255, 0, 0, 1)" or "rgba 255, 0, 0, 1"
+   * "rgba (1.0, 0, 0, 1)" or "rgba 1.0, 0, 0, 1"
+   * "hsl(0, 100%, 50%)" or "hsl 0 100% 50%"
+   * "hsla(0, 100%, 50%, 1)" or "hsla 0 100% 50%, 1"
+   * "hsv(0, 100%, 100%)" or "hsv 0 100% 100%"
+   * ```
+   */
+
+  function inputToRGB(color) {
+    var rgb = {
+      r: 0,
+      g: 0,
+      b: 0
+    };
+    var a = 1;
+    var s = null;
+    var v = null;
+    var l = null;
+    var ok = false;
+    var format = false;
+
+    if (typeof color === 'string') {
+      color = stringInputToObject(color);
+    }
+
+    if (typeof color === 'object') {
+      if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
+        rgb = rgbToRgb(color.r, color.g, color.b);
+        ok = true;
+        format = String(color.r).substr(-1) === '%' ? 'prgb' : 'rgb';
+      } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
+        s = convertToPercentage(color.s);
+        v = convertToPercentage(color.v);
+        rgb = hsvToRgb(color.h, s, v);
+        ok = true;
+        format = 'hsv';
+      } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
+        s = convertToPercentage(color.s);
+        l = convertToPercentage(color.l);
+        rgb = hslToRgb(color.h, s, l);
+        ok = true;
+        format = 'hsl';
+      }
+
+      if (Object.prototype.hasOwnProperty.call(color, 'a')) {
+        a = color.a;
+      }
+    }
+
+    a = boundAlpha(a);
+    return {
+      ok: ok,
+      format: color.format || format,
+      r: Math.min(255, Math.max(rgb.r, 0)),
+      g: Math.min(255, Math.max(rgb.g, 0)),
+      b: Math.min(255, Math.max(rgb.b, 0)),
+      a: a
+    };
+  } // <http://www.w3.org/TR/css3-values/#integers>
+
+  var CSS_INTEGER = '[-\\+]?\\d+%?'; // <http://www.w3.org/TR/css3-values/#number-value>
+
+  var CSS_NUMBER = '[-\\+]?\\d*\\.\\d+%?'; // Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.
+
+  var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")"; // Actual matching.
+  // Parentheses and commas are optional, but not required.
+  // Whitespace can take the place of commas or opening paren
+
+  var PERMISSIVE_MATCH3 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
+  var PERMISSIVE_MATCH4 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
+  var matchers = {
+    CSS_UNIT: new RegExp(CSS_UNIT),
+    rgb: new RegExp('rgb' + PERMISSIVE_MATCH3),
+    rgba: new RegExp('rgba' + PERMISSIVE_MATCH4),
+    hsl: new RegExp('hsl' + PERMISSIVE_MATCH3),
+    hsla: new RegExp('hsla' + PERMISSIVE_MATCH4),
+    hsv: new RegExp('hsv' + PERMISSIVE_MATCH3),
+    hsva: new RegExp('hsva' + PERMISSIVE_MATCH4),
+    hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+    hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
+    hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+    hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
+  };
+  /**
+   * Permissive string parsing.  Take in a number of formats, and output an object
+   * based on detected format.  Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}`
+   */
+
+  function stringInputToObject(color) {
+    color = color.trim().toLowerCase();
+
+    if (color.length === 0) {
+      return false;
+    }
+
+    var named = false;
+
+    if (names[color]) {
+      color = names[color];
+      named = true;
+    } else if (color === 'transparent') {
+      return {
+        r: 0,
+        g: 0,
+        b: 0,
+        a: 0,
+        format: 'name'
+      };
+    } // Try to match string input using regular expressions.
+    // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]
+    // Just return an object and let the conversion functions handle that.
+    // This way the result will be the same whether the tinycolor is initialized with string or object.
+
+
+    var match = matchers.rgb.exec(color);
+
+    if (match) {
+      return {
+        r: match[1],
+        g: match[2],
+        b: match[3]
+      };
+    }
+
+    match = matchers.rgba.exec(color);
+
+    if (match) {
+      return {
+        r: match[1],
+        g: match[2],
+        b: match[3],
+        a: match[4]
+      };
+    }
+
+    match = matchers.hsl.exec(color);
+
+    if (match) {
+      return {
+        h: match[1],
+        s: match[2],
+        l: match[3]
+      };
+    }
+
+    match = matchers.hsla.exec(color);
+
+    if (match) {
+      return {
+        h: match[1],
+        s: match[2],
+        l: match[3],
+        a: match[4]
+      };
+    }
+
+    match = matchers.hsv.exec(color);
+
+    if (match) {
+      return {
+        h: match[1],
+        s: match[2],
+        v: match[3]
+      };
+    }
+
+    match = matchers.hsva.exec(color);
+
+    if (match) {
+      return {
+        h: match[1],
+        s: match[2],
+        v: match[3],
+        a: match[4]
+      };
+    }
+
+    match = matchers.hex8.exec(color);
+
+    if (match) {
+      return {
+        r: parseIntFromHex(match[1]),
+        g: parseIntFromHex(match[2]),
+        b: parseIntFromHex(match[3]),
+        a: convertHexToDecimal(match[4]),
+        format: named ? 'name' : 'hex8'
+      };
+    }
+
+    match = matchers.hex6.exec(color);
+
+    if (match) {
+      return {
+        r: parseIntFromHex(match[1]),
+        g: parseIntFromHex(match[2]),
+        b: parseIntFromHex(match[3]),
+        format: named ? 'name' : 'hex'
+      };
+    }
+
+    match = matchers.hex4.exec(color);
+
+    if (match) {
+      return {
+        r: parseIntFromHex(match[1] + match[1]),
+        g: parseIntFromHex(match[2] + match[2]),
+        b: parseIntFromHex(match[3] + match[3]),
+        a: convertHexToDecimal(match[4] + match[4]),
+        format: named ? 'name' : 'hex8'
+      };
+    }
+
+    match = matchers.hex3.exec(color);
+
+    if (match) {
+      return {
+        r: parseIntFromHex(match[1] + match[1]),
+        g: parseIntFromHex(match[2] + match[2]),
+        b: parseIntFromHex(match[3] + match[3]),
+        format: named ? 'name' : 'hex'
+      };
+    }
+
+    return false;
+  }
+  /**
+   * Check to see if it looks like a CSS unit
+   * (see `matchers` above for definition).
+   */
+
+  function isValidCSSUnit(color) {
+    return Boolean(matchers.CSS_UNIT.exec(String(color)));
+  }
+
+  var hueStep = 2; // 色相阶梯
+
+  var saturationStep = 0.16; // 饱和度阶梯，浅色部分
+
+  var saturationStep2 = 0.05; // 饱和度阶梯，深色部分
+
+  var brightnessStep1 = 0.05; // 亮度阶梯，浅色部分
+
+  var brightnessStep2 = 0.15; // 亮度阶梯，深色部分
+
+  var lightColorCount = 5; // 浅色数量，主色上
+
+  var darkColorCount = 4; // 深色数量，主色下
+  // 暗色主题颜色映射关系表
+
+  var darkColorMap = [{
+    index: 7,
+    opacity: 0.15
+  }, {
+    index: 6,
+    opacity: 0.25
+  }, {
+    index: 5,
+    opacity: 0.3
+  }, {
+    index: 5,
+    opacity: 0.45
+  }, {
+    index: 5,
+    opacity: 0.65
+  }, {
+    index: 5,
+    opacity: 0.85
+  }, {
+    index: 4,
+    opacity: 0.9
+  }, {
+    index: 3,
+    opacity: 0.95
+  }, {
+    index: 2,
+    opacity: 0.97
+  }, {
+    index: 1,
+    opacity: 0.98
+  }]; // Wrapper function ported from TinyColor.prototype.toHsv
+  // Keep it here because of `hsv.h * 360`
+
+  function toHsv(_ref) {
+    var r = _ref.r,
+        g = _ref.g,
+        b = _ref.b;
+    var hsv = rgbToHsv(r, g, b);
+    return {
+      h: hsv.h * 360,
+      s: hsv.s,
+      v: hsv.v
+    };
+  } // Wrapper function ported from TinyColor.prototype.toHexString
+  // Keep it here because of the prefix `#`
+
+
+  function toHex(_ref2) {
+    var r = _ref2.r,
+        g = _ref2.g,
+        b = _ref2.b;
+    return "#".concat(rgbToHex(r, g, b, false));
+  } // Wrapper function ported from TinyColor.prototype.mix, not treeshakable.
+  // Amount in range [0, 1]
+  // Assume color1 & color2 has no alpha, since the following src code did so.
+
+
+  function mix(rgb1, rgb2, amount) {
+    var p = amount / 100;
+    var rgb = {
+      r: (rgb2.r - rgb1.r) * p + rgb1.r,
+      g: (rgb2.g - rgb1.g) * p + rgb1.g,
+      b: (rgb2.b - rgb1.b) * p + rgb1.b
+    };
+    return rgb;
+  }
+
+  function getHue(hsv, i, light) {
+    var hue; // 根据色相不同，色相转向不同
+
+    if (Math.round(hsv.h) >= 60 && Math.round(hsv.h) <= 240) {
+      hue = light ? Math.round(hsv.h) - hueStep * i : Math.round(hsv.h) + hueStep * i;
+    } else {
+      hue = light ? Math.round(hsv.h) + hueStep * i : Math.round(hsv.h) - hueStep * i;
+    }
+
+    if (hue < 0) {
+      hue += 360;
+    } else if (hue >= 360) {
+      hue -= 360;
+    }
+
+    return hue;
+  }
+
+  function getSaturation(hsv, i, light) {
+    // grey color don't change saturation
+    if (hsv.h === 0 && hsv.s === 0) {
+      return hsv.s;
+    }
+
+    var saturation;
+
+    if (light) {
+      saturation = hsv.s - saturationStep * i;
+    } else if (i === darkColorCount) {
+      saturation = hsv.s + saturationStep;
+    } else {
+      saturation = hsv.s + saturationStep2 * i;
+    } // 边界值修正
+
+
+    if (saturation > 1) {
+      saturation = 1;
+    } // 第一格的 s 限制在 0.06-0.1 之间
+
+
+    if (light && i === lightColorCount && saturation > 0.1) {
+      saturation = 0.1;
+    }
+
+    if (saturation < 0.06) {
+      saturation = 0.06;
+    }
+
+    return Number(saturation.toFixed(2));
+  }
+
+  function getValue(hsv, i, light) {
+    var value;
+
+    if (light) {
+      value = hsv.v + brightnessStep1 * i;
+    } else {
+      value = hsv.v - brightnessStep2 * i;
+    }
+
+    if (value > 1) {
+      value = 1;
+    }
+
+    return Number(value.toFixed(2));
+  }
+
+  function generate$1(color) {
+    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var patterns = [];
+    var pColor = inputToRGB(color);
+
+    for (var i = lightColorCount; i > 0; i -= 1) {
+      var hsv = toHsv(pColor);
+      var colorString = toHex(inputToRGB({
+        h: getHue(hsv, i, true),
+        s: getSaturation(hsv, i, true),
+        v: getValue(hsv, i, true)
+      }));
+      patterns.push(colorString);
+    }
+
+    patterns.push(toHex(pColor));
+
+    for (var _i = 1; _i <= darkColorCount; _i += 1) {
+      var _hsv = toHsv(pColor);
+
+      var _colorString = toHex(inputToRGB({
+        h: getHue(_hsv, _i),
+        s: getSaturation(_hsv, _i),
+        v: getValue(_hsv, _i)
+      }));
+
+      patterns.push(_colorString);
+    } // dark theme patterns
+
+
+    if (opts.theme === 'dark') {
+      return darkColorMap.map(function (_ref3) {
+        var index = _ref3.index,
+            opacity = _ref3.opacity;
+        var darkColorString = toHex(mix(inputToRGB(opts.backgroundColor || '#141414'), inputToRGB(patterns[index]), opacity * 100));
+        return darkColorString;
+      });
+    }
+
+    return patterns;
+  }
+
+  var presetPrimaryColors = {
+    red: '#F5222D',
+    volcano: '#FA541C',
+    orange: '#FA8C16',
+    gold: '#FAAD14',
+    yellow: '#FADB14',
+    lime: '#A0D911',
+    green: '#52C41A',
+    cyan: '#13C2C2',
+    blue: '#1890FF',
+    geekblue: '#2F54EB',
+    purple: '#722ED1',
+    magenta: '#EB2F96',
+    grey: '#666666'
+  };
+  var presetPalettes = {};
+  var presetDarkPalettes = {};
+  Object.keys(presetPrimaryColors).forEach(function (key) {
+    presetPalettes[key] = generate$1(presetPrimaryColors[key]);
+    presetPalettes[key].primary = presetPalettes[key][5]; // dark presetPalettes
+
+    presetDarkPalettes[key] = generate$1(presetPrimaryColors[key], {
+      theme: 'dark',
+      backgroundColor: '#141414'
+    });
+    presetDarkPalettes[key].primary = presetDarkPalettes[key][5];
+  });
+  presetPalettes.red;
+  presetPalettes.volcano;
+  presetPalettes.gold;
+  presetPalettes.orange;
+  presetPalettes.yellow;
+  presetPalettes.lime;
+  presetPalettes.green;
+  presetPalettes.cyan;
+  presetPalettes.blue;
+  presetPalettes.geekblue;
+  presetPalettes.purple;
+  presetPalettes.magenta;
+  presetPalettes.grey;
+
+  /* eslint-disable no-console */
+  var warned = {};
+  function warning$1(valid, message) {
+  }
+  function call(method, valid, message) {
+    if (!valid && !warned[message]) {
+      method(false, message);
+      warned[message] = true;
+    }
+  }
+  function warningOnce(valid, message) {
+    call(warning$1, valid, message);
+  }
+  /* eslint-enable */
+
+  function canUseDom() {
+    return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+  }
+
+  var MARK_KEY = "rc-util-key";
+
+  function getMark() {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        mark = _ref.mark;
+
+    if (mark) {
+      return mark.startsWith('data-') ? mark : "data-".concat(mark);
+    }
+
+    return MARK_KEY;
+  }
+
+  function getContainer(option) {
+    if (option.attachTo) {
+      return option.attachTo;
+    }
+
+    var head = document.querySelector('head');
+    return head || document.body;
+  }
+
+  function injectCSS(css) {
+    var _option$csp;
+
+    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+    if (!canUseDom()) {
+      return null;
+    }
+
+    var styleNode = document.createElement('style');
+
+    if ((_option$csp = option.csp) === null || _option$csp === void 0 ? void 0 : _option$csp.nonce) {
+      var _option$csp2;
+
+      styleNode.nonce = (_option$csp2 = option.csp) === null || _option$csp2 === void 0 ? void 0 : _option$csp2.nonce;
+    }
+
+    styleNode.innerHTML = css;
+    var container = getContainer(option);
+    var firstChild = container.firstChild;
+
+    if (option.prepend && container.prepend) {
+      // Use `prepend` first
+      container.prepend(styleNode);
+    } else if (option.prepend && firstChild) {
+      // Fallback to `insertBefore` like IE not support `prepend`
+      container.insertBefore(styleNode, firstChild);
+    } else {
+      container.appendChild(styleNode);
+    }
+
+    return styleNode;
+  }
+  var containerCache = new Map();
+
+  function findExistNode(key) {
+    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var container = getContainer(option);
+    return Array.from(containerCache.get(container).children).find(function (node) {
+      return node.tagName === 'STYLE' && node.getAttribute(getMark(option)) === key;
+    });
+  }
+  function updateCSS(css, key) {
+    var option = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    var container = getContainer(option); // Get real parent
+
+    if (!containerCache.has(container)) {
+      var placeholderStyle = injectCSS('', option);
+      var parentNode = placeholderStyle.parentNode;
+      containerCache.set(container, parentNode);
+      parentNode.removeChild(placeholderStyle);
+    }
+
+    var existNode = findExistNode(key, option);
+
+    if (existNode) {
+      var _option$csp3, _option$csp4;
+
+      if (((_option$csp3 = option.csp) === null || _option$csp3 === void 0 ? void 0 : _option$csp3.nonce) && existNode.nonce !== ((_option$csp4 = option.csp) === null || _option$csp4 === void 0 ? void 0 : _option$csp4.nonce)) {
+        var _option$csp5;
+
+        existNode.nonce = (_option$csp5 = option.csp) === null || _option$csp5 === void 0 ? void 0 : _option$csp5.nonce;
+      }
+
+      if (existNode.innerHTML !== css) {
+        existNode.innerHTML = css;
+      }
+
+      return existNode;
+    }
+
+    var newNode = injectCSS(css, option);
+    newNode.setAttribute(getMark(option), key);
+    return newNode;
+  }
+
+  function warning(valid, message) {
+    warningOnce(valid, "[@ant-design/icons] ".concat(message));
+  }
+  function isIconDefinition(target) {
+    return _typeof(target) === 'object' && typeof target.name === 'string' && typeof target.theme === 'string' && (_typeof(target.icon) === 'object' || typeof target.icon === 'function');
+  }
+  function normalizeAttrs() {
+    var attrs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return Object.keys(attrs).reduce(function (acc, key) {
+      var val = attrs[key];
+
+      switch (key) {
+        case 'class':
+          acc.className = val;
+          delete acc.class;
+          break;
+
+        default:
+          acc[key] = val;
+      }
+
+      return acc;
+    }, {});
+  }
+  function generate(node, key, rootProps) {
+    if (!rootProps) {
+      return /*#__PURE__*/React__default["default"].createElement(node.tag, _objectSpread2$1({
+        key: key
+      }, normalizeAttrs(node.attrs)), (node.children || []).map(function (child, index) {
+        return generate(child, "".concat(key, "-").concat(node.tag, "-").concat(index));
+      }));
+    }
+
+    return /*#__PURE__*/React__default["default"].createElement(node.tag, _objectSpread2$1(_objectSpread2$1({
+      key: key
+    }, normalizeAttrs(node.attrs)), rootProps), (node.children || []).map(function (child, index) {
+      return generate(child, "".concat(key, "-").concat(node.tag, "-").concat(index));
+    }));
+  }
+  function getSecondaryColor(primaryColor) {
+    // choose the second color
+    return generate$1(primaryColor)[0];
+  }
+  function normalizeTwoToneColors(twoToneColor) {
+    if (!twoToneColor) {
+      return [];
+    }
+
+    return Array.isArray(twoToneColor) ? twoToneColor : [twoToneColor];
+  } // These props make sure that the SVG behaviours like general text.
+  // Reference: https://blog.prototypr.io/align-svg-icons-to-text-and-say-goodbye-to-font-icons-d44b3d7b26b4
+
+  var svgBaseProps = {
+    width: '1em',
+    height: '1em',
+    fill: 'currentColor',
+    'aria-hidden': 'true',
+    focusable: 'false'
+  };
+  var iconStyles = "\n.anticon {\n  display: inline-block;\n  color: inherit;\n  font-style: normal;\n  line-height: 0;\n  text-align: center;\n  text-transform: none;\n  vertical-align: -0.125em;\n  text-rendering: optimizeLegibility;\n  -webkit-font-smoothing: antialiased;\n  -moz-osx-font-smoothing: grayscale;\n}\n\n.anticon > * {\n  line-height: 1;\n}\n\n.anticon svg {\n  display: inline-block;\n}\n\n.anticon::before {\n  display: none;\n}\n\n.anticon .anticon-icon {\n  display: block;\n}\n\n.anticon[tabindex] {\n  cursor: pointer;\n}\n\n.anticon-spin::before,\n.anticon-spin {\n  display: inline-block;\n  -webkit-animation: loadingCircle 1s infinite linear;\n  animation: loadingCircle 1s infinite linear;\n}\n\n@-webkit-keyframes loadingCircle {\n  100% {\n    -webkit-transform: rotate(360deg);\n    transform: rotate(360deg);\n  }\n}\n\n@keyframes loadingCircle {\n  100% {\n    -webkit-transform: rotate(360deg);\n    transform: rotate(360deg);\n  }\n}\n";
+  var useInsertStyles = function useInsertStyles() {
+    var styleStr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : iconStyles;
+
+    var _useContext = React.useContext(IconContext),
+        csp = _useContext.csp;
+
+    React.useEffect(function () {
+      updateCSS(styleStr, '@ant-design-icons', {
+        prepend: true,
+        csp: csp
+      });
+    }, []);
+  };
+
+  var _excluded$2 = ["icon", "className", "onClick", "style", "primaryColor", "secondaryColor"];
+  var twoToneColorPalette = {
+    primaryColor: '#333',
+    secondaryColor: '#E6E6E6',
+    calculated: false
+  };
+
+  function setTwoToneColors(_ref) {
+    var primaryColor = _ref.primaryColor,
+        secondaryColor = _ref.secondaryColor;
+    twoToneColorPalette.primaryColor = primaryColor;
+    twoToneColorPalette.secondaryColor = secondaryColor || getSecondaryColor(primaryColor);
+    twoToneColorPalette.calculated = !!secondaryColor;
+  }
+
+  function getTwoToneColors() {
+    return _objectSpread2$1({}, twoToneColorPalette);
+  }
+
+  var IconBase = function IconBase(props) {
+    var icon = props.icon,
+        className = props.className,
+        onClick = props.onClick,
+        style = props.style,
+        primaryColor = props.primaryColor,
+        secondaryColor = props.secondaryColor,
+        restProps = _objectWithoutProperties(props, _excluded$2);
+
+    var colors = twoToneColorPalette;
+
+    if (primaryColor) {
+      colors = {
+        primaryColor: primaryColor,
+        secondaryColor: secondaryColor || getSecondaryColor(primaryColor)
+      };
+    }
+
+    useInsertStyles();
+    warning(isIconDefinition(icon), "icon should be icon definiton, but got ".concat(icon));
+
+    if (!isIconDefinition(icon)) {
+      return null;
+    }
+
+    var target = icon;
+
+    if (target && typeof target.icon === 'function') {
+      target = _objectSpread2$1(_objectSpread2$1({}, target), {}, {
+        icon: target.icon(colors.primaryColor, colors.secondaryColor)
+      });
+    }
+
+    return generate(target.icon, "svg-".concat(target.name), _objectSpread2$1({
+      className: className,
+      onClick: onClick,
+      style: style,
+      'data-icon': target.name,
+      width: '1em',
+      height: '1em',
+      fill: 'currentColor',
+      'aria-hidden': 'true'
+    }, restProps));
+  };
+
+  IconBase.displayName = 'IconReact';
+  IconBase.getTwoToneColors = getTwoToneColors;
+  IconBase.setTwoToneColors = setTwoToneColors;
+
+  function setTwoToneColor(twoToneColor) {
+    var _normalizeTwoToneColo = normalizeTwoToneColors(twoToneColor),
+        _normalizeTwoToneColo2 = _slicedToArray(_normalizeTwoToneColo, 2),
+        primaryColor = _normalizeTwoToneColo2[0],
+        secondaryColor = _normalizeTwoToneColo2[1];
+
+    return IconBase.setTwoToneColors({
+      primaryColor: primaryColor,
+      secondaryColor: secondaryColor
+    });
+  }
+  function getTwoToneColor() {
+    var colors = IconBase.getTwoToneColors();
+
+    if (!colors.calculated) {
+      return colors.primaryColor;
+    }
+
+    return [colors.primaryColor, colors.secondaryColor];
+  }
+
+  var _excluded$1 = ["className", "icon", "spin", "rotate", "tabIndex", "onClick", "twoToneColor"];
+  // should move it to antd main repo?
+
+  setTwoToneColor('#1890ff');
+  var Icon$1 = /*#__PURE__*/React__namespace.forwardRef(function (props, ref) {
+    var _classNames;
+
+    var className = props.className,
+        icon = props.icon,
+        spin = props.spin,
+        rotate = props.rotate,
+        tabIndex = props.tabIndex,
+        onClick = props.onClick,
+        twoToneColor = props.twoToneColor,
+        restProps = _objectWithoutProperties(props, _excluded$1);
+
+    var _React$useContext = React__namespace.useContext(IconContext),
+        _React$useContext$pre = _React$useContext.prefixCls,
+        prefixCls = _React$useContext$pre === void 0 ? 'anticon' : _React$useContext$pre;
+
+    var classString = classnames(prefixCls, (_classNames = {}, _defineProperty$1(_classNames, "".concat(prefixCls, "-").concat(icon.name), !!icon.name), _defineProperty$1(_classNames, "".concat(prefixCls, "-spin"), !!spin || icon.name === 'loading'), _classNames), className);
+    var iconTabIndex = tabIndex;
+
+    if (iconTabIndex === undefined && onClick) {
+      iconTabIndex = -1;
+    }
+
+    var svgStyle = rotate ? {
+      msTransform: "rotate(".concat(rotate, "deg)"),
+      transform: "rotate(".concat(rotate, "deg)")
+    } : undefined;
+
+    var _normalizeTwoToneColo = normalizeTwoToneColors(twoToneColor),
+        _normalizeTwoToneColo2 = _slicedToArray(_normalizeTwoToneColo, 2),
+        primaryColor = _normalizeTwoToneColo2[0],
+        secondaryColor = _normalizeTwoToneColo2[1];
+
+    return /*#__PURE__*/React__namespace.createElement("span", _objectSpread2$1(_objectSpread2$1({
+      role: "img",
+      "aria-label": icon.name
+    }, restProps), {}, {
+      ref: ref,
+      tabIndex: iconTabIndex,
+      onClick: onClick,
+      className: classString
+    }), /*#__PURE__*/React__namespace.createElement(IconBase, {
+      icon: icon,
+      primaryColor: primaryColor,
+      secondaryColor: secondaryColor,
+      style: svgStyle
+    }));
+  });
+  Icon$1.displayName = 'AntdIcon';
+  Icon$1.getTwoToneColor = getTwoToneColor;
+  Icon$1.setTwoToneColor = setTwoToneColor;
+
+  // This icon file is generated automatically.
+  var CheckOutlined$2 = {
+    "icon": {
+      "tag": "svg",
+      "attrs": {
+        "viewBox": "64 64 896 896",
+        "focusable": "false"
+      },
+      "children": [{
+        "tag": "path",
+        "attrs": {
+          "d": "M912 190h-69.9c-9.8 0-19.1 4.5-25.1 12.2L404.7 724.5 207 474a32 32 0 00-25.1-12.2H112c-6.7 0-10.4 7.7-6.3 12.9l273.9 347c12.8 16.2 37.4 16.2 50.3 0l488.4-618.9c4.1-5.1.4-12.8-6.3-12.8z"
+        }
+      }]
+    },
+    "name": "check",
+    "theme": "outlined"
+  };
+
+  var CheckOutlined = function CheckOutlined(props, ref) {
+    return /*#__PURE__*/React__namespace.createElement(Icon$1, _objectSpread2$1(_objectSpread2$1({}, props), {}, {
+      ref: ref,
+      icon: CheckOutlined$2
+    }));
+  };
+
+  CheckOutlined.displayName = 'CheckOutlined';
+  var CheckOutlined$1 = /*#__PURE__*/React__namespace.forwardRef(CheckOutlined);
+
+  // This icon file is generated automatically.
+  var CloseOutlined$2 = {
+    "icon": {
+      "tag": "svg",
+      "attrs": {
+        "viewBox": "64 64 896 896",
+        "focusable": "false"
+      },
+      "children": [{
+        "tag": "path",
+        "attrs": {
+          "d": "M563.8 512l262.5-312.9c4.4-5.2.7-13.1-6.1-13.1h-79.8c-4.7 0-9.2 2.1-12.3 5.7L511.6 449.8 295.1 191.7c-3-3.6-7.5-5.7-12.3-5.7H203c-6.8 0-10.5 7.9-6.1 13.1L459.4 512 196.9 824.9A7.95 7.95 0 00203 838h79.8c4.7 0 9.2-2.1 12.3-5.7l216.5-258.1 216.5 258.1c3 3.6 7.5 5.7 12.3 5.7h79.8c6.8 0 10.5-7.9 6.1-13.1L563.8 512z"
+        }
+      }]
+    },
+    "name": "close",
+    "theme": "outlined"
+  };
+
+  var CloseOutlined = function CloseOutlined(props, ref) {
+    return /*#__PURE__*/React__namespace.createElement(Icon$1, _objectSpread2$1(_objectSpread2$1({}, props), {}, {
+      ref: ref,
+      icon: CloseOutlined$2
+    }));
+  };
+
+  CloseOutlined.displayName = 'CloseOutlined';
+  var CloseOutlined$1 = /*#__PURE__*/React__namespace.forwardRef(CloseOutlined);
+
+  // This icon file is generated automatically.
+  var DeleteOutlined$2 = {
+    "icon": {
+      "tag": "svg",
+      "attrs": {
+        "viewBox": "64 64 896 896",
+        "focusable": "false"
+      },
+      "children": [{
+        "tag": "path",
+        "attrs": {
+          "d": "M360 184h-8c4.4 0 8-3.6 8-8v8h304v-8c0 4.4 3.6 8 8 8h-8v72h72v-80c0-35.3-28.7-64-64-64H352c-35.3 0-64 28.7-64 64v80h72v-72zm504 72H160c-17.7 0-32 14.3-32 32v32c0 4.4 3.6 8 8 8h60.4l24.7 523c1.6 34.1 29.8 61 63.9 61h454c34.2 0 62.3-26.8 63.9-61l24.7-523H888c4.4 0 8-3.6 8-8v-32c0-17.7-14.3-32-32-32zM731.3 840H292.7l-24.2-512h487l-24.2 512z"
+        }
+      }]
+    },
+    "name": "delete",
+    "theme": "outlined"
+  };
+
+  var DeleteOutlined = function DeleteOutlined(props, ref) {
+    return /*#__PURE__*/React__namespace.createElement(Icon$1, _objectSpread2$1(_objectSpread2$1({}, props), {}, {
+      ref: ref,
+      icon: DeleteOutlined$2
+    }));
+  };
+
+  DeleteOutlined.displayName = 'DeleteOutlined';
+  var DeleteOutlined$1 = /*#__PURE__*/React__namespace.forwardRef(DeleteOutlined);
+
+  // This icon file is generated automatically.
+  var DownOutlined$2 = {
+    "icon": {
+      "tag": "svg",
+      "attrs": {
+        "viewBox": "64 64 896 896",
+        "focusable": "false"
+      },
+      "children": [{
+        "tag": "path",
+        "attrs": {
+          "d": "M884 256h-75c-5.1 0-9.9 2.5-12.9 6.6L512 654.2 227.9 262.6c-3-4.1-7.8-6.6-12.9-6.6h-75c-6.5 0-10.3 7.4-6.5 12.7l352.6 486.1c12.8 17.6 39 17.6 51.7 0l352.6-486.1c3.9-5.3.1-12.7-6.4-12.7z"
+        }
+      }]
+    },
+    "name": "down",
+    "theme": "outlined"
+  };
+
+  var DownOutlined = function DownOutlined(props, ref) {
+    return /*#__PURE__*/React__namespace.createElement(Icon$1, _objectSpread2$1(_objectSpread2$1({}, props), {}, {
+      ref: ref,
+      icon: DownOutlined$2
+    }));
+  };
+
+  DownOutlined.displayName = 'DownOutlined';
+  var DownOutlined$1 = /*#__PURE__*/React__namespace.forwardRef(DownOutlined);
+
+  // This icon file is generated automatically.
+  var PlusOutlined$2 = {
+    "icon": {
+      "tag": "svg",
+      "attrs": {
+        "viewBox": "64 64 896 896",
+        "focusable": "false"
+      },
+      "children": [{
+        "tag": "defs",
+        "attrs": {},
+        "children": [{
+          "tag": "style",
+          "attrs": {}
+        }]
+      }, {
+        "tag": "path",
+        "attrs": {
+          "d": "M482 152h60q8 0 8 8v704q0 8-8 8h-60q-8 0-8-8V160q0-8 8-8z"
+        }
+      }, {
+        "tag": "path",
+        "attrs": {
+          "d": "M176 474h672q8 0 8 8v60q0 8-8 8H176q-8 0-8-8v-60q0-8 8-8z"
+        }
+      }]
+    },
+    "name": "plus",
+    "theme": "outlined"
+  };
+
+  var PlusOutlined = function PlusOutlined(props, ref) {
+    return /*#__PURE__*/React__namespace.createElement(Icon$1, _objectSpread2$1(_objectSpread2$1({}, props), {}, {
+      ref: ref,
+      icon: PlusOutlined$2
+    }));
+  };
+
+  PlusOutlined.displayName = 'PlusOutlined';
+  var PlusOutlined$1 = /*#__PURE__*/React__namespace.forwardRef(PlusOutlined);
+
+  var _excluded = ["className", "component", "viewBox", "spin", "rotate", "tabIndex", "onClick", "children"];
+  var Icon = /*#__PURE__*/React__namespace.forwardRef(function (props, ref) {
+    var className = props.className,
+        Component = props.component,
+        viewBox = props.viewBox,
+        spin = props.spin,
+        rotate = props.rotate,
+        tabIndex = props.tabIndex,
+        onClick = props.onClick,
+        children = props.children,
+        restProps = _objectWithoutProperties(props, _excluded);
+
+    warning(Boolean(Component || children), 'Should have `component` prop or `children`.');
+    useInsertStyles();
+
+    var _React$useContext = React__namespace.useContext(IconContext),
+        _React$useContext$pre = _React$useContext.prefixCls,
+        prefixCls = _React$useContext$pre === void 0 ? 'anticon' : _React$useContext$pre;
+
+    var classString = classnames(prefixCls, className);
+    var svgClassString = classnames(_defineProperty$1({}, "".concat(prefixCls, "-spin"), !!spin));
+    var svgStyle = rotate ? {
+      msTransform: "rotate(".concat(rotate, "deg)"),
+      transform: "rotate(".concat(rotate, "deg)")
+    } : undefined;
+
+    var innerSvgProps = _objectSpread2$1(_objectSpread2$1({}, svgBaseProps), {}, {
+      className: svgClassString,
+      style: svgStyle,
+      viewBox: viewBox
+    });
+
+    if (!viewBox) {
+      delete innerSvgProps.viewBox;
+    } // component > children
+
+
+    var renderInnerNode = function renderInnerNode() {
+      if (Component) {
+        return /*#__PURE__*/React__namespace.createElement(Component, _objectSpread2$1({}, innerSvgProps), children);
+      }
+
+      if (children) {
+        warning(Boolean(viewBox) || React__namespace.Children.count(children) === 1 && /*#__PURE__*/React__namespace.isValidElement(children) && React__namespace.Children.only(children).type === 'use', 'Make sure that you provide correct `viewBox`' + ' prop (default `0 0 1024 1024`) to the icon.');
+        return /*#__PURE__*/React__namespace.createElement("svg", _objectSpread2$1(_objectSpread2$1({}, innerSvgProps), {}, {
+          viewBox: viewBox
+        }), children);
+      }
+
+      return null;
+    };
+
+    var iconTabIndex = tabIndex;
+
+    if (iconTabIndex === undefined && onClick) {
+      iconTabIndex = -1;
+    }
+
+    return /*#__PURE__*/React__namespace.createElement("span", _objectSpread2$1(_objectSpread2$1({
+      role: "img"
+    }, restProps), {}, {
+      ref: ref,
+      tabIndex: iconTabIndex,
+      onClick: onClick,
+      className: classString
+    }), renderInnerNode());
+  });
+  Icon.displayName = 'AntdIcon';
+
+  IconContext.Provider;
+
+  var TextArray = /*#__PURE__*/function (_PureComponent) {
+    _inherits(TextArray, _PureComponent);
+
+    var _super = _createSuper(TextArray);
+
+    function TextArray() {
+      var _this;
+
+      _classCallCheck$1(this, TextArray);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _super.call.apply(_super, [this].concat(args));
+
+      _defineProperty$2(_assertThisInitialized(_this), "value", []);
+
+      _defineProperty$2(_assertThisInitialized(_this), "onChange", function (i, e) {
+        var _this$props$onChange, _this$props;
+
+        var val = e.target.value;
+
+        var value = _toConsumableArray(_this.value);
+
+        value[i] = val;
+        (_this$props$onChange = (_this$props = _this.props).onChange) === null || _this$props$onChange === void 0 ? void 0 : _this$props$onChange.call(_this$props, value);
+      });
+
+      _defineProperty$2(_assertThisInitialized(_this), "onAdd", function (i) {
+        var _this$props$onChange2, _this$props2;
+
+        var value = _toConsumableArray(_this.value);
+
+        value.splice(i + 1, 0, '');
+        (_this$props$onChange2 = (_this$props2 = _this.props).onChange) === null || _this$props$onChange2 === void 0 ? void 0 : _this$props$onChange2.call(_this$props2, value);
+      });
+
+      _defineProperty$2(_assertThisInitialized(_this), "onDel", function (i) {
+        var _this$props$onChange3, _this$props3;
+
+        var value = _toConsumableArray(_this.value);
+
+        value.splice(i, 1);
+        (_this$props$onChange3 = (_this$props3 = _this.props).onChange) === null || _this$props$onChange3 === void 0 ? void 0 : _this$props$onChange3.call(_this$props3, value);
+      });
+
+      return _this;
+    }
+
+    _createClass$1(TextArray, [{
+      key: "render",
+      value: function render() {
+        var _this2 = this;
+
+        this.value = this.props.value || [];
+        if (!this.value.length) this.value.push('');
+        return /*#__PURE__*/React__default["default"].createElement("div", {
+          className: classnames('param-text-array', {
+            readonly: this.props.readonly
+          }, this.props.className),
+          style: this.props.style
+        }, this.props.readonly ? /*#__PURE__*/React__default["default"].createElement("span", {
+          className: "param-text-array-val"
+        }, this.value.filter(Boolean).join(', ') || '-') : this.value.map(function (it, i) {
+          return /*#__PURE__*/React__default["default"].createElement("div", {
+            className: "param-arr-item",
+            key: i
+          }, /*#__PURE__*/React__default["default"].createElement("input", {
+            type: "text",
+            placeholder: "Phone",
+            value: it,
+            onChange: _this2.onChange.bind(null, i),
+            onBlur: _this2.props.onBlur
+          }), /*#__PURE__*/React__default["default"].createElement("div", {
+            className: "param-arr-ops"
+          }, /*#__PURE__*/React__default["default"].createElement(PlusOutlined$1, {
+            className: "param-arr-ops-add",
+            onClick: _this2.onAdd.bind(null, i)
+          }), /*#__PURE__*/React__default["default"].createElement(DeleteOutlined$1, {
+            className: "param-arr-ops-del",
+            onClick: _this2.onDel.bind(null, i)
+          })));
+        }));
+      }
+    }]);
+
+    return TextArray;
+  }(React.PureComponent);
+
+  var Expiries = /*#__PURE__*/function (_PureComponent) {
+    _inherits(Expiries, _PureComponent);
+
+    var _super = _createSuper(Expiries);
+
+    function Expiries() {
+      var _this;
+
+      _classCallCheck$1(this, Expiries);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _super.call.apply(_super, [this].concat(args));
+
+      _defineProperty$2(_assertThisInitialized(_this), "state", {
+        visible: false
+      });
+
+      _defineProperty$2(_assertThisInitialized(_this), "handleVisibleChange", function (visible) {
+        return _this.setState({
+          visible: visible
+        });
+      });
+
+      _defineProperty$2(_assertThisInitialized(_this), "onChange", function (val) {
+        var _this$props$onChange, _this$props, _this$props$onBlur, _this$props2;
+
+        var value = _toConsumableArray(_this.props.value || []);
+
+        if (_this.props.multiple !== false) {
+          var index = value.findIndex(function (it) {
+            return it === val;
+          });
+          if (index > -1) value.splice(index, 1);else value.push(val);
+        } else {
+          value = [val];
+        }
+
+        (_this$props$onChange = (_this$props = _this.props).onChange) === null || _this$props$onChange === void 0 ? void 0 : _this$props$onChange.call(_this$props, value);
+        (_this$props$onBlur = (_this$props2 = _this.props).onBlur) === null || _this$props$onBlur === void 0 ? void 0 : _this$props$onBlur.call(_this$props2);
+        if (_this.props.multiple === false) _this.handleVisibleChange(false);
+      });
+
+      return _this;
+    }
+
+    _createClass$1(Expiries, [{
+      key: "renderValue",
+      value: function renderValue() {
+        var _this$props$value,
+            _this2 = this;
+
+        var value = (_this$props$value = this.props.value) === null || _this$props$value === void 0 ? void 0 : _this$props$value.filter(function (it) {
+          return it && !isExpired(it);
+        });
+
+        if (this.props.readonly) {
+          return /*#__PURE__*/React__default["default"].createElement("span", {
+            className: "param-expiries-val"
+          }, (value === null || value === void 0 ? void 0 : value.join(', ')) || '-');
+        }
+
+        var placeholder = /*#__PURE__*/React__default["default"].createElement("span", {
+          className: "param-expiries-placeholder"
+        }, "Choose an expiry");
+
+        if (this.props.multiple === false) {
+          var _this$props$value2;
+
+          var _val = (_this$props$value2 = this.props.value) === null || _this$props$value2 === void 0 ? void 0 : _this$props$value2[0];
+
+          return !_val || isExpired(_val) ? placeholder : /*#__PURE__*/React__default["default"].createElement("span", {
+            className: "param-expiries-val"
+          }, _val);
+        }
+
+        if (!(value === null || value === void 0 ? void 0 : value.length)) return placeholder;
+        return value.map(function (it) {
+          return /*#__PURE__*/React__default["default"].createElement("span", {
+            className: "param-expiries-multi-val",
+            key: it,
+            onClick: function onClick(e) {
+              return e.stopPropagation();
+            }
+          }, it, /*#__PURE__*/React__default["default"].createElement(CloseOutlined$1, {
+            onClick: _this2.onChange.bind(null, it)
+          }));
+        });
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props$options,
+            _this3 = this;
+
+        return /*#__PURE__*/React__default["default"].createElement(antd.Popover, {
+          overlayClassName: "param-expiries-popover",
+          trigger: 'click',
+          placement: 'bottomLeft',
+          visible: !this.props.readonly && this.state.visible,
+          onVisibleChange: this.handleVisibleChange,
+          content: (_this$props$options = this.props.options) === null || _this$props$options === void 0 ? void 0 : _this$props$options.map(function (it) {
+            var _this3$props$value, _this3$props$calcDisa, _this3$props, _this3$onChange;
+
+            var checked = (_this3$props$value = _this3.props.value) === null || _this3$props$value === void 0 ? void 0 : _this3$props$value.includes(it);
+            var disabled = (_this3$props$calcDisa = (_this3$props = _this3.props).calcDisabled) === null || _this3$props$calcDisa === void 0 ? void 0 : _this3$props$calcDisa.call(_this3$props, it);
+            return /*#__PURE__*/React__default["default"].createElement("div", {
+              className: classnames('param-expiries-option', {
+                'param-expiries-option-checked': checked,
+                'param-expiries-option-disabled': disabled
+              }),
+              key: it,
+              onClick: disabled ? undefined : (_this3$onChange = _this3.onChange) === null || _this3$onChange === void 0 ? void 0 : _this3$onChange.bind(null, it)
+            }, it, checked && /*#__PURE__*/React__default["default"].createElement(CheckOutlined$1, null));
+          })
+        }, /*#__PURE__*/React__default["default"].createElement("div", {
+          className: classnames('param-expiries', {
+            readonly: this.props.readonly,
+            multiple: this.props.multiple !== false
+          }, this.props.className),
+          style: this.props.style
+        }, this.renderValue(), !this.props.readonly && this.props.options && /*#__PURE__*/React__default["default"].createElement(DownOutlined$1, {
+          className: "param-expiries-arrow"
+        })));
+      }
+    }]);
+
+    return Expiries;
+  }(React.PureComponent);
+
+  var ExpiriesLimit = /*#__PURE__*/function (_PureComponent) {
+    _inherits(ExpiriesLimit, _PureComponent);
+
+    var _super = _createSuper(ExpiriesLimit);
+
+    function ExpiriesLimit() {
+      var _this;
+
+      _classCallCheck$1(this, ExpiriesLimit);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _super.call.apply(_super, [this].concat(args));
+
+      _defineProperty$2(_assertThisInitialized(_this), "value", []);
+
+      _defineProperty$2(_assertThisInitialized(_this), "onChange", function (i, val, key) {
+        var _this$props$onChange, _this$props;
+
+        var value = _toConsumableArray(_this.value);
+
+        if (!value[i]) value[i] = {
+          expiry: ''
+        };
+        if (key) value[i][key] = val;else value[i] = _objectSpread2$2(_objectSpread2$2({}, value[i]), val);
+        (_this$props$onChange = (_this$props = _this.props).onChange) === null || _this$props$onChange === void 0 ? void 0 : _this$props$onChange.call(_this$props, value);
+      });
+
+      _defineProperty$2(_assertThisInitialized(_this), "onAdd", function (i) {
+        var _this$props$onChange2, _this$props2, _this$props$onBlur, _this$props3;
+
+        var value = _toConsumableArray(_this.value);
+
+        value.splice(i + 1, 0, {
+          expiry: ''
+        });
+        (_this$props$onChange2 = (_this$props2 = _this.props).onChange) === null || _this$props$onChange2 === void 0 ? void 0 : _this$props$onChange2.call(_this$props2, value);
+        (_this$props$onBlur = (_this$props3 = _this.props).onBlur) === null || _this$props$onBlur === void 0 ? void 0 : _this$props$onBlur.call(_this$props3);
+      });
+
+      _defineProperty$2(_assertThisInitialized(_this), "onDel", function (i) {
+        var _this$props$onChange3, _this$props4, _this$props$onBlur2, _this$props5;
+
+        var value = _toConsumableArray(_this.value);
+
+        value.splice(i, 1);
+        (_this$props$onChange3 = (_this$props4 = _this.props).onChange) === null || _this$props$onChange3 === void 0 ? void 0 : _this$props$onChange3.call(_this$props4, value);
+        (_this$props$onBlur2 = (_this$props5 = _this.props).onBlur) === null || _this$props$onBlur2 === void 0 ? void 0 : _this$props$onBlur2.call(_this$props5);
+      });
+
+      return _this;
+    }
+
+    _createClass$1(ExpiriesLimit, [{
+      key: "render",
+      value: function render() {
+        var _this$props$value,
+            _this$props$value2,
+            _this2 = this;
+
+        this.value = ((_this$props$value = this.props.value) === null || _this$props$value === void 0 ? void 0 : _this$props$value.filter(function (it) {
+          return !isExpired(it.expiry);
+        })) || [];
+        if (!this.value.length) this.value.push({
+          expiry: ''
+        });
+        return /*#__PURE__*/React__default["default"].createElement("div", {
+          className: classnames('param-expiries-limit', {
+            readonly: this.props.readonly
+          }, this.props.className),
+          style: this.props.style
+        }, this.props.readonly ? ((_this$props$value2 = this.props.value) === null || _this$props$value2 === void 0 ? void 0 : _this$props$value2.length) ? this.value.filter(function (it) {
+          return it.expiry;
+        }).map(function (it, i) {
+          return /*#__PURE__*/React__default["default"].createElement("span", {
+            className: "param-expiries-limit-val",
+            key: i
+          }, it.expiry, /*#__PURE__*/React__default["default"].createElement("span", {
+            className: "param-expiries-limit-val-sep"
+          }, "/"), it.minAumPercentage && it.maxAumPercentage ? "(".concat(NumCvt.show(it.minAumPercentage, true), "%, ").concat(NumCvt.show(it.maxAumPercentage, true), "%)") : '-', /*#__PURE__*/React__default["default"].createElement("span", {
+            className: "param-expiries-limit-val-sep"
+          }, "/"), it.minAbs && it.maxAbs ? "(".concat(it.minAbs, ", ").concat(it.maxAbs, ")") : '-');
+        }) : '-' : /*#__PURE__*/React__default["default"].createElement("div", {
+          className: "param-expiries-limit-inputs"
+        }, /*#__PURE__*/React__default["default"].createElement("div", {
+          className: "param-expiries readonly"
+        }, /*#__PURE__*/React__default["default"].createElement("span", {
+          className: "param-expiries-val"
+        }, "Expiry")), /*#__PURE__*/React__default["default"].createElement("div", {
+          className: "param-number-range readonly"
+        }, "Limit(% of AUM)"), /*#__PURE__*/React__default["default"].createElement("div", {
+          className: "param-number-range readonly"
+        }, "Limit(ABS)"), /*#__PURE__*/React__default["default"].createElement("div", {
+          className: "param-arr-ops readonly"
+        }), this.value.map(function (it, i) {
+          return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, {
+            key: i
+          }, /*#__PURE__*/React__default["default"].createElement(Expiries, {
+            multiple: false,
+            options: _this2.props.options,
+            value: [it.expiry],
+            onChange: function onChange(val) {
+              return _this2.onChange(i, val[0], 'expiry');
+            },
+            calcDisabled: function calcDisabled(expiry) {
+              return _this2.value.some(function (item) {
+                return item !== it && item.expiry === expiry;
+              });
+            },
+            onBlur: _this2.props.onBlur
+          }), /*#__PURE__*/React__default["default"].createElement(NumRange, {
+            value: {
+              min: it.minAumPercentage,
+              max: it.maxAumPercentage
+            },
+            onChange: function onChange(val) {
+              return _this2.onChange(i, {
+                minAumPercentage: val === null || val === void 0 ? void 0 : val.min,
+                maxAumPercentage: val === null || val === void 0 ? void 0 : val.max
+              });
+            },
+            isPercentage: true,
+            onBlur: _this2.props.onBlur
+          }), /*#__PURE__*/React__default["default"].createElement(NumRange, {
+            value: {
+              min: it.minAbs,
+              max: it.maxAbs
+            },
+            onChange: function onChange(val) {
+              return _this2.onChange(i, {
+                minAbs: val === null || val === void 0 ? void 0 : val.min,
+                maxAbs: val === null || val === void 0 ? void 0 : val.max
+              });
+            },
+            onBlur: _this2.props.onBlur
+          }), /*#__PURE__*/React__default["default"].createElement("div", {
+            className: "param-arr-ops"
+          }, /*#__PURE__*/React__default["default"].createElement(PlusOutlined$1, {
+            className: "param-arr-ops-add",
+            onClick: _this2.onAdd.bind(null, i)
+          }), /*#__PURE__*/React__default["default"].createElement(DeleteOutlined$1, {
+            className: "param-arr-ops-del",
+            onClick: _this2.onDel.bind(null, i)
+          })));
+        })));
+      }
+    }]);
+
+    return ExpiriesLimit;
+  }(React.PureComponent);
+
+  var _ParamTypeConfig;
+  var ParamTypeConfig = (_ParamTypeConfig = {}, _defineProperty$2(_ParamTypeConfig, exports.ParamType.ParamGroup, {
+    name: '参数组',
+    Comp: function Comp() {
+      return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null);
+    }
+  }), _defineProperty$2(_ParamTypeConfig, exports.ParamType.Number, {
+    name: '普通数值',
+    key: 'number',
+    Comp: Num,
+    validator: emptyValidator
+  }), _defineProperty$2(_ParamTypeConfig, exports.ParamType.Percentage, {
+    name: '百分比数值',
+    key: 'number',
+    Comp: function Comp(props) {
+      return /*#__PURE__*/React__default["default"].createElement(Num, Object.assign({}, props, {
+        isPercentage: true
+      }));
+    },
+    validator: emptyValidator
+  }), _defineProperty$2(_ParamTypeConfig, exports.ParamType.Bool, {
+    name: 'TRUE/FALSE',
+    key: 'bool',
+    Comp: Bool,
+    validator: emptyValidator
+  }), _defineProperty$2(_ParamTypeConfig, exports.ParamType.NumberRange, {
+    name: '数值范围',
+    key: 'range',
+    Comp: NumRange,
+    validator: numRangeValidator
+  }), _defineProperty$2(_ParamTypeConfig, exports.ParamType.PercentageRange, {
+    name: '百分比范围',
+    key: 'range',
+    Comp: function Comp(props) {
+      return /*#__PURE__*/React__default["default"].createElement(NumRange, Object.assign({}, props, {
+        isPercentage: true
+      }));
+    },
+    validator: numRangeValidator
+  }), _defineProperty$2(_ParamTypeConfig, exports.ParamType.ExpiryLimit, {
+    name: '到期日 Limit',
+    key: 'expiryLimitList',
+    Comp: ExpiriesLimit,
+    validator: function validator($val) {
+      for (var i = 0; i < $val.length; i++) {
+        var val = $val[i];
+        var error = expiryValidator(val === null || val === void 0 ? void 0 : val.expiry);
+
+        if (error) {
+          // return { [i]: { expire: error } }
+          return "Expiry field of the ".concat(i + 1, "th item: ").concat(error);
+        }
+
+        if (isNullLike(val === null || val === void 0 ? void 0 : val.minAumPercentage) && isNullLike(val === null || val === void 0 ? void 0 : val.maxAumPercentage) && isNullLike(val === null || val === void 0 ? void 0 : val.minAbs) && isNullLike(val === null || val === void 0 ? void 0 : val.maxAbs)) {
+          // return {
+          //   [i]: 'at least one parameter must be specified between AUM and ABS',
+          // }
+          return "The ".concat(i + 1, "th item: at least one parameter must be specified between AUM and ABS");
+        }
+
+        if (val.minAbs > val.maxAbs) // return { [i]: { minAbs: 'Min ABS should smaller than Max ABS' } }
+          return "The ".concat(i + 1, "th item: Min ABS should smaller than Max ABS");
+
+        if (val.minAumPercentage > val.maxAumPercentage) {
+          // return {
+          //   [i]: { minAumPercentage: 'Min AUM should smaller than Max AUM' },
+          // }
+          return "The ".concat(i + 1, "th item: Min AUM should smaller than Max AUM");
+        }
+      }
+
+      return '';
+    }
+  }), _defineProperty$2(_ParamTypeConfig, exports.ParamType.Expiry, {
+    name: '到期日',
+    key: 'list',
+    Comp: Expiries,
+    validator: expiriesValidator
+  }), _defineProperty$2(_ParamTypeConfig, exports.ParamType.Phone, {
+    name: '联系人电话',
+    key: 'list',
+    Comp: TextArray
+  }), _ParamTypeConfig);
+  function paramValidator(val, values) {
+    var _config$validator;
+
+    var config = ParamTypeConfig[values.valueType];
+    console.log();
+    if (!config) return '';
+    var value = config.key ? val === null || val === void 0 ? void 0 : val[config.key] : val;
+    return ((_config$validator = config.validator) === null || _config$validator === void 0 ? void 0 : _config$validator.call(config, value)) || '';
+  }
+  var ParamTypeOptions = Object.entries(ParamTypeConfig).map(function (_ref) {
+    var _ref2 = _slicedToArray$1(_ref, 2),
+        value = _ref2[0],
+        config = _ref2[1];
+
+    return _objectSpread2$2(_objectSpread2$2({}, config), {}, {
+      value: value,
+      label: config.name
+    });
+  });
+
+  var ParamRenderer = /*#__PURE__*/function (_PureComponent) {
+    _inherits(ParamRenderer, _PureComponent);
+
+    var _super = _createSuper(ParamRenderer);
+
+    function ParamRenderer() {
+      var _this;
+
+      _classCallCheck$1(this, ParamRenderer);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _super.call.apply(_super, [this].concat(args));
+
+      _defineProperty$2(_assertThisInitialized(_this), "onChange", function (val) {
+        var _this$props$onChange, _this$props;
+
+        var value = _this.typeConfig.key ? _objectSpread2$2(_objectSpread2$2({}, _this.props.value), {}, _defineProperty$2({}, _this.typeConfig.key, val)) : val;
+        (_this$props$onChange = (_this$props = _this.props).onChange) === null || _this$props$onChange === void 0 ? void 0 : _this$props$onChange.call(_this$props, value);
+      });
+
+      return _this;
+    }
+
+    _createClass$1(ParamRenderer, [{
+      key: "typeConfig",
+      get: function get() {
+        return ParamTypeConfig[this.props.valueType] || ParamTypeConfig[exports.ParamType.Number];
+      }
+    }, {
+      key: "value",
+      get: function get() {
+        var _this$props$value;
+
+        return this.typeConfig.key ? (_this$props$value = this.props.value) === null || _this$props$value === void 0 ? void 0 : _this$props$value[this.typeConfig.key] : this.props.value;
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var Comp = this.typeConfig.Comp;
+        return /*#__PURE__*/React__default["default"].createElement(Comp, Object.assign({}, this.props, {
+          value: this.value,
+          onChange: this.onChange,
+          className: classnames('param-renderer', this.props.className)
+        }));
+      }
+    }]);
+
+    return ParamRenderer;
+  }(React.PureComponent);
+
+  function ParentSelector(props) {
+    var value = React.useMemo(function () {
+      var _props$parentOptions;
+
+      var $value = [];
+
+      var find = function find(item) {
+        var _item$children;
+
+        var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+        $value[index] = item.value;
+        $value.length = index + 1;
+        if (String(item.value) === String(props.value)) return true;
+        return Boolean((_item$children = item.children) === null || _item$children === void 0 ? void 0 : _item$children.some(function (it) {
+          return find(it, index + 1);
+        }));
+      };
+
+      var matched = props.value && ((_props$parentOptions = props.parentOptions) === null || _props$parentOptions === void 0 ? void 0 : _props$parentOptions.some(function (it) {
+        return find(it);
+      }));
+      if (!matched) return [];
+      return $value;
+    }, [props.parentOptions, props.value]);
+    return /*#__PURE__*/React__default["default"].createElement(antd.Cascader, Object.assign({}, props, {
+      disabled: props.readonly,
+      placeholder: '请选择',
+      options: props.parentOptions,
+      className: classnames('param-parent-selector', {
+        readonly: props.readonly
+      }, props.className),
+      value: value,
+      onChange: function onChange(val) {
+        var _props$onChange;
+
+        return (_props$onChange = props.onChange) === null || _props$onChange === void 0 ? void 0 : _props$onChange.call(props, val.pop());
+      }
+    }));
+  }
+
+  /**
+   * Bundle of react-global-comp
+   * Generated: 2022-04-07
+   * Version: 2.0.4
+   * License: MIT
+   * Author: 2631541504@qq.com
+   */
+
+  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 ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+
+    if (Object.getOwnPropertySymbols) {
+      var symbols = Object.getOwnPropertySymbols(object);
+      if (enumerableOnly) symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+      keys.push.apply(keys, symbols);
+    }
+
+    return keys;
+  }
+
+  function _objectSpread2(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i] != null ? arguments[i] : {};
+
+      if (i % 2) {
+        ownKeys(Object(source), true).forEach(function (key) {
+          _defineProperty(target, key, source[key]);
+        });
+      } else if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+      } else {
+        ownKeys(Object(source)).forEach(function (key) {
+          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+      }
+    }
+
+    return target;
+  }
+
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a 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;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+  }
+
+  var ReactGlobalComp = /*#__PURE__*/function () {
+    function ReactGlobalComp(id, comp) {
+      _classCallCheck(this, ReactGlobalComp);
+
+      _defineProperty(this, "id", void 0);
+
+      _defineProperty(this, "comp", void 0);
+
+      _defineProperty(this, "preProps", void 0);
+
+      _defineProperty(this, "ref", void 0);
+
+      this.id = id;
+      this.comp = comp;
+    }
+
+    _createClass(ReactGlobalComp, [{
+      key: "render",
+      value: function render(props) {
+        var _this = this;
+
+        return new Promise(function (res) {
+          var dom = document.getElementById(_this.id);
+
+          if (!dom) {
+            dom = document.createElement('div');
+            dom.id = _this.id;
+            document.body.appendChild(dom);
+          }
+
+          var $props = _objectSpread2(_objectSpread2({}, _this.preProps), props);
+
+          ReactDOM__default["default"].render(React__default["default"].createElement(_this.comp, _objectSpread2(_objectSpread2({}, $props), {}, {
+            ref: function ref(el) {
+              _this.ref = el;
+              if (typeof $props.ref === 'function') $props.ref(el);else if ($props.ref) $props.ref.current = el;
+            }
+          })), dom, res);
+        });
+      }
+    }]);
+
+    return ReactGlobalComp;
+  }();
+
+  var ParamForm = /*#__PURE__*/function (_PureComponent) {
+    _inherits(ParamForm, _PureComponent);
+
+    var _super = _createSuper(ParamForm);
+
+    function ParamForm() {
+      var _this;
+
+      _classCallCheck$1(this, ParamForm);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _super.call.apply(_super, [this].concat(args));
+
+      _defineProperty$2(_assertThisInitialized(_this), "ref", React__default["default"].createRef());
+
+      _defineProperty$2(_assertThisInitialized(_this), "formItems", [{
+        label: '所属分组',
+        name: 'parentId',
+        Comp: ParentSelector,
+        required: true,
+        validator: validatorCvt(function (val) {
+          return emptyValidator(val);
+        })
+      }, {
+        label: '参数 Key',
+        name: 'key',
+        Comp: function Comp(props) {
+          return /*#__PURE__*/React__default["default"].createElement(antd.Input, Object.assign({
+            placeholder: '请输入'
+          }, props));
+        },
+        required: true,
+        validator: validatorCvt(keyValidator)
+      }, {
+        label: '参数名称',
+        name: 'name',
+        Comp: function Comp(props) {
+          return /*#__PURE__*/React__default["default"].createElement(antd.Input, Object.assign({
+            placeholder: '请输入'
+          }, props));
+        }
+      }, {
+        label: '参数类型',
+        name: 'valueType',
+        Comp: function Comp(props) {
+          return /*#__PURE__*/React__default["default"].createElement(antd.Select, Object.assign({
+            placeholder: '请选择'
+          }, props, {
+            options: undefined
+          }), ParamTypeOptions.map(function (it) {
+            return /*#__PURE__*/React__default["default"].createElement(antd.Select.Option, {
+              key: it.value,
+              value: it.value
+            }, it.label);
+          }));
+        },
+        required: true,
+        validator: validatorCvt(function (val) {
+          return emptyValidator(val);
+        })
+      }, {
+        label: '默认值',
+        name: 'defaultValue',
+        Comp: ParamRenderer,
+        validator: validatorCvt(paramValidator, function () {
+          return _this.ref.current;
+        })
+      }, {
+        label: '参数说明',
+        name: 'description',
+        Comp: function Comp(props) {
+          return /*#__PURE__*/React__default["default"].createElement(antd.Input.TextArea, Object.assign({
+            placeholder: '请输入'
+          }, props));
+        }
+      }]);
+
+      _defineProperty$2(_assertThisInitialized(_this), "onChange", function (changed, data) {
+        var _this$props$onChange, _this$props;
+
+        (_this$props$onChange = (_this$props = _this.props).onChange) === null || _this$props$onChange === void 0 ? void 0 : _this$props$onChange.call(_this$props, data);
+        if ('valueType' in changed) _this.forceUpdate();
+      });
+
+      return _this;
+    }
+
+    _createClass$1(ParamForm, [{
+      key: "render",
+      value: function render() {
+        var _this2 = this;
+
+        return /*#__PURE__*/React__default["default"].createElement(antd.Form, {
+          className: "param-form",
+          ref: this.ref,
+          key: JSON.stringify(this.props.initialValues),
+          initialValues: this.props.initialValues,
+          onFinish: this.props.onSubmit,
+          onValuesChange: this.onChange
+        }, this.formItems.map(function (it) {
+          var _this2$ref$current;
+
+          return /*#__PURE__*/React__default["default"].createElement(antd.Form.Item, {
+            key: it.name,
+            label: it.label,
+            name: it.name,
+            required: it.required,
+            requiredMark: true,
+            rules: [{
+              validator: it.validator || function () {
+                return Promise.resolve();
+              }
+            }],
+            validateTrigger: 'onBlur'
+          }, /*#__PURE__*/React__default["default"].createElement(it.Comp, {
+            parentOptions: _this2.props.parentOptions,
+            options: _this2.props.expiriesOptions,
+            valueType: (_this2$ref$current = _this2.ref.current) === null || _this2$ref$current === void 0 ? void 0 : _this2$ref$current.getFieldValue('valueType')
+          }));
+        }), this.props.onSubmit && /*#__PURE__*/React__default["default"].createElement(antd.Button, {
+          type: "primary",
+          htmlType: "submit"
+        }, "\u63D0\u4EA4"));
+      }
+    }]);
+
+    return ParamForm;
+  }(React.PureComponent);
+
+  var ParamFormModalEl = /*#__PURE__*/function (_PureComponent2) {
+    _inherits(ParamFormModalEl, _PureComponent2);
+
+    var _super2 = _createSuper(ParamFormModalEl);
+
+    function ParamFormModalEl() {
+      var _this3;
+
+      _classCallCheck$1(this, ParamFormModalEl);
+
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+
+      _this3 = _super2.call.apply(_super2, [this].concat(args));
+
+      _defineProperty$2(_assertThisInitialized(_this3), "ref", React__default["default"].createRef());
+
+      _defineProperty$2(_assertThisInitialized(_this3), "state", {
+        visible: false
+      });
+
+      _defineProperty$2(_assertThisInitialized(_this3), "onShow", function () {
+        return _this3.setState({
+          visible: true
+        });
+      });
+
+      _defineProperty$2(_assertThisInitialized(_this3), "onHide", function () {
+        return _this3.setState({
+          visible: false
+        });
+      });
+
+      _defineProperty$2(_assertThisInitialized(_this3), "onSubmit", function () {
+        var form = _this3.ref.current.ref.current;
+        return form.validateFields().then(function () {
+          return _this3.props.onSubmit(form.getFieldsValue());
+        }).then(_this3.onHide);
+      });
+
+      return _this3;
+    }
+
+    _createClass$1(ParamFormModalEl, [{
+      key: "render",
+      value: function render() {
+        var _this$props$initialVa;
+
+        return /*#__PURE__*/React__default["default"].createElement(antd.Modal, {
+          key: String(this.state.visible),
+          width: 640,
+          closable: false,
+          title: !((_this$props$initialVa = this.props.initialValues) === null || _this$props$initialVa === void 0 ? void 0 : _this$props$initialVa.paramId) ? '新增参数' : '修改参数',
+          visible: this.state.visible,
+          footer: /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, /*#__PURE__*/React__default["default"].createElement(antd.Button, {
+            onClick: this.onHide
+          }, "\u53D6\u6D88"), /*#__PURE__*/React__default["default"].createElement(antd.Button, {
+            type: "primary",
+            onClick: this.onSubmit
+          }, "\u786E\u8BA4"))
+        }, /*#__PURE__*/React__default["default"].createElement(ParamForm, Object.assign({}, this.props, {
+          ref: this.ref,
+          onSubmit: undefined
+        })));
+      }
+    }]);
+
+    return ParamFormModalEl;
+  }(React.PureComponent);
+
+  var ParamFormModal = /*#__PURE__*/function () {
+    function ParamFormModal() {
+      _classCallCheck$1(this, ParamFormModal);
+    }
+
+    _createClass$1(ParamFormModal, null, [{
+      key: "show",
+      value: function show(props) {
+        return ParamFormModal.el.render(props).then(function () {
+          ParamFormModal.el.ref.onShow();
+        });
+      }
+    }, {
+      key: "hide",
+      value: function hide() {
+        return ParamFormModal.el.render().then(function () {
+          ParamFormModal.el.ref.onHide();
+        });
+      }
+    }]);
+
+    return ParamFormModal;
+  }();
+
+  _defineProperty$2(ParamFormModal, "el", new ReactGlobalComp('param-form-modal', ParamFormModalEl));
+
+  var ParamValueEditor = /*#__PURE__*/function (_PureComponent) {
+    _inherits(ParamValueEditor, _PureComponent);
+
+    var _super = _createSuper(ParamValueEditor);
+
+    function ParamValueEditor() {
+      var _this;
+
+      _classCallCheck$1(this, ParamValueEditor);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _super.call.apply(_super, [this].concat(args));
+
+      _defineProperty$2(_assertThisInitialized(_this), "ref", React__default["default"].createRef());
+
+      _defineProperty$2(_assertThisInitialized(_this), "formItems", [{
+        label: 'Parameter',
+        name: 'paramId',
+        Comp: function Comp(props) {
+          return /*#__PURE__*/React__default["default"].createElement(ParentSelector, Object.assign({}, props, {
+            readonly: true
+          }));
+        }
+      }, {
+        label: 'Description',
+        name: 'description',
+        Comp: function Comp(props) {
+          return /*#__PURE__*/React__default["default"].createElement("span", {
+            className: "param-value-editor-desc",
+            style: {
+              lineHeight: '20px',
+              padding: '10px 0'
+            }
+          }, props.value || '-');
+        }
+      }, {
+        label: 'Value before',
+        name: 'valueBefore',
+        Comp: function Comp(props) {
+          return /*#__PURE__*/React__default["default"].createElement(ParamRenderer, Object.assign({}, props, {
+            readonly: true
+          }));
+        }
+      }, {
+        label: 'Value after',
+        name: 'value',
+        Comp: ParamRenderer,
+        required: true,
+        validator: validatorCvt(function (val) {
+          return paramValidator(val, {
+            valueType: _this.props.valueType
+          });
+        })
+      }]);
+
+      _defineProperty$2(_assertThisInitialized(_this), "onChange", function (changed, data) {
+        var _this$props$onChange, _this$props;
+
+        (_this$props$onChange = (_this$props = _this.props).onChange) === null || _this$props$onChange === void 0 ? void 0 : _this$props$onChange.call(_this$props, data);
+      });
+
+      return _this;
+    }
+
+    _createClass$1(ParamValueEditor, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        console.log(1111, 'mounted');
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this2 = this;
+
+        return /*#__PURE__*/React__default["default"].createElement(antd.Form, {
+          className: "param-value-editor",
+          ref: this.ref,
+          key: this.props.valueType,
+          initialValues: this.props.initialValues,
+          onFinish: this.props.onSubmit,
+          onValuesChange: this.onChange
+        }, this.formItems.map(function (it) {
+          return /*#__PURE__*/React__default["default"].createElement(antd.Form.Item, {
+            key: it.name,
+            label: it.label,
+            name: it.name,
+            required: it.required,
+            requiredMark: true,
+            rules: [{
+              validator: it.validator || function () {
+                return Promise.resolve();
+              }
+            }],
+            validateTrigger: 'onBlur'
+          }, /*#__PURE__*/React__default["default"].createElement(it.Comp, {
+            parentOptions: _this2.props.allParams,
+            valueType: _this2.props.valueType
+          }));
+        }), this.props.onSubmit && /*#__PURE__*/React__default["default"].createElement(antd.Button, {
+          type: "primary",
+          htmlType: "submit"
+        }, "\u63D0\u4EA4"));
+      }
+    }]);
+
+    return ParamValueEditor;
+  }(React.PureComponent);
+  var ParamValueEditorModalEl = /*#__PURE__*/function (_PureComponent2) {
+    _inherits(ParamValueEditorModalEl, _PureComponent2);
+
+    var _super2 = _createSuper(ParamValueEditorModalEl);
+
+    function ParamValueEditorModalEl() {
+      var _this3;
+
+      _classCallCheck$1(this, ParamValueEditorModalEl);
+
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+
+      _this3 = _super2.call.apply(_super2, [this].concat(args));
+
+      _defineProperty$2(_assertThisInitialized(_this3), "ref", React__default["default"].createRef());
+
+      _defineProperty$2(_assertThisInitialized(_this3), "state", {
+        visible: false
+      });
+
+      _defineProperty$2(_assertThisInitialized(_this3), "onShow", function () {
+        return _this3.setState({
+          visible: true
+        });
+      });
+
+      _defineProperty$2(_assertThisInitialized(_this3), "onHide", function () {
+        return _this3.setState({
+          visible: false
+        });
+      });
+
+      _defineProperty$2(_assertThisInitialized(_this3), "onSubmit", function () {
+        var form = _this3.ref.current.ref.current;
+        return form.validateFields().then(function () {
+          return _this3.props.onSubmit(form.getFieldsValue());
+        }).then(_this3.onHide);
+      });
+
+      return _this3;
+    }
+
+    _createClass$1(ParamValueEditorModalEl, [{
+      key: "render",
+      value: function render() {
+        return /*#__PURE__*/React__default["default"].createElement(antd.Modal, {
+          key: String(this.state.visible),
+          width: 640,
+          title: 'Edit Value',
+          closable: false,
+          visible: this.state.visible,
+          footer: /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, /*#__PURE__*/React__default["default"].createElement(antd.Button, {
+            onClick: this.onHide
+          }, "Cancel"), /*#__PURE__*/React__default["default"].createElement(antd.Button, {
+            type: "primary",
+            onClick: this.onSubmit
+          }, "Submit"))
+        }, /*#__PURE__*/React__default["default"].createElement(ParamValueEditor, Object.assign({}, this.props, {
+          ref: this.ref,
+          onSubmit: undefined
+        })));
+      }
+    }]);
+
+    return ParamValueEditorModalEl;
+  }(React.PureComponent);
+  var ParamValueEditorModal = /*#__PURE__*/function () {
+    function ParamValueEditorModal() {
+      _classCallCheck$1(this, ParamValueEditorModal);
+    }
+
+    _createClass$1(ParamValueEditorModal, null, [{
+      key: "show",
+      value: function show(props) {
+        return ParamValueEditorModal.el.render(props).then(function () {
+          ParamValueEditorModal.el.ref.onShow();
+        });
+      }
+    }, {
+      key: "hide",
+      value: function hide() {
+        return ParamValueEditorModal.el.render().then(function () {
+          ParamValueEditorModal.el.ref.onHide();
+        });
+      }
+    }]);
+
+    return ParamValueEditorModal;
+  }();
+
+  _defineProperty$2(ParamValueEditorModal, "el", new ReactGlobalComp('param-value-editor-modal', ParamValueEditorModalEl));
+
+  exports.ParamForm = ParamForm;
+  exports.ParamFormModal = ParamFormModal;
+  exports.ParamRenderer = ParamRenderer;
+  exports.ParamTypeConfig = ParamTypeConfig;
+  exports.ParamTypeOptions = ParamTypeOptions;
+  exports.ParamValueEditor = ParamValueEditor;
+  exports.ParamValueEditorModal = ParamValueEditorModal;
+  exports.ParamValueEditorModalEl = ParamValueEditorModalEl;
+  exports.emptyValidator = emptyValidator;
+  exports.expiriesValidator = expiriesValidator;
+  exports.expiryValidator = expiryValidator;
+  exports.formatNum = formatNum;
+  exports.isExpired = isExpired;
+  exports.isNullLike = isNullLike;
+  exports.keyValidator = keyValidator;
+  exports.numRangeValidator = numRangeValidator;
+  exports.paramValidator = paramValidator;
+  exports.validatorCvt = validatorCvt;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));