@noah-libjs/utils 0.0.2 → 0.0.3

package/dist/index.js

@@ -1,18 +1,24 @@
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _wrapNativeSuper from "@babel/runtime/helpers/wrapNativeSuper";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _typeof from "@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; }
-import _regeneratorRuntime from "@babel/runtime/regenerator";
+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; }
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 import dayjs from 'dayjs';
-export { Dayjs, default as dayjs } from 'dayjs';
+export { default as dayjs } from 'dayjs';
 var isSymbol = function isSymbol(value) {
   return !!value && value.constructor === Symbol;
 };
@@ -29,6 +35,12 @@ var isFunction = function isFunction(value) {
 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;
@@ -36,6 +48,29 @@ var isNumber = function isNumber(value) {
     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) {
@@ -56,6 +91,142 @@ var _isEqual = function isEqual(x, y) {
   }
   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;
@@ -65,60 +236,765 @@ var unique = function unique(array, toKey) {
   }, {});
   return Object.values(valueMap);
 };
-var map = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(array, asyncMapFunc) {
-    var result, index, _iterator, _step, value, newValue;
+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) {
-            _context.next = 2;
+            _context3.next = 2;
             break;
           }
-          return _context.abrupt("return", []);
+          return _context3.abrupt("return", []);
         case 2:
           result = [];
           index = 0;
-          _iterator = _createForOfIteratorHelper(array);
-          _context.prev = 5;
-          _iterator.s();
+          _iterator2 = _createForOfIteratorHelper(array);
+          _context3.prev = 5;
+          _iterator2.s();
         case 7:
-          if ((_step = _iterator.n()).done) {
-            _context.next = 15;
+          if ((_step2 = _iterator2.n()).done) {
+            _context3.next = 15;
             break;
           }
-          value = _step.value;
-          _context.next = 11;
+          value = _step2.value;
+          _context3.next = 11;
           return asyncMapFunc(value, index++);
         case 11:
-          newValue = _context.sent;
+          newValue = _context3.sent;
           result.push(newValue);
         case 13:
-          _context.next = 7;
+          _context3.next = 7;
           break;
         case 15:
-          _context.next = 20;
+          _context3.next = 20;
           break;
         case 17:
-          _context.prev = 17;
-          _context.t0 = _context["catch"](5);
-          _iterator.e(_context.t0);
+          _context3.prev = 17;
+          _context3.t0 = _context3["catch"](5);
+          _iterator2.e(_context3.t0);
         case 20:
-          _context.prev = 20;
-          _iterator.f();
-          return _context.finish(20);
+          _context3.prev = 20;
+          _iterator2.f();
+          return _context3.finish(20);
         case 23:
-          return _context.abrupt("return", result);
+          return _context3.abrupt("return", result);
         case 24:
         case "end":
-          return _context.stop();
+          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();
       }
-    }, _callee, null, [[5, 17, 20, 23]]);
+    }, _callee4);
   }));
-  return function map(_x, _x2) {
-    return _ref.apply(this, arguments);
+  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 _callee10(promises) {
+    var entries, results, exceptions;
+    return _regeneratorRuntime.wrap(function _callee10$(_context10) {
+      while (1) switch (_context10.prev = _context10.next) {
+        case 0:
+          entries = isArray(promises) ? promises.map(function (p) {
+            return [null, p];
+          }) : Object.entries(promises);
+          _context10.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 = _context10.sent;
+          exceptions = results.filter(function (r) {
+            return r.exc;
+          });
+          if (!(exceptions.length > 0)) {
+            _context10.next = 7;
+            break;
+          }
+          throw new AggregateError(exceptions.map(function (e) {
+            return e.exc;
+          }));
+        case 7:
+          if (!isArray(promises)) {
+            _context10.next = 9;
+            break;
+          }
+          return _context10.abrupt("return", results.map(function (r) {
+            return r.result;
+          }));
+        case 9:
+          return _context10.abrupt("return", results.reduce(function (acc, item) {
+            return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, item.key, item.result));
+          }, {}));
+        case 10:
+        case "end":
+          return _context10.stop();
+      }
+    }, _callee10);
+  }));
+  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) {
@@ -135,6 +1011,28 @@ var toInt = function toInt(value, defaultValue) {
   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) {
@@ -144,10 +1042,10 @@ var mapValues = function mapValues(obj, mapFunc) {
 };
 var mapEntries = function mapEntries(obj, toEntry) {
   if (!obj) return {};
-  return Object.entries(obj).reduce(function (acc, _ref2) {
-    var _ref3 = _slicedToArray(_ref2, 2),
-      key = _ref3[0],
-      value = _ref3[1];
+  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],
@@ -156,6 +1054,24 @@ var mapEntries = function mapEntries(obj, toEntry) {
     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;
@@ -169,6 +1085,15 @@ var clone = function clone(obj) {
   });
   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) {
@@ -187,11 +1112,11 @@ var omit = function omit(obj, keys2) {
 var get = function get(value, path, defaultValue) {
   var segments = path.split(/[\.\[\]]/g);
   var current = value;
-  var _iterator2 = _createForOfIteratorHelper(segments),
-    _step2;
+  var _iterator4 = _createForOfIteratorHelper(segments),
+    _step4;
   try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var key = _step2.value;
+    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, "");
@@ -199,9 +1124,9 @@ var get = function get(value, path, defaultValue) {
       current = current[dequoted];
     }
   } catch (err) {
-    _iterator2.e(err);
+    _iterator4.e(err);
   } finally {
-    _iterator2.f();
+    _iterator4.f();
   }
   if (current === void 0) return defaultValue;
   return current;
@@ -226,14 +1151,27 @@ var set = function set(initial, path, value) {
   _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 (_ref4) {
-        var _ref5 = _slicedToArray(_ref4, 2),
-          k = _ref5[0],
-          v = _ref5[1];
+      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]));
       });
     }
@@ -246,6 +1184,177 @@ var keys = function keys(value) {
   };
   return _getKeys(value, []);
 };
+var crush = function crush(value) {
+  if (!value) return {};
+  return objectify(keys(value), function (k) {
+    return k;
+  }, function (k) {
+    return get(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, "");
+};
 var symbolProto = Symbol ? Symbol.prototype : undefined;
 var symbolToString = symbolProto ? symbolProto.toString : undefined;
 var INFINITY = 1 / 0;
@@ -368,11 +1477,10 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
   var e = new Error(message);
   return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
-function sleep(sec) {
-  return new Promise(function (resolve) {
-    return setTimeout(resolve, sec * 1000);
-  });
-}
+
+// export function sleep(sec: number) {
+//     return new Promise<void>((resolve) => setTimeout(resolve, sec * 1000))
+// }
 function getSearchParamsValue(key) {
   var _a, _b;
   var url = new URL(location.toString());
@@ -484,8 +1592,8 @@ function copyText(text) {
   return res;
 }
 function safeExec(fn) {
-  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-    args[_key - 1] = arguments[_key];
+  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;
 }
@@ -495,12 +1603,15 @@ function safeGetFromFuncOrData(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) === toInt(b)) return true;
-  if (toFloat(a) === toFloat(b)) return true;
+  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;
 }
@@ -566,59 +1677,59 @@ function filter_obj_to_url_search(obj) {
   return clone_one;
 }
 function safe_async_call(cb) {
-  for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-    args[_key2 - 1] = arguments[_key2];
+  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 _callee2() {
-    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-      while (1) switch (_context2.prev = _context2.next) {
+  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)) {
-            _context2.next = 2;
+            _context8.next = 2;
             break;
           }
-          return _context2.abrupt("return", null);
+          return _context8.abrupt("return", null);
         case 2:
-          _context2.next = 4;
+          _context8.next = 4;
           return Promise.resolve(cb.apply(void 0, args));
         case 4:
-          return _context2.abrupt("return", _context2.sent);
+          return _context8.abrupt("return", _context8.sent);
         case 5:
         case "end":
-          return _context2.stop();
+          return _context8.stop();
       }
-    }, _callee2);
+    }, _callee8);
   }));
 }
 window.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 _callee3() {
+  return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
     var _a, conf;
-    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
-      while (1) switch (_context3.prev = _context3.next) {
+    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) {
-            _context3.next = 3;
+            _context9.next = 3;
             break;
           }
-          return _context3.abrupt("return", conf.cache);
+          return _context9.abrupt("return", conf.cache);
         case 3:
           if (!conf.cache_promise) {
-            _context3.next = 5;
+            _context9.next = 5;
             break;
           }
-          return _context3.abrupt("return", conf.cache_promise);
+          return _context9.abrupt("return", conf.cache_promise);
         case 5:
-          return _context3.abrupt("return", conf.cache_promise = cb().then(function (r) {
+          return _context9.abrupt("return", conf.cache_promise = cb().then(function (r) {
             return conf.cache = r;
           }));
         case 6:
         case "end":
-          return _context3.stop();
+          return _context9.stop();
       }
-    }, _callee3);
+    }, _callee9);
   }));
 }
 function speculate_on_display(value) {
@@ -670,7 +1781,19 @@ function confirm_operation() {
 // '😎'.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 getFn(format) {
   return Object.assign(function (s) {
     if (isFunction(s === null || s === void 0 ? void 0 : s.format)) {
@@ -751,8 +1874,8 @@ var MyLog = /*#__PURE__*/function () {
       var _a;
       var fn = (_a = MyLog._handler) === null || _a === void 0 ? void 0 : _a[type];
       if (!fn || !isFunction(fn)) return;
-      for (var _len3 = arguments.length, msg = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
-        msg[_key3 - 1] = arguments[_key3];
+      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));
     }
@@ -767,24 +1890,24 @@ var MyLog = /*#__PURE__*/function () {
   }, {
     key: "log",
     value: function log() {
-      for (var _len4 = arguments.length, msg = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
-        msg[_key4] = arguments[_key4];
+      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 _len5 = arguments.length, msg = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
-        msg[_key5] = arguments[_key5];
+      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 _len6 = arguments.length, msg = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
-        msg[_key6] = arguments[_key6];
+      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));
     }
@@ -839,18 +1962,18 @@ var EventEmitter = /*#__PURE__*/function () {
   }, {
     key: "on_rm",
     value: function on_rm(event, listener) {
-      var _this = this;
+      var _this2 = this;
       // this.off(event, listener)
       this.addListener(event, listener);
       return function () {
-        _this.off(event, listener);
+        _this2.off(event, listener);
       };
     }
   }, {
     key: "emit",
     value: function emit(event) {
-      for (var _len7 = arguments.length, args = new Array(_len7 > 1 ? _len7 - 1 : 0), _key7 = 1; _key7 < _len7; _key7++) {
-        args[_key7 - 1] = arguments[_key7];
+      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 })
@@ -887,10 +2010,10 @@ var EventEmitter = /*#__PURE__*/function () {
   }, {
     key: "once",
     value: function once(event, listener) {
-      var _this2 = this;
+      var _this3 = this;
       var _fn = function fn() {
         listener.apply(void 0, arguments);
-        _this2.off(event, _fn);
+        _this3.off(event, _fn);
       };
       this.on(event, _fn);
       return this;
@@ -948,4 +2071,4 @@ Object.defineProperty(EventEmitter, "logger", {
   writable: true,
   value: new MyLog('EventEmitter')
 });
-export { EventEmitter, MyLog, base64ToBinary, base64_to_image, cache_fetch, charToUTF8, charToUnicode, clone, cloneDeep, confirm_operation, copyText, dayjs_quarter, downloadFile, expect_array, filter_obj_to_url_search, formatDate, formatDateTime, formatDateTimeNoSecond, formatTime, gen_encoded_char_svg, get, getFilledArray, getFuckTimeInterval, getFutureDate, getMomentObj, getMomentRange, getSearchParamsAll, getSearchParamsValue, image_to_base64, isArray, isBoolean, _isEqual as isEqual, isFunction, isMoment, isNil, isNull, isNumber, isObject, isObjectLike, isString, isSymbol, keys, map, mapEntries, mapValues, numberLikeCompare, omit, pick, randomHex, random_word, safeExec, safeGetFromFuncOrData, safe_async_call, safe_json_parse, safe_json_parse_arr, safe_json_stringify, safe_number_parse, scrollIntoView, set, sleep, speculate_on_display, toFloat, toInt, toString, unicodeToChar, unicode_to_UTF8, unique, uuid, warpBase64Type };
+export { EventEmitter, MyLog, all, alphabetical, _assign as assign, base64ToBinary, base64_to_image, boil, cache_fetch, callable, camel, capitalize, chain, charToUTF8, charToUnicode, clone, cloneDeep, cluster, compose, confirm_operation, construct, copyText, counting, crush, dash, dayjs_quarter, debounce, defer, diff, downloadFile, draw, expect_array, filter_obj_to_url_search, first, flat, fork, formatDate, formatDateTime, formatDateTimeNoSecond, formatTime, gen_encoded_char_svg, get, getFilledArray, getFuckTimeInterval, getFutureDate, getMomentObj, getMomentRange, getSearchParamsAll, getSearchParamsValue, group, guard, image_to_base64, inRange, intersects, invert, isArray, isBoolean, isDate, isEmpty, _isEqual as isEqual, isFloat, isFunction, isInt, isMoment, isNil, isNull, isNumber, isObject, isObjectLike, isPrimitive, isPromise, isString, isSymbol, iterate, keys, last, list, listify, lowerize, map, mapEntries, mapKeys, mapValues, max, memo, merge, min, numberLikeCompare, objectify, omit, parallel, partial, partob, pascal, pick, proxied, random, randomHex, random_word, range, reduce, replace, replaceOrAppend, retry, safeExec, safeGetFromFuncOrData, safe_async_call, safe_json_parse, safe_json_parse_arr, safe_json_stringify, safe_number_parse, scrollIntoView, select, series, set, shake, shift, shuffle, sift, simple_decrypt, simple_encrypt, sleep, snake, sort, speculate_on_display, sum, template, throttle, title, toFloat, toInt, toString, toggle, trim, tryit as try, tryit, uid, unicodeToChar, unicode_to_UTF8, unique, upperize, uuid, warpBase64Type, zip, zipToObject };