@noah-libjs/utils 0.0.4 → 0.0.6

package/dist/lib.js

@@ -0,0 +1,2670 @@
+'use strict';
+
+var _defineProperty = require("@babel/runtime/helpers/defineProperty");
+var _createClass = require("@babel/runtime/helpers/createClass");
+var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");
+var _possibleConstructorReturn = require("@babel/runtime/helpers/possibleConstructorReturn");
+var _getPrototypeOf = require("@babel/runtime/helpers/getPrototypeOf");
+var _inherits = require("@babel/runtime/helpers/inherits");
+var _wrapNativeSuper = require("@babel/runtime/helpers/wrapNativeSuper");
+var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");
+var _slicedToArray = require("@babel/runtime/helpers/slicedToArray");
+var _regeneratorRuntime = require("@babel/runtime/regenerator");
+var _toConsumableArray = require("@babel/runtime/helpers/toConsumableArray");
+var _typeof = require("@babel/runtime/helpers/typeof");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+var dayjs = require('dayjs');
+function _interopDefaultLegacy(e) {
+  return e && _typeof(e) === 'object' && 'default' in e ? e : {
+    'default': e
+  };
+}
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+var isSymbol = function isSymbol(value) {
+  return !!value && value.constructor === Symbol;
+};
+var isArray = Array.isArray;
+var isObject = function isObject(value) {
+  return !!value && value.constructor === Object;
+};
+var isPrimitive = function isPrimitive(value) {
+  return value === void 0 || value === null || _typeof(value) !== "object" && typeof value !== "function";
+};
+var isFunction = function isFunction(value) {
+  return !!(value && value.constructor && value.call && value.apply);
+};
+var isString = function isString(value) {
+  return typeof value === "string" || value instanceof String;
+};
+var isInt = function isInt(value) {
+  return isNumber(value) && value % 1 === 0;
+};
+var isFloat = function isFloat(value) {
+  return isNumber(value) && value % 1 !== 0;
+};
+var isNumber = function isNumber(value) {
+  try {
+    return Number(value) === value;
+  } catch (_unused) {
+    return false;
+  }
+};
+var isDate = function isDate(value) {
+  return Object.prototype.toString.call(value) === "[object Date]";
+};
+var isPromise = function isPromise(value) {
+  if (!value) return false;
+  if (!value.then) return false;
+  if (!isFunction(value.then)) return false;
+  return true;
+};
+var isEmpty = function isEmpty(value) {
+  if (value === true || value === false) return true;
+  if (value === null || value === void 0) return true;
+  if (isNumber(value)) return value === 0;
+  if (isDate(value)) return isNaN(value.getTime());
+  if (isFunction(value)) return false;
+  if (isSymbol(value)) return false;
+  var length = value.length;
+  if (isNumber(length)) return length === 0;
+  var size = value.size;
+  if (isNumber(size)) return size === 0;
+  var keys = Object.keys(value).length;
+  return keys === 0;
+};
+var _isEqual = function isEqual(x, y) {
+  if (Object.is(x, y)) return true;
+  if (x instanceof Date && y instanceof Date) {
+    return x.getTime() === y.getTime();
+  }
+  if (x instanceof RegExp && y instanceof RegExp) {
+    return x.toString() === y.toString();
+  }
+  if (_typeof(x) !== "object" || x === null || _typeof(y) !== "object" || y === null) {
+    return false;
+  }
+  var keysX = Reflect.ownKeys(x);
+  var keysY = Reflect.ownKeys(y);
+  if (keysX.length !== keysY.length) return false;
+  for (var i = 0; i < keysX.length; i++) {
+    if (!Reflect.has(y, keysX[i])) return false;
+    if (!_isEqual(x[keysX[i]], y[keysX[i]])) return false;
+  }
+  return true;
+};
+var group = function group(array, getGroupId) {
+  return array.reduce(function (acc, item) {
+    var groupId = getGroupId(item);
+    if (!acc[groupId]) acc[groupId] = [];
+    acc[groupId].push(item);
+    return acc;
+  }, {});
+};
+function zip() {
+  for (var _len = arguments.length, arrays = new Array(_len), _key = 0; _key < _len; _key++) {
+    arrays[_key] = arguments[_key];
+  }
+  if (!arrays || !arrays.length) return [];
+  return new Array(Math.max.apply(Math, _toConsumableArray(arrays.map(function (_ref) {
+    var length = _ref.length;
+    return length;
+  })))).fill([]).map(function (_, idx) {
+    return arrays.map(function (array) {
+      return array[idx];
+    });
+  });
+}
+function zipToObject(keys, values) {
+  if (!keys || !keys.length) {
+    return {};
+  }
+  var getValue = isFunction(values) ? values : isArray(values) ? function (_k, i) {
+    return values[i];
+  } : function (_k, _i) {
+    return values;
+  };
+  return keys.reduce(function (acc, key, idx) {
+    acc[key] = getValue(key, idx);
+    return acc;
+  }, {});
+}
+var boil = function boil(array, compareFunc) {
+  var _array$length;
+  if (!array || ((_array$length = array.length) !== null && _array$length !== void 0 ? _array$length : 0) === 0) return null;
+  return array.reduce(compareFunc);
+};
+function sum(array, fn) {
+  return (array || []).reduce(function (acc, item) {
+    return acc + (fn ? fn(item) : item);
+  }, 0);
+}
+var first = function first(array) {
+  var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : void 0;
+  return (array === null || array === void 0 ? void 0 : array.length) > 0 ? array[0] : defaultValue;
+};
+var last = function last(array) {
+  var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : void 0;
+  return (array === null || array === void 0 ? void 0 : array.length) > 0 ? array[array.length - 1] : defaultValue;
+};
+var sort = function sort(array, getter) {
+  var desc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  if (!array) return [];
+  var asc = function asc(a, b) {
+    return getter(a) - getter(b);
+  };
+  var dsc = function dsc(a, b) {
+    return getter(b) - getter(a);
+  };
+  return array.slice().sort(desc === true ? dsc : asc);
+};
+var alphabetical = function alphabetical(array, getter) {
+  var dir = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "asc";
+  if (!array) return [];
+  var asc = function asc(a, b) {
+    return "".concat(getter(a)).localeCompare(getter(b));
+  };
+  var dsc = function dsc(a, b) {
+    return "".concat(getter(b)).localeCompare(getter(a));
+  };
+  return array.slice().sort(dir === "desc" ? dsc : asc);
+};
+var counting = function counting(list2, identity) {
+  if (!list2) return {};
+  return list2.reduce(function (acc, item) {
+    var _acc$id;
+    var id = identity(item);
+    acc[id] = ((_acc$id = acc[id]) !== null && _acc$id !== void 0 ? _acc$id : 0) + 1;
+    return acc;
+  }, {});
+};
+var replace = function replace(list2, newItem, match) {
+  if (!list2) return [];
+  if (newItem === void 0) return _toConsumableArray(list2);
+  for (var idx = 0; idx < list2.length; idx++) {
+    var item = list2[idx];
+    if (match(item, idx)) {
+      return [].concat(_toConsumableArray(list2.slice(0, idx)), [newItem], _toConsumableArray(list2.slice(idx + 1, list2.length)));
+    }
+  }
+  return _toConsumableArray(list2);
+};
+var objectify = function objectify(array, getKey) {
+  var getValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function (item) {
+    return item;
+  };
+  return array.reduce(function (acc, item) {
+    acc[getKey(item)] = getValue(item);
+    return acc;
+  }, {});
+};
+var select = function select(array, mapper, condition) {
+  if (!array) return [];
+  return array.reduce(function (acc, item, index) {
+    if (!condition(item, index)) return acc;
+    acc.push(mapper(item, index));
+    return acc;
+  }, []);
+};
+function max(array, getter) {
+  var get = getter !== null && getter !== void 0 ? getter : function (v) {
+    return v;
+  };
+  return boil(array, function (a, b) {
+    return get(a) > get(b) ? a : b;
+  });
+}
+function min(array, getter) {
+  var get = getter !== null && getter !== void 0 ? getter : function (v) {
+    return v;
+  };
+  return boil(array, function (a, b) {
+    return get(a) < get(b) ? a : b;
+  });
+}
+var cluster = function cluster(list2) {
+  var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
+  var clusterCount = Math.ceil(list2.length / size);
+  return new Array(clusterCount).fill(null).map(function (_c, i) {
+    return list2.slice(i * size, i * size + size);
+  });
+};
+var unique = function unique(array, toKey) {
+  var valueMap = array.reduce(function (acc, item) {
+    var key = toKey ? toKey(item) : item;
+    if (acc[key]) return acc;
+    acc[key] = item;
+    return acc;
+  }, {});
+  return Object.values(valueMap);
+};
+function range(startOrLength, end) {
+  var valueOrMapper = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function (i) {
+    return i;
+  };
+  var step = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
+  return /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var mapper, start, _final, i;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          mapper = isFunction(valueOrMapper) ? valueOrMapper : function () {
+            return valueOrMapper;
+          };
+          start = end ? startOrLength : 0;
+          _final = end !== null && end !== void 0 ? end : startOrLength;
+          i = start;
+        case 4:
+          if (!(i <= _final)) {
+            _context.next = 12;
+            break;
+          }
+          _context.next = 7;
+          return mapper(i);
+        case 7:
+          if (!(i + step > _final)) {
+            _context.next = 9;
+            break;
+          }
+          return _context.abrupt("break", 12);
+        case 9:
+          i += step;
+          _context.next = 4;
+          break;
+        case 12:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })();
+}
+var list = function list(startOrLength, end, valueOrMapper, step) {
+  return Array.from(range(startOrLength, end, valueOrMapper, step));
+};
+var flat = function flat(lists) {
+  return lists.reduce(function (acc, list2) {
+    acc.push.apply(acc, _toConsumableArray(list2));
+    return acc;
+  }, []);
+};
+var intersects = function intersects(listA, listB, identity) {
+  if (!listA || !listB) return false;
+  var ident = identity !== null && identity !== void 0 ? identity : function (x) {
+    return x;
+  };
+  var dictB = listB.reduce(function (acc, item) {
+    acc[ident(item)] = true;
+    return acc;
+  }, {});
+  return listA.some(function (value) {
+    return dictB[ident(value)];
+  });
+};
+var fork = function fork(list2, condition) {
+  if (!list2) return [[], []];
+  return list2.reduce(function (acc, item) {
+    var _acc = _slicedToArray(acc, 2),
+      a = _acc[0],
+      b = _acc[1];
+    if (condition(item)) {
+      return [[].concat(_toConsumableArray(a), [item]), b];
+    } else {
+      return [a, [].concat(_toConsumableArray(b), [item])];
+    }
+  }, [[], []]);
+};
+var merge = function merge(root, others, matcher) {
+  if (!others && !root) return [];
+  if (!others) return root;
+  if (!root) return [];
+  if (!matcher) return root;
+  return root.reduce(function (acc, r) {
+    var matched = others.find(function (o) {
+      return matcher(r) === matcher(o);
+    });
+    if (matched) acc.push(matched);else acc.push(r);
+    return acc;
+  }, []);
+};
+var replaceOrAppend = function replaceOrAppend(list2, newItem, match) {
+  if (!list2 && !newItem) return [];
+  if (!newItem) return _toConsumableArray(list2);
+  if (!list2) return [newItem];
+  for (var idx = 0; idx < list2.length; idx++) {
+    var item = list2[idx];
+    if (match(item, idx)) {
+      return [].concat(_toConsumableArray(list2.slice(0, idx)), [newItem], _toConsumableArray(list2.slice(idx + 1, list2.length)));
+    }
+  }
+  return [].concat(_toConsumableArray(list2), [newItem]);
+};
+var toggle = function toggle(list2, item, toKey, options) {
+  var _options$strategy;
+  if (!list2 && !item) return [];
+  if (!list2) return [item];
+  if (!item) return _toConsumableArray(list2);
+  var matcher = toKey ? function (x, idx) {
+    return toKey(x, idx) === toKey(item, idx);
+  } : function (x) {
+    return x === item;
+  };
+  var existing = list2.find(matcher);
+  if (existing) return list2.filter(function (x, idx) {
+    return !matcher(x, idx);
+  });
+  var strategy = (_options$strategy = options === null || options === void 0 ? void 0 : options.strategy) !== null && _options$strategy !== void 0 ? _options$strategy : "append";
+  if (strategy === "append") return [].concat(_toConsumableArray(list2), [item]);
+  return [item].concat(_toConsumableArray(list2));
+};
+var sift = function sift(list2) {
+  var _list2$filter;
+  return (_list2$filter = list2 === null || list2 === void 0 ? void 0 : list2.filter(function (x) {
+    return !!x;
+  })) !== null && _list2$filter !== void 0 ? _list2$filter : [];
+};
+var iterate = function iterate(count, func, initValue) {
+  var value = initValue;
+  for (var i = 1; i <= count; i++) {
+    value = func(value, i);
+  }
+  return value;
+};
+var diff = function diff(root, other) {
+  var identity = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function (t) {
+    return t;
+  };
+  if (!(root !== null && root !== void 0 && root.length) && !(other !== null && other !== void 0 && other.length)) return [];
+  if ((root === null || root === void 0 ? void 0 : root.length) === void 0) return _toConsumableArray(other);
+  if (!(other !== null && other !== void 0 && other.length)) return _toConsumableArray(root);
+  var bKeys = other.reduce(function (acc, item) {
+    acc[identity(item)] = true;
+    return acc;
+  }, {});
+  return root.filter(function (a) {
+    return !bKeys[identity(a)];
+  });
+};
+function shift(arr, n) {
+  if (arr.length === 0) return arr;
+  var shiftNumber = n % arr.length;
+  if (shiftNumber === 0) return arr;
+  return [].concat(_toConsumableArray(arr.slice(-shiftNumber, arr.length)), _toConsumableArray(arr.slice(0, -shiftNumber)));
+}
+var reduce = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(array, asyncReducer, initValue) {
+    var initProvided, iter, value, _iterator, _step, _step$value, i, item;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          initProvided = initValue !== void 0;
+          if (!(!initProvided && (array === null || array === void 0 ? void 0 : array.length) < 1)) {
+            _context2.next = 3;
+            break;
+          }
+          throw new Error("Cannot reduce empty array with no init value");
+        case 3:
+          iter = initProvided ? array : array.slice(1);
+          value = initProvided ? initValue : array[0];
+          _iterator = _createForOfIteratorHelper(iter.entries());
+          _context2.prev = 6;
+          _iterator.s();
+        case 8:
+          if ((_step = _iterator.n()).done) {
+            _context2.next = 15;
+            break;
+          }
+          _step$value = _slicedToArray(_step.value, 2), i = _step$value[0], item = _step$value[1];
+          _context2.next = 12;
+          return asyncReducer(value, item, i);
+        case 12:
+          value = _context2.sent;
+        case 13:
+          _context2.next = 8;
+          break;
+        case 15:
+          _context2.next = 20;
+          break;
+        case 17:
+          _context2.prev = 17;
+          _context2.t0 = _context2["catch"](6);
+          _iterator.e(_context2.t0);
+        case 20:
+          _context2.prev = 20;
+          _iterator.f();
+          return _context2.finish(20);
+        case 23:
+          return _context2.abrupt("return", value);
+        case 24:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[6, 17, 20, 23]]);
+  }));
+  return function reduce(_x, _x2, _x3) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+var map = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(array, asyncMapFunc) {
+    var result, index, _iterator2, _step2, value, newValue;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          if (array) {
+            _context3.next = 2;
+            break;
+          }
+          return _context3.abrupt("return", []);
+        case 2:
+          result = [];
+          index = 0;
+          _iterator2 = _createForOfIteratorHelper(array);
+          _context3.prev = 5;
+          _iterator2.s();
+        case 7:
+          if ((_step2 = _iterator2.n()).done) {
+            _context3.next = 15;
+            break;
+          }
+          value = _step2.value;
+          _context3.next = 11;
+          return asyncMapFunc(value, index++);
+        case 11:
+          newValue = _context3.sent;
+          result.push(newValue);
+        case 13:
+          _context3.next = 7;
+          break;
+        case 15:
+          _context3.next = 20;
+          break;
+        case 17:
+          _context3.prev = 17;
+          _context3.t0 = _context3["catch"](5);
+          _iterator2.e(_context3.t0);
+        case 20:
+          _context3.prev = 20;
+          _iterator2.f();
+          return _context3.finish(20);
+        case 23:
+          return _context3.abrupt("return", result);
+        case 24:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[5, 17, 20, 23]]);
+  }));
+  return function map(_x4, _x5) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+var defer = /*#__PURE__*/function () {
+  var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4(func) {
+    var callbacks, register, _yield$tryit, _yield$tryit2, err, response, _i2, _callbacks, _callbacks$_i, fn, rethrow, _yield$tryit3, _yield$tryit4, rethrown;
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          callbacks = [];
+          register = function register(fn, options) {
+            var _options$rethrow;
+            return callbacks.push({
+              fn: fn,
+              rethrow: (_options$rethrow = options === null || options === void 0 ? void 0 : options.rethrow) !== null && _options$rethrow !== void 0 ? _options$rethrow : false
+            });
+          };
+          _context4.next = 4;
+          return tryit(func)(register);
+        case 4:
+          _yield$tryit = _context4.sent;
+          _yield$tryit2 = _slicedToArray(_yield$tryit, 2);
+          err = _yield$tryit2[0];
+          response = _yield$tryit2[1];
+          _i2 = 0, _callbacks = callbacks;
+        case 9:
+          if (!(_i2 < _callbacks.length)) {
+            _context4.next = 21;
+            break;
+          }
+          _callbacks$_i = _callbacks[_i2], fn = _callbacks$_i.fn, rethrow = _callbacks$_i.rethrow;
+          _context4.next = 13;
+          return tryit(fn)(err);
+        case 13:
+          _yield$tryit3 = _context4.sent;
+          _yield$tryit4 = _slicedToArray(_yield$tryit3, 1);
+          rethrown = _yield$tryit4[0];
+          if (!(rethrown && rethrow)) {
+            _context4.next = 18;
+            break;
+          }
+          throw rethrown;
+        case 18:
+          _i2++;
+          _context4.next = 9;
+          break;
+        case 21:
+          if (!err) {
+            _context4.next = 23;
+            break;
+          }
+          throw err;
+        case 23:
+          return _context4.abrupt("return", response);
+        case 24:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return function defer(_x6) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+var AggregateError = /*#__PURE__*/function (_Error) {
+  function AggregateError() {
+    var _errors$find$name, _errors$find, _errors$find$stack, _errors$find2;
+    var _this;
+    var errors = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    _classCallCheck(this, AggregateError);
+    _this = _callSuper(this, AggregateError);
+    var name = (_errors$find$name = (_errors$find = errors.find(function (e) {
+      return e.name;
+    })) === null || _errors$find === void 0 ? void 0 : _errors$find.name) !== null && _errors$find$name !== void 0 ? _errors$find$name : "";
+    _this.name = "AggregateError(".concat(name, "...)");
+    _this.message = "AggregateError with ".concat(errors.length, " errors");
+    _this.stack = (_errors$find$stack = (_errors$find2 = errors.find(function (e) {
+      return e.stack;
+    })) === null || _errors$find2 === void 0 ? void 0 : _errors$find2.stack) !== null && _errors$find$stack !== void 0 ? _errors$find$stack : _this.stack;
+    _this.errors = errors;
+    return _this;
+  }
+  _inherits(AggregateError, _Error);
+  return _createClass(AggregateError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+var parallel = /*#__PURE__*/function () {
+  var _ref5 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6(limit, array, func) {
+    var work, processor, queues, itemResults, _fork, _fork2, errors, results;
+    return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          work = array.map(function (item, index) {
+            return {
+              index: index,
+              item: item
+            };
+          });
+          processor = /*#__PURE__*/function () {
+            var _ref6 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5(res) {
+              var results2, next, _yield$tryit5, _yield$tryit6, error, result;
+              return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+                while (1) switch (_context5.prev = _context5.next) {
+                  case 0:
+                    results2 = [];
+                  case 1:
+                    if (!true) {
+                      _context5.next = 14;
+                      break;
+                    }
+                    next = work.pop();
+                    if (next) {
+                      _context5.next = 5;
+                      break;
+                    }
+                    return _context5.abrupt("return", res(results2));
+                  case 5:
+                    _context5.next = 7;
+                    return tryit(func)(next.item);
+                  case 7:
+                    _yield$tryit5 = _context5.sent;
+                    _yield$tryit6 = _slicedToArray(_yield$tryit5, 2);
+                    error = _yield$tryit6[0];
+                    result = _yield$tryit6[1];
+                    results2.push({
+                      error: error,
+                      result: result,
+                      index: next.index
+                    });
+                    _context5.next = 1;
+                    break;
+                  case 14:
+                  case "end":
+                    return _context5.stop();
+                }
+              }, _callee5);
+            }));
+            return function processor(_x10) {
+              return _ref6.apply(this, arguments);
+            };
+          }();
+          queues = list(1, limit).map(function () {
+            return new Promise(processor);
+          });
+          _context6.next = 5;
+          return Promise.all(queues);
+        case 5:
+          itemResults = _context6.sent;
+          _fork = fork(sort(itemResults.flat(), function (r) {
+            return r.index;
+          }), function (x) {
+            return !!x.error;
+          }), _fork2 = _slicedToArray(_fork, 2), errors = _fork2[0], results = _fork2[1];
+          if (!(errors.length > 0)) {
+            _context6.next = 9;
+            break;
+          }
+          throw new AggregateError(errors.map(function (error) {
+            return error.error;
+          }));
+        case 9:
+          return _context6.abrupt("return", results.map(function (r) {
+            return r.result;
+          }));
+        case 10:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  }));
+  return function parallel(_x7, _x8, _x9) {
+    return _ref5.apply(this, arguments);
+  };
+}();
+function all(_x11) {
+  return _all.apply(this, arguments);
+}
+function _all() {
+  _all = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee11(promises) {
+    var entries, results, exceptions;
+    return _regeneratorRuntime.wrap(function _callee11$(_context11) {
+      while (1) switch (_context11.prev = _context11.next) {
+        case 0:
+          entries = isArray(promises) ? promises.map(function (p) {
+            return [null, p];
+          }) : Object.entries(promises);
+          _context11.next = 3;
+          return Promise.all(entries.map(function (_ref19) {
+            var _ref20 = _slicedToArray(_ref19, 2),
+              key = _ref20[0],
+              value = _ref20[1];
+            return value.then(function (result) {
+              return {
+                result: result,
+                exc: null,
+                key: key
+              };
+            })["catch"](function (exc) {
+              return {
+                result: null,
+                exc: exc,
+                key: key
+              };
+            });
+          }));
+        case 3:
+          results = _context11.sent;
+          exceptions = results.filter(function (r) {
+            return r.exc;
+          });
+          if (!(exceptions.length > 0)) {
+            _context11.next = 7;
+            break;
+          }
+          throw new AggregateError(exceptions.map(function (e) {
+            return e.exc;
+          }));
+        case 7:
+          if (!isArray(promises)) {
+            _context11.next = 9;
+            break;
+          }
+          return _context11.abrupt("return", results.map(function (r) {
+            return r.result;
+          }));
+        case 9:
+          return _context11.abrupt("return", results.reduce(function (acc, item) {
+            return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, item.key, item.result));
+          }, {}));
+        case 10:
+        case "end":
+          return _context11.stop();
+      }
+    }, _callee11);
+  }));
+  return _all.apply(this, arguments);
+}
+var retry = /*#__PURE__*/function () {
+  var _ref7 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7(options, func) {
+    var _options$times, _options$backoff;
+    var times, delay, backoff, _iterator3, _step3, i, _yield$tryit7, _yield$tryit8, err, result;
+    return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          times = (_options$times = options === null || options === void 0 ? void 0 : options.times) !== null && _options$times !== void 0 ? _options$times : 3;
+          delay = options === null || options === void 0 ? void 0 : options.delay;
+          backoff = (_options$backoff = options === null || options === void 0 ? void 0 : options.backoff) !== null && _options$backoff !== void 0 ? _options$backoff : null;
+          _iterator3 = _createForOfIteratorHelper(range(1, times));
+          _context7.prev = 4;
+          _iterator3.s();
+        case 6:
+          if ((_step3 = _iterator3.n()).done) {
+            _context7.next = 28;
+            break;
+          }
+          i = _step3.value;
+          _context7.next = 10;
+          return tryit(func)(function (err2) {
+            throw {
+              _exited: err2
+            };
+          });
+        case 10:
+          _yield$tryit7 = _context7.sent;
+          _yield$tryit8 = _slicedToArray(_yield$tryit7, 2);
+          err = _yield$tryit8[0];
+          result = _yield$tryit8[1];
+          if (err) {
+            _context7.next = 16;
+            break;
+          }
+          return _context7.abrupt("return", result);
+        case 16:
+          if (!err._exited) {
+            _context7.next = 18;
+            break;
+          }
+          throw err._exited;
+        case 18:
+          if (!(i === times)) {
+            _context7.next = 20;
+            break;
+          }
+          throw err;
+        case 20:
+          if (!delay) {
+            _context7.next = 23;
+            break;
+          }
+          _context7.next = 23;
+          return sleep(delay);
+        case 23:
+          if (!backoff) {
+            _context7.next = 26;
+            break;
+          }
+          _context7.next = 26;
+          return sleep(backoff(i));
+        case 26:
+          _context7.next = 6;
+          break;
+        case 28:
+          _context7.next = 33;
+          break;
+        case 30:
+          _context7.prev = 30;
+          _context7.t0 = _context7["catch"](4);
+          _iterator3.e(_context7.t0);
+        case 33:
+          _context7.prev = 33;
+          _iterator3.f();
+          return _context7.finish(33);
+        case 36:
+          return _context7.abrupt("return", void 0);
+        case 37:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7, null, [[4, 30, 33, 36]]);
+  }));
+  return function retry(_x12, _x13) {
+    return _ref7.apply(this, arguments);
+  };
+}();
+var sleep = function sleep(milliseconds) {
+  return new Promise(function (res) {
+    return setTimeout(res, milliseconds);
+  });
+};
+var tryit = function tryit(func) {
+  return function () {
+    try {
+      var result = func.apply(void 0, arguments);
+      if (isPromise(result)) {
+        return result.then(function (value) {
+          return [void 0, value];
+        })["catch"](function (err) {
+          return [err, void 0];
+        });
+      }
+      return [void 0, result];
+    } catch (err) {
+      return [err, void 0];
+    }
+  };
+};
+var guard = function guard(func, shouldGuard) {
+  var _guard = function _guard(err) {
+    if (shouldGuard && !shouldGuard(err)) throw err;
+    return void 0;
+  };
+  var isPromise2 = function isPromise2(result) {
+    return result instanceof Promise;
+  };
+  try {
+    var result = func();
+    return isPromise2(result) ? result["catch"](_guard) : result;
+  } catch (err) {
+    return _guard(err);
+  }
+};
+function chain() {
+  for (var _len2 = arguments.length, funcs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    funcs[_key2] = arguments[_key2];
+  }
+  return function () {
+    return funcs.slice(1).reduce(function (acc, fn) {
+      return fn(acc);
+    }, funcs[0].apply(funcs, arguments));
+  };
+}
+function compose() {
+  for (var _len3 = arguments.length, funcs = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+    funcs[_key3] = arguments[_key3];
+  }
+  return funcs.reverse().reduce(function (acc, fn) {
+    return fn(acc);
+  });
+}
+var partial = function partial(fn) {
+  for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+    args[_key4 - 1] = arguments[_key4];
+  }
+  return function () {
+    for (var _len5 = arguments.length, rest = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+      rest[_key5] = arguments[_key5];
+    }
+    return fn.apply(void 0, [].concat(args, rest));
+  };
+};
+var partob = function partob(fn, argobj) {
+  return function (restobj) {
+    return fn(_objectSpread(_objectSpread({}, argobj), restobj));
+  };
+};
+var proxied = function proxied(handler) {
+  return new Proxy({}, {
+    get: function get(target, propertyName) {
+      return handler(propertyName);
+    }
+  });
+};
+var memoize = function memoize(cache, func, keyFunc, ttl) {
+  return function callWithMemo() {
+    for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+      args[_key6] = arguments[_key6];
+    }
+    var key = keyFunc ? keyFunc.apply(void 0, args) : JSON.stringify({
+      args: args
+    });
+    var existing = cache[key];
+    if (existing !== void 0) {
+      if (!existing.exp) return existing.value;
+      if (existing.exp > new Date().getTime()) {
+        return existing.value;
+      }
+    }
+    var result = func.apply(void 0, args);
+    cache[key] = {
+      exp: ttl ? new Date().getTime() + ttl : null,
+      value: result
+    };
+    return result;
+  };
+};
+var memo = function memo(func) {
+  var _options$key, _options$ttl;
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return memoize({}, func, (_options$key = options.key) !== null && _options$key !== void 0 ? _options$key : null, (_options$ttl = options.ttl) !== null && _options$ttl !== void 0 ? _options$ttl : null);
+};
+var debounce = function debounce(_ref8, func) {
+  var delay = _ref8.delay;
+  var timer = void 0;
+  var active = true;
+  var debounced = function debounced() {
+    for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
+      args[_key7] = arguments[_key7];
+    }
+    if (active) {
+      clearTimeout(timer);
+      timer = setTimeout(function () {
+        active && func.apply(void 0, args);
+        timer = void 0;
+      }, delay);
+    } else {
+      func.apply(void 0, args);
+    }
+  };
+  debounced.isPending = function () {
+    return timer !== void 0;
+  };
+  debounced.cancel = function () {
+    active = false;
+  };
+  debounced.flush = function () {
+    return func.apply(void 0, arguments);
+  };
+  return debounced;
+};
+var throttle = function throttle(_ref9, func) {
+  var interval = _ref9.interval;
+  var ready = true;
+  var timer = void 0;
+  var throttled = function throttled() {
+    if (!ready) return;
+    func.apply(void 0, arguments);
+    ready = false;
+    timer = setTimeout(function () {
+      ready = true;
+      timer = void 0;
+    }, interval);
+  };
+  throttled.isThrottled = function () {
+    return timer !== void 0;
+  };
+  return throttled;
+};
+var callable = function callable(obj, fn) {
+  var FUNC = function FUNC() {};
+  return new Proxy(Object.assign(FUNC, obj), {
+    get: function get(target, key) {
+      return target[key];
+    },
+    set: function set(target, key, value) {
+      target[key] = value;
+      return true;
+    },
+    apply: function apply(target, self, args) {
+      return fn(Object.assign({}, target)).apply(void 0, _toConsumableArray(args));
+    }
+  });
+};
+function inRange(number, start, end) {
+  var isTypeSafe = typeof number === "number" && typeof start === "number" && (typeof end === "undefined" || typeof end === "number");
+  if (!isTypeSafe) {
+    return false;
+  }
+  if (typeof end === "undefined") {
+    end = start;
+    start = 0;
+  }
+  return number >= Math.min(start, end) && number < Math.max(start, end);
+}
+var toFloat = function toFloat(value, defaultValue) {
+  var def = defaultValue === void 0 ? 0 : defaultValue;
+  if (value === null || value === void 0) {
+    return def;
+  }
+  var result = parseFloat(value);
+  return isNaN(result) ? def : result;
+};
+var toInt = function toInt(value, defaultValue) {
+  var def = defaultValue === void 0 ? 0 : defaultValue;
+  if (value === null || value === void 0) {
+    return def;
+  }
+  var result = parseInt(value);
+  return isNaN(result) ? def : result;
+};
+var shake = function shake(obj) {
+  var filter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (x) {
+    return x === void 0;
+  };
+  if (!obj) return {};
+  var keys2 = Object.keys(obj);
+  return keys2.reduce(function (acc, key) {
+    if (filter(obj[key])) {
+      return acc;
+    } else {
+      acc[key] = obj[key];
+      return acc;
+    }
+  }, {});
+};
+var mapKeys = function mapKeys(obj, mapFunc) {
+  var keys2 = Object.keys(obj);
+  return keys2.reduce(function (acc, key) {
+    acc[mapFunc(key, obj[key])] = obj[key];
+    return acc;
+  }, {});
+};
+var mapValues = function mapValues(obj, mapFunc) {
+  var keys2 = Object.keys(obj);
+  return keys2.reduce(function (acc, key) {
+    acc[key] = mapFunc(obj[key], key);
+    return acc;
+  }, {});
+};
+var mapEntries = function mapEntries(obj, toEntry) {
+  if (!obj) return {};
+  return Object.entries(obj).reduce(function (acc, _ref10) {
+    var _ref11 = _slicedToArray(_ref10, 2),
+      key = _ref11[0],
+      value = _ref11[1];
+    var _toEntry = toEntry(key, value),
+      _toEntry2 = _slicedToArray(_toEntry, 2),
+      newKey = _toEntry2[0],
+      newValue = _toEntry2[1];
+    acc[newKey] = newValue;
+    return acc;
+  }, {});
+};
+var invert = function invert(obj) {
+  if (!obj) return {};
+  var keys2 = Object.keys(obj);
+  return keys2.reduce(function (acc, key) {
+    acc[obj[key]] = key;
+    return acc;
+  }, {});
+};
+var lowerize = function lowerize(obj) {
+  return mapKeys(obj, function (k) {
+    return k.toLowerCase();
+  });
+};
+var upperize = function upperize(obj) {
+  return mapKeys(obj, function (k) {
+    return k.toUpperCase();
+  });
+};
+var clone = function clone(obj) {
+  if (isPrimitive(obj)) {
+    return obj;
+  }
+  if (typeof obj === "function") {
+    return obj.bind({});
+  }
+  var newObj = new obj.constructor();
+  Object.getOwnPropertyNames(obj).forEach(function (prop) {
+    newObj[prop] = obj[prop];
+  });
+  return newObj;
+};
+var listify = function listify(obj, toItem) {
+  if (!obj) return [];
+  var entries = Object.entries(obj);
+  if (entries.length === 0) return [];
+  return entries.reduce(function (acc, entry) {
+    acc.push(toItem(entry[0], entry[1]));
+    return acc;
+  }, []);
+};
+var pick = function pick(obj, keys2) {
+  if (!obj) return {};
+  return keys2.reduce(function (acc, key) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) acc[key] = obj[key];
+    return acc;
+  }, {});
+};
+var omit = function omit(obj, keys2) {
+  if (!obj) return {};
+  if (!keys2 || keys2.length === 0) return obj;
+  return keys2.reduce(function (acc, key) {
+    delete acc[key];
+    return acc;
+  }, _objectSpread({}, obj));
+};
+var get$1 = function get$1(value, path, defaultValue) {
+  var segments = path.split(/[\.\[\]]/g);
+  var current = value;
+  var _iterator4 = _createForOfIteratorHelper(segments),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var key = _step4.value;
+      if (current === null) return defaultValue;
+      if (current === void 0) return defaultValue;
+      var dequoted = key.replace(/['"]/g, "");
+      if (dequoted.trim() === "") continue;
+      current = current[dequoted];
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  if (current === void 0) return defaultValue;
+  return current;
+};
+var set = function set(initial, path, value) {
+  if (!initial) return {};
+  if (!path || value === void 0) return initial;
+  var segments = path.split(/[\.\[\]]/g).filter(function (x) {
+    return !!x.trim();
+  });
+  var _set2 = function _set(node) {
+    if (segments.length > 1) {
+      var key = segments.shift();
+      var nextIsNum = toInt(segments[0], null) === null ? false : true;
+      node[key] = node[key] === void 0 ? nextIsNum ? [] : {} : node[key];
+      _set2(node[key]);
+    } else {
+      node[segments[0]] = value;
+    }
+  };
+  var cloned = clone(initial);
+  _set2(cloned);
+  return cloned;
+};
+var _assign = function assign(initial, override) {
+  var _ref12;
+  if (!initial || !override) return (_ref12 = initial !== null && initial !== void 0 ? initial : override) !== null && _ref12 !== void 0 ? _ref12 : {};
+  return Object.entries(_objectSpread(_objectSpread({}, initial), override)).reduce(function (acc, _ref13) {
+    var _ref14 = _slicedToArray(_ref13, 2),
+      key = _ref14[0],
+      value = _ref14[1];
+    return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, key, function () {
+      if (isObject(initial[key])) return _assign(initial[key], value);
+      return value;
+    }()));
+  }, {});
+};
+var keys = function keys(value) {
+  if (!value) return [];
+  var _getKeys = function getKeys(nested, paths) {
+    if (isObject(nested)) {
+      return Object.entries(nested).flatMap(function (_ref15) {
+        var _ref16 = _slicedToArray(_ref15, 2),
+          k = _ref16[0],
+          v = _ref16[1];
+        return _getKeys(v, [].concat(_toConsumableArray(paths), [k]));
+      });
+    }
+    if (isArray(nested)) {
+      return nested.flatMap(function (item, i) {
+        return _getKeys(item, [].concat(_toConsumableArray(paths), ["".concat(i)]));
+      });
+    }
+    return [paths.join(".")];
+  };
+  return _getKeys(value, []);
+};
+var crush = function crush(value) {
+  if (!value) return {};
+  return objectify(keys(value), function (k) {
+    return k;
+  }, function (k) {
+    return get$1(value, k);
+  });
+};
+var construct = function construct(obj) {
+  if (!obj) return {};
+  return Object.keys(obj).reduce(function (acc, path) {
+    return set(acc, path, obj[path]);
+  }, {});
+};
+var random = function random(min, max) {
+  return Math.floor(Math.random() * (max - min + 1) + min);
+};
+var draw = function draw(array) {
+  var max = array.length;
+  if (max === 0) {
+    return null;
+  }
+  var index = random(0, max - 1);
+  return array[index];
+};
+var shuffle = function shuffle(array) {
+  return array.map(function (a) {
+    return {
+      rand: Math.random(),
+      value: a
+    };
+  }).sort(function (a, b) {
+    return a.rand - b.rand;
+  }).map(function (a) {
+    return a.value;
+  });
+};
+var uid = function uid(length) {
+  var specials = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+  var characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" + specials;
+  return iterate(length, function (acc) {
+    return acc + characters.charAt(random(0, characters.length - 1));
+  }, "");
+};
+var series = function series(items) {
+  var toKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (item) {
+    return "".concat(item);
+  };
+  var _items$reduce = items.reduce(function (acc, item, idx) {
+      return {
+        indexesByKey: _objectSpread(_objectSpread({}, acc.indexesByKey), {}, _defineProperty({}, toKey(item), idx)),
+        itemsByIndex: _objectSpread(_objectSpread({}, acc.itemsByIndex), {}, _defineProperty({}, idx, item))
+      };
+    }, {
+      indexesByKey: {},
+      itemsByIndex: {}
+    }),
+    indexesByKey = _items$reduce.indexesByKey,
+    itemsByIndex = _items$reduce.itemsByIndex;
+  var min = function min(a, b) {
+    return indexesByKey[toKey(a)] < indexesByKey[toKey(b)] ? a : b;
+  };
+  var max = function max(a, b) {
+    return indexesByKey[toKey(a)] > indexesByKey[toKey(b)] ? a : b;
+  };
+  var first = function first() {
+    return itemsByIndex[0];
+  };
+  var last = function last() {
+    return itemsByIndex[items.length - 1];
+  };
+  var next = function next(current, defaultValue) {
+    var _ref17, _itemsByIndex;
+    return (_ref17 = (_itemsByIndex = itemsByIndex[indexesByKey[toKey(current)] + 1]) !== null && _itemsByIndex !== void 0 ? _itemsByIndex : defaultValue) !== null && _ref17 !== void 0 ? _ref17 : first();
+  };
+  var previous = function previous(current, defaultValue) {
+    var _ref18, _itemsByIndex2;
+    return (_ref18 = (_itemsByIndex2 = itemsByIndex[indexesByKey[toKey(current)] - 1]) !== null && _itemsByIndex2 !== void 0 ? _itemsByIndex2 : defaultValue) !== null && _ref18 !== void 0 ? _ref18 : last();
+  };
+  var spin = function spin(current, num) {
+    if (num === 0) return current;
+    var abs = Math.abs(num);
+    var rel = abs > items.length ? abs % items.length : abs;
+    return list(0, rel - 1).reduce(function (acc) {
+      return num > 0 ? next(acc) : previous(acc);
+    }, current);
+  };
+  return {
+    min: min,
+    max: max,
+    first: first,
+    last: last,
+    next: next,
+    previous: previous,
+    spin: spin
+  };
+};
+var capitalize = function capitalize(str) {
+  if (!str || str.length === 0) return "";
+  var lower = str.toLowerCase();
+  return lower.substring(0, 1).toUpperCase() + lower.substring(1, lower.length);
+};
+var camel = function camel(str) {
+  var _str$replace$split$ma, _str$replace;
+  var parts = (_str$replace$split$ma = str === null || str === void 0 || (_str$replace = str.replace(/([A-Z])+/g, capitalize)) === null || _str$replace === void 0 ? void 0 : _str$replace.split(/(?=[A-Z])|[\.\-\s_]/).map(function (x) {
+    return x.toLowerCase();
+  })) !== null && _str$replace$split$ma !== void 0 ? _str$replace$split$ma : [];
+  if (parts.length === 0) return "";
+  if (parts.length === 1) return parts[0];
+  return parts.reduce(function (acc, part) {
+    return "".concat(acc).concat(part.charAt(0).toUpperCase()).concat(part.slice(1));
+  });
+};
+var snake = function snake(str, options) {
+  var _str$replace$split$ma2;
+  var parts = (_str$replace$split$ma2 = str === null || str === void 0 ? void 0 : str.replace(/([A-Z])+/g, capitalize).split(/(?=[A-Z])|[\.\-\s_]/).map(function (x) {
+    return x.toLowerCase();
+  })) !== null && _str$replace$split$ma2 !== void 0 ? _str$replace$split$ma2 : [];
+  if (parts.length === 0) return "";
+  if (parts.length === 1) return parts[0];
+  var result = parts.reduce(function (acc, part) {
+    return "".concat(acc, "_").concat(part.toLowerCase());
+  });
+  return (options === null || options === void 0 ? void 0 : options.splitOnNumber) === false ? result : result.replace(/([A-Za-z]{1}[0-9]{1})/, function (val) {
+    return "".concat(val[0], "_").concat(val[1]);
+  });
+};
+var dash = function dash(str) {
+  var _str$replace$split$ma3, _str$replace2;
+  var parts = (_str$replace$split$ma3 = str === null || str === void 0 || (_str$replace2 = str.replace(/([A-Z])+/g, capitalize)) === null || _str$replace2 === void 0 ? void 0 : _str$replace2.split(/(?=[A-Z])|[\.\-\s_]/).map(function (x) {
+    return x.toLowerCase();
+  })) !== null && _str$replace$split$ma3 !== void 0 ? _str$replace$split$ma3 : [];
+  if (parts.length === 0) return "";
+  if (parts.length === 1) return parts[0];
+  return parts.reduce(function (acc, part) {
+    return "".concat(acc, "-").concat(part.toLowerCase());
+  });
+};
+var pascal = function pascal(str) {
+  var _str$split$map;
+  var parts = (_str$split$map = str === null || str === void 0 ? void 0 : str.split(/[\.\-\s_]/).map(function (x) {
+    return x.toLowerCase();
+  })) !== null && _str$split$map !== void 0 ? _str$split$map : [];
+  if (parts.length === 0) return "";
+  return parts.map(function (str2) {
+    return str2.charAt(0).toUpperCase() + str2.slice(1);
+  }).join("");
+};
+var title = function title(str) {
+  if (!str) return "";
+  return str.split(/(?=[A-Z])|[\.\-\s_]/).map(function (s) {
+    return s.trim();
+  }).filter(function (s) {
+    return !!s;
+  }).map(function (s) {
+    return capitalize(s.toLowerCase());
+  }).join(" ");
+};
+var template = function template(str, data) {
+  var regex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : /\{\{(.+?)\}\}/g;
+  return Array.from(str.matchAll(regex)).reduce(function (acc, match) {
+    return acc.replace(match[0], data[match[1]]);
+  }, str);
+};
+var trim = function trim(str) {
+  var charsToTrim = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : " ";
+  if (!str) return "";
+  var toTrim = charsToTrim.replace(/[\W]{1}/g, "\\$&");
+  var regex = new RegExp("^[".concat(toTrim, "]+|[").concat(toTrim, "]+$"), "g");
+  return str.replace(regex, "");
+};
+function get(value, path, defaultValue) {
+  //@ts-ignore
+  var direct_value = value === null || value === void 0 ? void 0 : value[path];
+  if (direct_value) return direct_value;
+  return get$1(value, path, defaultValue);
+}
+function identity(value) {
+  return value;
+}
+var symbolProto = Symbol ? Symbol.prototype : undefined;
+var symbolToString = symbolProto ? symbolProto.toString : undefined;
+var INFINITY = 1 / 0;
+function isBoolean(value) {
+  return value === true || value === false;
+}
+function isObjectLike(value) {
+  return value != null && _typeof(value) == 'object';
+}
+function isNull(value) {
+  return value === null;
+}
+function size(value) {
+  if (isString(value) || isArray(value)) return value.length;
+  if (isObject(value)) return Object.keys(value).length;
+  return 0;
+}
+function isNil(value) {
+  return value == null;
+}
+function toString(value) {
+  return value == null ? '' : baseToString(value);
+}
+function baseToString(value) {
+  // Exit early for strings to avoid a performance hit in some environments.
+  if (typeof value == 'string') {
+    return value;
+  }
+  if (isArray(value)) {
+    // Recursively convert values (susceptible to call stack limits).
+    return arrayMap(value, baseToString) + '';
+  }
+  if (isSymbol(value)) {
+    return symbolToString ? symbolToString.call(value) : '';
+  }
+  var result = value + '';
+  return result == '0' && 1 / value == -INFINITY ? '-0' : result;
+}
+function arrayMap(array, iteratee) {
+  var index = -1,
+    length = array == null ? 0 : array.length,
+    result = Array(length);
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+function cloneDeep(value) {
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch (error) {
+    return null;
+  }
+}
+function safe_json_parse(str) {
+  var retOnErr = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  if (!str) return retOnErr;
+  if (_typeof(str) === 'object') return str;
+  if (!isString(str)) return retOnErr;
+  try {
+    var v = JSON.parse(str);
+    return isObject(v) || Array.isArray(v) ? v : retOnErr;
+  } catch (error) {
+    return retOnErr;
+  }
+}
+function safe_json_stringify(obj) {
+  if (isString(obj) && safe_json_parse(obj)) {
+    return obj;
+  }
+  return JSON.stringify(obj);
+}
+function safe_json_parse_arr(str) {
+  var retOnErr = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  if (!str) return retOnErr;
+  if (Array.isArray(str)) return str;
+  if (!isString(str)) return retOnErr;
+  try {
+    var v = JSON.parse(str);
+    return Array.isArray(v) ? v : retOnErr;
+  } catch (error) {
+    return retOnErr;
+  }
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+// export function sleep(sec: number) {
+//     return new Promise<void>((resolve) => setTimeout(resolve, sec * 1000))
+// }
+function get_global() {
+  var _a;
+  return (_a = window !== null && window !== void 0 ? window : globalThis) !== null && _a !== void 0 ? _a : global;
+}
+function getSearchParamsValue(key) {
+  var _a, _b;
+  var url = new URL(location.toString());
+  return (_b = (_a = url === null || url === void 0 ? void 0 : url.searchParams) === null || _a === void 0 ? void 0 : _a.get(key)) !== null && _b !== void 0 ? _b : null;
+}
+function getSearchParamsAll(url) {
+  var _url = url !== null && url !== void 0 ? url : new URL(location.href);
+  var searchParams = _url ? _toConsumableArray(_url.searchParams.entries()).reduce(function (a, b) {
+    return Object.assign(a, _defineProperty({}, b[0], b[1]));
+  }, {}) : {};
+  return searchParams;
+}
+function setSearchParamsValue(key, value) {
+  var _a;
+  var url = new URL(location.toString());
+  (_a = url === null || url === void 0 ? void 0 : url.searchParams) === null || _a === void 0 ? void 0 : _a.set(key, "".concat(value));
+  return url;
+}
+function setSearchParamsAll(data) {
+  var _url = new URL(location.href);
+  Object.keys(data).forEach(function (k) {
+    var _a;
+    (_a = _url === null || _url === void 0 ? void 0 : _url.searchParams) === null || _a === void 0 ? void 0 : _a.set(k, "".concat(data[k]));
+  });
+  return _url;
+}
+function scrollIntoView(symbol) {
+  var finder = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : document.querySelector.bind(document);
+  var dom = finder(symbol);
+  var scrollIntoViewIfNeeded = dom === null || dom === void 0 ? void 0 : dom.scrollIntoViewIfNeeded;
+  if (scrollIntoViewIfNeeded) {
+    scrollIntoViewIfNeeded.call(dom);
+  } else {
+    dom === null || dom === void 0 ? void 0 : dom.scrollIntoView({
+      behavior: 'smooth'
+    });
+  }
+}
+function base64ToBinary(data, type) {
+  var raw = get_global().atob(data);
+  var uInt8Array = new Uint8Array(raw.length);
+  for (var i = 0; i < raw.length; i++) {
+    uInt8Array[i] = raw.charCodeAt(i);
+  }
+  return new Blob([uInt8Array], {
+    type: type
+  });
+}
+function downloadFile(content) {
+  var filename = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '问卷答题情况.xlsx';
+  var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'application/vnd.ms-excel';
+  var isBase64 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var eleLink = document.createElement('a');
+  eleLink.download = filename;
+  eleLink.style.display = 'none';
+  var blob = typeof content === 'string' ? isBase64 ? base64ToBinary(content, type) : new Blob([content], {
+    type: type
+  }) : content;
+  eleLink.href = URL.createObjectURL(blob);
+  document.body.appendChild(eleLink);
+  eleLink.click();
+  document.body.removeChild(eleLink);
+}
+function uuid() {
+  var temp_url = URL.createObjectURL(new Blob());
+  var uuid = temp_url.toString();
+  URL.revokeObjectURL(temp_url);
+  return uuid.slice(uuid.lastIndexOf("/") + 1);
+}
+function randomHex() {
+  var hex = ~~(Math.random() * 16);
+  return hex;
+}
+function charToUTF8(_char) {
+  var encoder = new TextEncoder();
+  var uint8Array = encoder.encode(_char[0]);
+  return Array.from(uint8Array);
+}
+function charToUnicode(_char2) {
+  // ES6 之后可以用 String.prototype.codePointAt() 从字符返回对应的码点
+  var u = _char2.charCodeAt(0);
+  var u1 = _char2.charCodeAt(0);
+  var u2 = _char2.charCodeAt(1);
+  if (u1 >= 0xD800 && u1 <= 0xDBFF && u2 >= 0xDC00 && u2 <= 0xDFFF) {
+    u = (u1 - 0xD800 << 10 | u2 - 0xDC00) + 0x10000;
+  }
+  return u;
+}
+// 先转 utf-8 再 decode
+function unicodeToChar(u) {
+  var arr = unicode_to_UTF8(u);
+  if (!arr) return null;
+  var decoder = new TextDecoder();
+  var ui8 = new Uint8Array(arr);
+  return decoder.decode(ui8);
+}
+function unicode_to_UTF8(u) {
+  var arr = null; //utf8;
+  if (u <= 0x7F) {
+    arr = [u & 0xFF];
+  } else if (u <= 0x07FF) {
+    arr = [u >> 6 & 0x1F | 0xC0, u & 0x3F | 0x80];
+  } else if (u <= 0xFFFF) {
+    arr = [u >> 12 & 0x0F | 0xE0, u >> 6 & 0x3F | 0x80, u & 0x3F | 0x80];
+  } else if (u <= 0x10FFFF) {
+    arr = [u >> 18 & 0x07 | 0xF0, u >> 12 & 0x3F | 0x80, u >> 6 & 0x3F | 0x80, u & 0x3F | 0x80];
+  }
+  if (!arr) return null;
+  return arr;
+}
+function getFilledArray(n) {
+  return Array(n).fill(0);
+}
+function copyText(text) {
+  var textareaC = document.createElement('textarea');
+  textareaC.setAttribute('readonly', 'readonly');
+  textareaC.value = text;
+  document.body.appendChild(textareaC);
+  textareaC.select();
+  var res = document.execCommand('copy');
+  document.body.removeChild(textareaC);
+  return res;
+}
+function safeExec(fn) {
+  for (var _len8 = arguments.length, args = new Array(_len8 > 1 ? _len8 - 1 : 0), _key8 = 1; _key8 < _len8; _key8++) {
+    args[_key8 - 1] = arguments[_key8];
+  }
+  return isFunction(fn) ? fn.apply(void 0, args) : null;
+}
+function safeGetFromFuncOrData(fn) {
+  var _a;
+  return (_a = safeExec(fn)) !== null && _a !== void 0 ? _a : fn;
+}
+function numberLikeCompare(a, b) {
+  if (a === b) return true;
+  if (isString(a) && isString(b)) {
+    return a === b;
+  }
+  if (isNil(a) || isNil(b)) return false;
+  if (isObject(a) || isObject(b)) return false;
+  if (isBoolean(a) && !isBoolean(b)) return false;
+  if (isBoolean(b) && !isBoolean(a)) return false;
+  if (toInt(a, NaN) === toInt(b, NaN)) return true;
+  if (toFloat(a, NaN) === toFloat(b, NaN)) return true;
+  if (toString(a) === toString(b)) return true;
+  return false;
+}
+function warpBase64Type(str, type) {
+  if (!str) return str;
+  if (type === 'img') {
+    return str.startsWith('data:image/png;base64,') ? str : "data:image/png;base64,".concat(str);
+  }
+  if (type === 'pdf') {
+    return str.startsWith('data:application/json;base64,') ? str : "data:application/json;base64,".concat(str);
+  }
+  return str;
+}
+function safe_number_parse(value) {
+  var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : NaN;
+  if (isNumber(value) && !isNaN(value)) return value;
+  var rawParse = Number(value);
+  return isNaN(rawParse) ? defaultValue : rawParse;
+}
+function expect_array(value) {
+  var default_v = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  if (!Array.isArray(value)) {
+    if (Array.isArray(default_v)) return default_v;
+    return [];
+  }
+  return value;
+}
+// 生成包含字符的 svg 转义字符串
+function gen_encoded_char_svg(props) {
+  var _char3 = props["char"],
+    _props$size = props.size,
+    size = _props$size === void 0 ? 12 : _props$size,
+    _props$color = props.color,
+    color = _props$color === void 0 ? 'cc0000' : _props$color;
+  var _color = (color === null || color === void 0 ? void 0 : color.startsWith('#')) ? color.slice(1) : color;
+  return "data:image/svg+xml,%3Csvg \n    width='".concat(size + 2, "' height='").concat(size + 2, "' \n    xmlns='http://www.w3.org/2000/svg'%3E%3Ctext x='50%25' y='50%25' \n    font-size='").concat(size, "' \n    fill='%23").concat(_color, "' \n    font-weight='bold'\n    text-anchor='middle' \n    dominant-baseline='middle'%3E").concat(_char3, "%3C/text%3E%3C/svg%3E");
+}
+function base64_to_image(base64img) {
+  return new Promise(function (res, rej) {
+    if (!base64img) res(null);
+    var img = new Image();
+    img.onload = function () {
+      res(img);
+    };
+    img.src = base64img;
+  });
+}
+function image_to_base64(img_el) {
+  if (!img_el) return null;
+  var c = document.createElement('canvas');
+  c.width = img_el.width;
+  c.height = img_el.height;
+  var ctx = c.getContext('2d');
+  ctx === null || ctx === void 0 ? void 0 : ctx.drawImage(img_el, 0, 0, img_el.width, img_el.height);
+  var base64 = c.toDataURL('image/png');
+  return base64;
+}
+function filter_obj_to_url_search(obj) {
+  if (!obj) return {};
+  var clone_one = {};
+  keys(obj).forEach(function (k) {
+    var v = obj[k];
+    if (isNumber(v) || isBoolean(v) || isString(v) || isNull(v)) {
+      clone_one[k] = v;
+    }
+  });
+  return clone_one;
+}
+function safe_async_call(cb) {
+  for (var _len9 = arguments.length, args = new Array(_len9 > 1 ? _len9 - 1 : 0), _key9 = 1; _key9 < _len9; _key9++) {
+    args[_key9 - 1] = arguments[_key9];
+  }
+  return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+    return _regeneratorRuntime.wrap(function _callee8$(_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          if (isFunction(cb)) {
+            _context8.next = 2;
+            break;
+          }
+          return _context8.abrupt("return", null);
+        case 2:
+          _context8.next = 4;
+          return Promise.resolve(cb.apply(void 0, args));
+        case 4:
+          return _context8.abrupt("return", _context8.sent);
+        case 5:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8);
+  }));
+}
+get_global().safe_async_call = safe_async_call;
+var global_cache_map = {};
+function cache_fetch(key, cb) {
+  return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+    var _a, conf;
+    return _regeneratorRuntime.wrap(function _callee9$(_context9) {
+      while (1) switch (_context9.prev = _context9.next) {
+        case 0:
+          conf = global_cache_map[key] = (_a = global_cache_map[key]) !== null && _a !== void 0 ? _a : {};
+          if (!conf.cache) {
+            _context9.next = 3;
+            break;
+          }
+          return _context9.abrupt("return", conf.cache);
+        case 3:
+          if (!conf.cache_promise) {
+            _context9.next = 5;
+            break;
+          }
+          return _context9.abrupt("return", conf.cache_promise);
+        case 5:
+          return _context9.abrupt("return", conf.cache_promise = cb().then(function (r) {
+            return conf.cache = r;
+          }));
+        case 6:
+        case "end":
+          return _context9.stop();
+      }
+    }, _callee9);
+  }));
+}
+function speculate_on_display(value) {
+  if (!value) return '';
+  if (isNumber(value)) return value + '';
+  if (Array.isArray(value)) {
+    var item0 = value[0];
+    return (item0 === null || item0 === void 0 ? void 0 : item0.label) || (item0 === null || item0 === void 0 ? void 0 : item0.value);
+  }
+  if (isObjectLike(value)) {
+    return value.label || value.value;
+  }
+  if (isString(value)) {
+    var obj = safe_json_parse(value);
+    return speculate_on_display(obj) || value;
+  }
+  return '';
+}
+// 00:00 00:05 ... 23:55
+function getFuckTimeInterval() {
+  var star_hour = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  var end_hour = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 24;
+  var min_interval = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 5;
+  return Array(end_hour - star_hour).fill(0).map(function (_, hour) {
+    var hour_str = (hour + star_hour).toString().padStart(2, '0');
+    var min_counts = 60 / min_interval;
+    return Array(min_counts).fill(0).map(function (_, min) {
+      var min_str = (min * min_interval).toString().padStart(2, '0');
+      return "".concat(hour_str, ":").concat(min_str);
+    });
+  }).flat();
+}
+// export function getTimeSlice(hour = 24, isShowSecond = false) {
+//     const hourArr = Array(hour).fill(0) as number[]
+//     const minuteArr = Array(60).fill(0) as number[]
+//     return hourArr.reduce((sum, h, hIdx) => {
+//         return [...sum, ...minuteArr.map((m, mIdx) => `${hIdx}:${mIdx}`)]
+//     }, [] as string[])
+// }
+var word = [['abundant', ' 丰富的', '/əˈbʌndənt/'], ['eloquent', ' 雄辩的', '/ˈeləkwənt/'], ['meticulous', ' 细致的', '/məˈtɪkjʊləs/'], ['resilient', ' 有韧性的', '/rɪˈzɪliənt/'], ['versatile', ' 多才多艺的', '/ˈvɜːsətaɪl/'], ['pragmatic', ' 务实的', '/præɡˈmætɪk/'], ['inevitable', ' 不可避免的', '/ɪˈnevɪtəbl/'], ['ambiguous', ' 模棱两可的', '/æmˈbɪɡjuəs/'], ['spontaneous', ' 自发的', '/spɒnˈteɪniəs/'], ['conscientious', ' 认真的', '/ˌkɒnʃiˈenʃəs/'], ['impeccable', ' 无瑕疵的', '/ɪmˈpekəbl/'], ['tenacious', ' 顽强的', '/təˈneɪʃəs/'], ['prolific', ' 多产的', '/prəˈlɪfɪk/']];
+function random_word() {
+  return word[Math.random() * word.length | 0];
+}
+function confirm_operation() {
+  var word = random_word();
+  return prompt("\u8BF7\u8F93\u5165 ".concat(word[0], "\uFF08").concat(word[2], " adj.").concat(word[1], "\uFF09 \u4EE5\u786E\u8BA4\u4F60\u7684\u64CD\u4F5C")) === word[0];
+}
+// ES6 新增的方法
+// '😎'.charCodeAt(0).toString(16) == 'd83d' // UTF-16 码元
+// '😎'.charCodeAt(1).toString(16) == 'de0e'
+// '😎'.codePointAt(0)?.toString(16) == '1f60e'// Unicode 码点
+function simple_encrypt(data) {
+  if (!data) return null;
+  return JSON.stringify(data).split('').map(function (_, idx) {
+    return ~_.charCodeAt(0) + idx * 119;
+  });
+}
+function simple_decrypt(code) {
+  if (!code) return null;
+  var str = expect_array(code).map(function (_, idx) {
+    return String.fromCharCode(~(_ - idx * 119));
+  }).join('');
+  return safe_json_parse(str);
+}
+function simple_encrypt_str(data) {
+  if (!data || !isString(data)) return null;
+  return data.split('').map(function (_, idx) {
+    return ~_.charCodeAt(0) + idx * 119;
+  }).join('@@');
+}
+function simple_decrypt_str(code) {
+  if (!code || !isString(code)) return null;
+  var str = code.split('@@').map(function (_, idx) {
+    return String.fromCharCode(~(+_ - idx * 119));
+  }).join('');
+  return str;
+}
+function getFn(format) {
+  function f(s) {
+    if (isFunction(s === null || s === void 0 ? void 0 : s.format)) {
+      var res = s.format(format);
+      if (isString(res)) return res;
+    }
+    var a = dayjs__default["default"](s);
+    return a.isValid() ? a.format(format) : null;
+  }
+  return Object.assign(f, {
+    format: format
+  });
+}
+function getMomentObj(s) {
+  return dayjs__default["default"](s);
+}
+var formatDate = getFn('YYYY-MM-DD');
+var formatDateTime = getFn('YYYY-MM-DD HH:mm:ss');
+var formatDateTimeNoSecond = getFn('YYYY-MM-DD HH:mm');
+var formatTime = getFn('HH:mm:ss');
+function start() {
+  var m = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : dayjs__default["default"];
+  return m().set('hour', 0).set('minute', 0).set('second', 0);
+}
+function end() {
+  var m = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : dayjs__default["default"];
+  return m().set('hour', 23).set('minute', 59).set('second', 59);
+}
+function getMomentRange() {
+  var m = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : dayjs__default["default"];
+  return {
+    昨天: [start(m).add(-1, 'day'), end(m).add(-1, 'day')],
+    今天: [start(m), end(m)],
+    明天: [start(m).add(1, 'day'), end(m).add(1, 'day')],
+    上周: [start(m).add(-1, 'week').startOf('week'), end(m).add(-1, 'week').endOf('week')],
+    // 这周: [start(m).startOf('week'), end(m).endOf('week')] as DT,
+    近一周: [start(m).add(-1, 'week').add(1, 'day'), end(m)],
+    下周: [start(m).add(1, 'week').startOf('week'), end(m).add(1, 'week').endOf('week')],
+    上月: [start(m).add(-1, 'month').startOf('month'), end(m).add(-1, 'month').endOf('month')],
+    // 这月: [start(m).startOf('month'), end(m).endOf('month')] as DT,
+    近一月: [start(m).add(-1, 'month').add(1, 'day'), end(m)],
+    下月: [start(m).add(1, 'month').startOf('month'), end(m).add(1, 'month').endOf('month')],
+    近一年: [start(m).add(-1, 'year').add(1, 'day'), end(m)]
+  };
+}
+function presets_date() {
+  return [{
+    label: '一月前',
+    value: start().add(-1, 'month')
+  }, {
+    label: '一周前',
+    value: start().add(-1, 'week')
+  }, {
+    label: '一天前',
+    value: start().add(-1, 'day')
+  }, {
+    label: '一天后',
+    value: start().add(1, 'day')
+  }, {
+    label: '两天后',
+    value: start().add(2, 'day')
+  }, {
+    label: '三天后',
+    value: start().add(3, 'day')
+  }, {
+    label: '一周后',
+    value: start().add(1, 'week')
+  }, {
+    label: '两周后',
+    value: start().add(2, 'week')
+  }, {
+    label: '一月后',
+    value: start().add(1, 'month')
+  }, {
+    label: '两月后',
+    value: start().add(2, 'month')
+  }, {
+    label: '半年后',
+    value: start().add(6, 'month')
+  }];
+}
+function isMoment(m) {
+  return isFunction(m.format);
+}
+/**
+ * 获取若干天后的日期
+ */
+function getFutureDate(num) {
+  return dayjs__default["default"]().add(num, 'days').format('YYYY-MM-DD');
+}
+function dayjs_quarter(input, which_quarter) {
+  if (typeof which_quarter !== 'undefined') {
+    // 设置季度：调整月份至目标季度的第一个月，并保持其他部分不变
+    var targetMonth = (which_quarter - 1) * 3;
+    var adjustedDate = input.month(targetMonth);
+    return [adjustedDate, which_quarter];
+  } else {
+    // 获取当前季度：根据月份计算季度（1-4）
+    var currentMonth = input.month(); // 0-11
+    var currentQuarter = Math.floor(currentMonth / 3) + 1;
+    return [input, currentQuarter];
+  }
+}
+function diff_between(a, b, unit) {
+  var _float = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+  return dayjs__default["default"](a).diff(dayjs__default["default"](b), unit, _float);
+}
+var colorMap = {
+  'log': '#1475b2',
+  'warn': '#f89c1e',
+  'error': '#ed7961'
+};
+var big_txt_style = 'color:#1772F6;font-weight:bold;font-size:6em;padding:10px 20%;text-shadow:0.7px -1px 0 rgb(255 255 255 / 100%),1.4px -2px 0 rgb(255 255 255 / 96%),2px -3px 0 rgb(255 255 255 / 92%),2.8px -4px 0 rgb(255 255 255 / 88%),-1px 1px 2px rgb(0 0 0 / 70%),-2px 2px 4px rgb(0 0 0 / 70%),-3px 3px 6px rgb(0 0 0 / 70%);background: linear-gradient(to right top,oklab(58.2% -0.04 -0.21),oklab(58.2% -0.376 -0.21));';
+var MyLog = /*#__PURE__*/function () {
+  function MyLog(e) {
+    _classCallCheck(this, MyLog);
+    Object.defineProperty(this, "env", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.env = e;
+  }
+  return _createClass(MyLog, [{
+    key: "_logMsg",
+    value: function _logMsg() {
+      var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'log';
+      var _a;
+      var fn = (_a = MyLog._handler) === null || _a === void 0 ? void 0 : _a[type];
+      if (!fn || !isFunction(fn)) return;
+      for (var _len10 = arguments.length, msg = new Array(_len10 > 1 ? _len10 - 1 : 0), _key10 = 1; _key10 < _len10; _key10++) {
+        msg[_key10 - 1] = arguments[_key10];
+      }
+      fn.apply(void 0, ["%c ".concat(this.env, " %c ").concat(formatDateTime(), " "), "padding: 1px; border-radius:3px 0 0 3px; color: #fff; background: ".concat(colorMap[type], ";"), "padding: 1px; border-radius: 0 3px 3px 0; color: #fff; background: #606060;"].concat(msg));
+    }
+  }, {
+    key: "logBig",
+    value: function logBig(t) {
+      var _a;
+      var fn = (_a = MyLog._handler) === null || _a === void 0 ? void 0 : _a.log;
+      if (!fn || !isFunction(fn)) return;
+      fn("%c".concat(t), big_txt_style);
+    }
+  }, {
+    key: "log",
+    value: function log() {
+      for (var _len11 = arguments.length, msg = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) {
+        msg[_key11] = arguments[_key11];
+      }
+      this._logMsg.apply(this, ['log'].concat(msg));
+    }
+  }, {
+    key: "warn",
+    value: function warn() {
+      for (var _len12 = arguments.length, msg = new Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {
+        msg[_key12] = arguments[_key12];
+      }
+      this._logMsg.apply(this, ['warn'].concat(msg));
+    }
+  }, {
+    key: "error",
+    value: function error() {
+      for (var _len13 = arguments.length, msg = new Array(_len13), _key13 = 0; _key13 < _len13; _key13++) {
+        msg[_key13] = arguments[_key13];
+      }
+      this._logMsg.apply(this, ['error'].concat(msg));
+    }
+  }], [{
+    key: "handler",
+    set: function set(v) {
+      if (!v) return;
+      MyLog._handler = Object.assign(Object.assign({}, MyLog._handler), v);
+    }
+  }]);
+}();
+Object.defineProperty(MyLog, "_handler", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: console
+});
+MyLog.handler = console;
+var EventEmitter = /*#__PURE__*/function () {
+  function EventEmitter() {
+    _classCallCheck(this, EventEmitter);
+    Object.defineProperty(this, "events", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {}
+    });
+  }
+  return _createClass(EventEmitter, [{
+    key: "addListener",
+    value: function addListener(event, listener) {
+      var existing = this.events[event];
+      if (!existing) {
+        this.events[event] = existing = [];
+      }
+      existing.includes(listener) || existing.push(listener);
+      return this;
+    }
+  }, {
+    key: "on",
+    value: function on(event, listener) {
+      // this.off(event, listener)
+      return this.addListener(event, listener);
+    }
+  }, {
+    key: "on_cb",
+    value: function on_cb(event, listener) {
+      // this.off(event, listener)
+      this.addListener(event, listener);
+      return listener;
+    }
+  }, {
+    key: "on_rm",
+    value: function on_rm(event, listener) {
+      var _this2 = this;
+      // this.off(event, listener)
+      this.addListener(event, listener);
+      return function () {
+        _this2.off(event, listener);
+      };
+    }
+  }, {
+    key: "emit",
+    value: function emit(event) {
+      for (var _len14 = arguments.length, args = new Array(_len14 > 1 ? _len14 - 1 : 0), _key14 = 1; _key14 < _len14; _key14++) {
+        args[_key14 - 1] = arguments[_key14];
+      }
+      var existing = this.events[event];
+      // EventEmitter.logger.log({ event, args })
+      if (!existing) {
+        return false;
+      }
+      existing.forEach(function (fn) {
+        fn.apply(void 0, args);
+      });
+      return true;
+    }
+  }, {
+    key: "removeAllListeners",
+    value: function removeAllListeners(event) {
+      this.events[event] = [];
+      return this;
+    }
+  }, {
+    key: "off",
+    value: function off(event, listener) {
+      var existing = this.events[event];
+      if (!existing) {
+        return this;
+      }
+      var index = existing.findIndex(function (_) {
+        return _ === listener;
+      });
+      if (index < 0) {
+        return this;
+      }
+      existing.splice(index, 1);
+      return this;
+    }
+  }, {
+    key: "once",
+    value: function once(event, listener) {
+      var _this3 = this;
+      var _fn = function fn() {
+        listener.apply(void 0, arguments);
+        _this3.off(event, _fn);
+      };
+      this.on(event, _fn);
+      return this;
+    }
+  }, {
+    key: "prependListener",
+    value: function prependListener(event, listener) {
+      return this;
+    }
+  }, {
+    key: "prependOnceListener",
+    value: function prependOnceListener(event, listener) {
+      return this;
+    }
+  }, {
+    key: "removeListener",
+    value: function removeListener(event, listener) {
+      return this;
+    }
+  }, {
+    key: "setMaxListeners",
+    value: function setMaxListeners(n) {
+      return this;
+    }
+  }, {
+    key: "getMaxListeners",
+    value: function getMaxListeners() {
+      return 0;
+    }
+  }, {
+    key: "listeners",
+    value: function listeners(event) {
+      return [];
+    }
+  }, {
+    key: "rawListeners",
+    value: function rawListeners(event) {
+      return [];
+    }
+  }, {
+    key: "eventNames",
+    value: function eventNames() {
+      return [];
+    }
+  }, {
+    key: "listenerCount",
+    value: function listenerCount(type) {
+      return 0;
+    }
+  }]);
+}();
+Object.defineProperty(EventEmitter, "logger", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: new MyLog('EventEmitter')
+});
+var EMPTY_PLACEHOLDER = '-';
+var TOKEN_KEY = 'Σ(っ °Д °;)っ';
+var ARG_URS1_KEY = 'usr1';
+var ARG_URS2_KEY = 'usr2';
+var noop = function noop() {};
+var ROMAN_NUMERALS = {
+  1: 'Ⅰ',
+  2: 'Ⅱ',
+  3: 'Ⅲ',
+  4: 'Ⅳ',
+  5: 'Ⅴ',
+  6: 'Ⅵ',
+  7: 'Ⅶ',
+  8: 'Ⅷ',
+  9: 'Ⅷ',
+  10: 'Ⅹ'
+};
+var selectOptionMap = {};
+var REGE_AutoComplete = /\<(.*)\>a$/;
+var REGE_MyCheckbox = /\<(.*)\>c$/;
+var REGE_MySelect = /\<(.*)\>s$/;
+var REGE_EXCLUSIVE = /^(.*)\<(.*)\>(.*)#$/;
+var optionKey其他 = 99;
+var optionKey不详 = 100;
+var optionKey否 = 0;
+var defalutSp = [{
+  label: '不详',
+  value: optionKey不详
+}, {
+  label: '其他',
+  value: optionKey其他,
+  inputType: 'MyInput'
+}, {
+  label: '其它',
+  value: optionKey其他,
+  inputType: 'MyInput'
+}, {
+  label: '无',
+  value: optionKey否,
+  exclusive: true
+}, {
+  label: '否',
+  value: optionKey否,
+  exclusive: true
+}];
+function _getSimpleOptions(_arr) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var arr = parseList(_arr);
+  var _options$sp = options.sp,
+    sp = _options$sp === void 0 ? [] : _options$sp,
+    _options$start = options.start,
+    start = _options$start === void 0 ? 1 : _options$start,
+    _options$useDefault = options.useDefault,
+    useDefault = _options$useDefault === void 0 ? true : _options$useDefault,
+    useString = options.useString;
+  var index = start;
+  var opt = arr.map(function (_label, idx) {
+    var _a, _b;
+    var preset = presetInput(_label);
+    var label = (_a = preset.label) !== null && _a !== void 0 ? _a : _label;
+    var _defaultSpItem = useDefault ? defalutSp.find(function (s) {
+      return label === s.label;
+    }) : null;
+    var _spItem = sp.find(function (s) {
+      return label === s.label;
+    });
+    var spItem = (_b = _spItem !== null && _spItem !== void 0 ? _spItem : _defaultSpItem) !== null && _b !== void 0 ? _b : {};
+    if (spItem.value && useString) {
+      spItem.value = spItem.value.toString();
+    }
+    var _value = _defaultSpItem ? index : index++;
+    return Object.assign({
+      label: label,
+      value: useString ? _value.toString() : _value,
+      inputType: preset.inputType,
+      props: preset.props,
+      exclusive: preset.exclusive,
+      parentheses: preset.parentheses,
+      prefix: preset.prefix,
+      suffix: preset.suffix
+    }, spItem);
+  });
+  return opt;
+}
+function getSimpleOptions(_arr) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var ret = typeof _arr === 'function' ? function () {
+    return _getSimpleOptions(_arr(), options);
+  } : _getSimpleOptions(_arr, options);
+  return ret;
+}
+function _getSameOptions(_arr) {
+  var arr = parseList(_arr);
+  return arr.map(function (label) {
+    return {
+      label: label,
+      value: label
+    };
+  });
+}
+function getSameOptions(_arr) {
+  var ret = typeof _arr === 'function' ? function () {
+    return _getSameOptions(_arr());
+  } : _getSameOptions(_arr);
+  return ret;
+}
+function getDualModeOptions(arr, options) {
+  return [getSimpleOptions(arr, options), getSameOptions(arr)];
+}
+function parseList(arr) {
+  if (!arr) return [];
+  var _arr = [];
+  var split1 = [];
+  if (Array.isArray(arr)) {
+    _arr = arr;
+  } else if ((split1 = arr.split(',')) && split1.length > 1) {
+    _arr = split1;
+  } else if ((split1 = arr.split('、')) && split1.length > 1) {
+    _arr = split1;
+  }
+  return _arr;
+}
+function presetInput(_label) {
+  if (!_label) return {
+    label: _label
+  };
+  var withInput = (_label === null || _label === void 0 ? void 0 : _label.endsWith('|i')) || (_label === null || _label === void 0 ? void 0 : _label.endsWith('i'));
+  if (withInput) {
+    return {
+      inputType: 'Input',
+      label: _label.slice(0, -1)
+    };
+  }
+  var useAuto = REGE_AutoComplete.exec(_label);
+  if (useAuto) {
+    return {
+      inputType: 'MA',
+      label: _label.slice(0, useAuto.index),
+      props: {
+        options: useAuto[1]
+      }
+    };
+  }
+  var useCheckbox = REGE_MyCheckbox.exec(_label);
+  if (useCheckbox) {
+    var config = useCheckbox[1];
+    var arr = config.split('|');
+    var options = arr[0];
+    var marshal = arr[1] ? Number(arr[1]) : undefined;
+    var type = arr[2] || undefined;
+    return {
+      inputType: 'MC',
+      label: _label.slice(0, useCheckbox.index),
+      props: {
+        options: options,
+        marshal: marshal,
+        type: type
+      }
+    };
+  }
+  var useSelect = REGE_MySelect.exec(_label);
+  if (useSelect) {
+    var _config = useSelect[1];
+    var _arr2 = _config.split('|');
+    var _options = _arr2[0];
+    var _marshal = _arr2[1] ? Number(_arr2[1]) : undefined;
+    var mode = _arr2[2] || undefined;
+    return {
+      inputType: 'MS',
+      label: _label.slice(0, useSelect.index),
+      props: {
+        options: _options,
+        marshal: _marshal,
+        mode: mode
+      }
+    };
+  }
+  // 文字<exclusive|parentheses|prefix|suffix>MyInput#
+  var useExclusive = REGE_EXCLUSIVE.exec(_label);
+  if (useExclusive) {
+    var label = useExclusive[1];
+    var _config2 = useExclusive[2];
+    var _arr3 = _config2.split('|');
+    var inputType = useExclusive[3];
+    var exclusive = _arr3[0] ? Boolean(_arr3[0]) : undefined;
+    var parentheses = _arr3[1] ? Boolean(_arr3[1]) : undefined;
+    var prefix = _arr3[2];
+    var suffix = _arr3[3];
+    // mchcLogger.log('useExclusive', { useExclusive, exclusive, parentheses, prefix, suffix, inputType, label, _label })
+    return {
+      exclusive: exclusive,
+      parentheses: parentheses,
+      prefix: prefix,
+      suffix: suffix,
+      inputType: inputType,
+      label: label
+    };
+  }
+  return {
+    label: _label
+  };
+}
+function safe_fetch_options(cb) {
+  return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee10() {
+    var arr;
+    return _regeneratorRuntime.wrap(function _callee10$(_context10) {
+      while (1) switch (_context10.prev = _context10.next) {
+        case 0:
+          _context10.next = 2;
+          return safe_async_call(cb);
+        case 2:
+          arr = _context10.sent;
+          return _context10.abrupt("return", expect_array(arr));
+        case 4:
+        case "end":
+          return _context10.stop();
+      }
+    }, _callee10);
+  }));
+}
+function getPresetOptions(key) {
+  var pure = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var _a, _b;
+  var options = (_b = (_a = selectOptionMap[key]) === null || _a === void 0 ? void 0 : _a.call(selectOptionMap)) !== null && _b !== void 0 ? _b : [];
+  return pure ? options.map(function (_) {
+    return Object.assign(Object.assign({}, _), {
+      inputType: undefined
+    });
+  }) : options;
+}
+function getOptionLabel(k, value) {
+  var defaultLabel = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  var _a, _b, _c, _d;
+  var options = (_b = (_a = selectOptionMap[k]) === null || _a === void 0 ? void 0 : _a.call(selectOptionMap)) !== null && _b !== void 0 ? _b : [];
+  return (_d = (_c = options.find(function (_) {
+    return _.value === value;
+  })) === null || _c === void 0 ? void 0 : _c.label) !== null && _d !== void 0 ? _d : defaultLabel;
+}
+function getOptionValue(k, label) {
+  var _a, _b, _c;
+  var options = (_b = (_a = selectOptionMap[k]) === null || _a === void 0 ? void 0 : _a.call(selectOptionMap)) !== null && _b !== void 0 ? _b : [];
+  return (_c = options.find(function (_) {
+    return _.label === label;
+  })) === null || _c === void 0 ? void 0 : _c.value;
+}
+// merge options
+function merge_preset_options(ops) {
+  Object.assign(selectOptionMap, ops);
+}
+var dic_map = {};
+function getDictionaries() {
+  return dic_map;
+}
+/**
+ *
+ * @param value 枚举值value
+ * @param type string 字典类型
+ */
+function getDictionariesEnumerations(type) {
+  var _a;
+  var dictionaries = getDictionaries();
+  var object = dictionaries === null || dictionaries === void 0 ? void 0 : dictionaries[type];
+  if (!object) {
+    console.warn("\u5B57\u5178 ".concat(type, " \u4E0D\u5B58\u5728!"));
+    return [];
+  }
+  var enumerations = (_a = object === null || object === void 0 ? void 0 : object.enumerations) !== null && _a !== void 0 ? _a : [];
+  return enumerations;
+}
+/**
+ *
+ * @param value 枚举值value
+ * @param type string 字典类型
+ */
+function getDictionaryLabel(type, value) {
+  var enumerations = getDictionariesEnumerations(type);
+  var item = enumerations.find(function (_) {
+    return _.value === +value;
+  });
+  if (!item) {
+    return null;
+  }
+  return item.label;
+}
+/**
+ *
+ * @param label 枚举值value
+ * @param type string 字典类型
+ */
+function getDictionaryValue(type, label) {
+  var enumerations = getDictionariesEnumerations(type);
+  var item = enumerations.find(function (_) {
+    return _.label === label;
+  });
+  if (!item) {
+    return null;
+  }
+  return item.value;
+}
+// merge dic
+function merge_dict(ops) {
+  Object.assign(dic_map, ops);
+}
+Object.defineProperty(exports, 'dayjs', {
+  enumerable: true,
+  get: function get() {
+    return dayjs__default["default"];
+  }
+});
+exports.ARG_URS1_KEY = ARG_URS1_KEY;
+exports.ARG_URS2_KEY = ARG_URS2_KEY;
+exports.EMPTY_PLACEHOLDER = EMPTY_PLACEHOLDER;
+exports.EventEmitter = EventEmitter;
+exports.MyLog = MyLog;
+exports.ROMAN_NUMERALS = ROMAN_NUMERALS;
+exports.TOKEN_KEY = TOKEN_KEY;
+exports.all = all;
+exports.alphabetical = alphabetical;
+exports.assign = _assign;
+exports.base64ToBinary = base64ToBinary;
+exports.base64_to_image = base64_to_image;
+exports.boil = boil;
+exports.cache_fetch = cache_fetch;
+exports.callable = callable;
+exports.camel = camel;
+exports.capitalize = capitalize;
+exports.chain = chain;
+exports.charToUTF8 = charToUTF8;
+exports.charToUnicode = charToUnicode;
+exports.clone = clone;
+exports.cloneDeep = cloneDeep;
+exports.cluster = cluster;
+exports.compose = compose;
+exports.confirm_operation = confirm_operation;
+exports.construct = construct;
+exports.copyText = copyText;
+exports.counting = counting;
+exports.crush = crush;
+exports.dash = dash;
+exports.dayjs_quarter = dayjs_quarter;
+exports.debounce = debounce;
+exports.defer = defer;
+exports.diff = diff;
+exports.diff_between = diff_between;
+exports.downloadFile = downloadFile;
+exports.draw = draw;
+exports.expect_array = expect_array;
+exports.filter_obj_to_url_search = filter_obj_to_url_search;
+exports.first = first;
+exports.flat = flat;
+exports.fork = fork;
+exports.formatDate = formatDate;
+exports.formatDateTime = formatDateTime;
+exports.formatDateTimeNoSecond = formatDateTimeNoSecond;
+exports.formatTime = formatTime;
+exports.gen_encoded_char_svg = gen_encoded_char_svg;
+exports.get = get;
+exports.getDictionaries = getDictionaries;
+exports.getDictionariesEnumerations = getDictionariesEnumerations;
+exports.getDictionaryLabel = getDictionaryLabel;
+exports.getDictionaryValue = getDictionaryValue;
+exports.getDualModeOptions = getDualModeOptions;
+exports.getFilledArray = getFilledArray;
+exports.getFuckTimeInterval = getFuckTimeInterval;
+exports.getFutureDate = getFutureDate;
+exports.getMomentObj = getMomentObj;
+exports.getMomentRange = getMomentRange;
+exports.getOptionLabel = getOptionLabel;
+exports.getOptionValue = getOptionValue;
+exports.getPresetOptions = getPresetOptions;
+exports.getSameOptions = getSameOptions;
+exports.getSearchParamsAll = getSearchParamsAll;
+exports.getSearchParamsValue = getSearchParamsValue;
+exports.getSimpleOptions = getSimpleOptions;
+exports.get_global = get_global;
+exports.group = group;
+exports.guard = guard;
+exports.identity = identity;
+exports.image_to_base64 = image_to_base64;
+exports.inRange = inRange;
+exports.intersects = intersects;
+exports.invert = invert;
+exports.isArray = isArray;
+exports.isBoolean = isBoolean;
+exports.isDate = isDate;
+exports.isEmpty = isEmpty;
+exports.isEqual = _isEqual;
+exports.isFloat = isFloat;
+exports.isFunction = isFunction;
+exports.isInt = isInt;
+exports.isMoment = isMoment;
+exports.isNil = isNil;
+exports.isNull = isNull;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isObjectLike = isObjectLike;
+exports.isPrimitive = isPrimitive;
+exports.isPromise = isPromise;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.iterate = iterate;
+exports.keys = keys;
+exports.last = last;
+exports.list = list;
+exports.listify = listify;
+exports.lowerize = lowerize;
+exports.map = map;
+exports.mapEntries = mapEntries;
+exports.mapKeys = mapKeys;
+exports.mapValues = mapValues;
+exports.max = max;
+exports.memo = memo;
+exports.merge = merge;
+exports.merge_dict = merge_dict;
+exports.merge_preset_options = merge_preset_options;
+exports.min = min;
+exports.noop = noop;
+exports.numberLikeCompare = numberLikeCompare;
+exports.objectify = objectify;
+exports.omit = omit;
+exports["optionKey不详"] = optionKey不详;
+exports["optionKey其他"] = optionKey其他;
+exports["optionKey否"] = optionKey否;
+exports.parallel = parallel;
+exports.partial = partial;
+exports.partob = partob;
+exports.pascal = pascal;
+exports.pick = pick;
+exports.presets_date = presets_date;
+exports.proxied = proxied;
+exports.random = random;
+exports.randomHex = randomHex;
+exports.random_word = random_word;
+exports.range = range;
+exports.reduce = reduce;
+exports.replace = replace;
+exports.replaceOrAppend = replaceOrAppend;
+exports.retry = retry;
+exports.safeExec = safeExec;
+exports.safeGetFromFuncOrData = safeGetFromFuncOrData;
+exports.safe_async_call = safe_async_call;
+exports.safe_fetch_options = safe_fetch_options;
+exports.safe_json_parse = safe_json_parse;
+exports.safe_json_parse_arr = safe_json_parse_arr;
+exports.safe_json_stringify = safe_json_stringify;
+exports.safe_number_parse = safe_number_parse;
+exports.scrollIntoView = scrollIntoView;
+exports.select = select;
+exports.series = series;
+exports.set = set;
+exports.setSearchParamsAll = setSearchParamsAll;
+exports.setSearchParamsValue = setSearchParamsValue;
+exports.shake = shake;
+exports.shift = shift;
+exports.shuffle = shuffle;
+exports.sift = sift;
+exports.simple_decrypt = simple_decrypt;
+exports.simple_decrypt_str = simple_decrypt_str;
+exports.simple_encrypt = simple_encrypt;
+exports.simple_encrypt_str = simple_encrypt_str;
+exports.size = size;
+exports.sleep = sleep;
+exports.snake = snake;
+exports.sort = sort;
+exports.speculate_on_display = speculate_on_display;
+exports.sum = sum;
+exports.template = template;
+exports.throttle = throttle;
+exports.title = title;
+exports.toFloat = toFloat;
+exports.toInt = toInt;
+exports.toString = toString;
+exports.toggle = toggle;
+exports.trim = trim;
+exports["try"] = tryit;
+exports.tryit = tryit;
+exports.uid = uid;
+exports.unicodeToChar = unicodeToChar;
+exports.unicode_to_UTF8 = unicode_to_UTF8;
+exports.unique = unique;
+exports.upperize = upperize;
+exports.uuid = uuid;
+exports.warpBase64Type = warpBase64Type;
+exports.zip = zip;
+exports.zipToObject = zipToObject;