@zelgadis87/utils-core 4.3.1 → 4.3.3

package/esbuild/index.mjs

@@ -219,6 +219,12 @@ function sortedArray(arr, sortFn) {
 function includes(arr, item, fromIndex) {
   return arr.includes(item, fromIndex);
 }
+function mapTruthys(arr, mapper) {
+  return arr.map(mapper).filter((value) => value !== void 0);
+}
+function flatMapTruthys(arr, mapper) {
+  return arr.flatMap(mapper).filter((value) => value !== void 0);
+}
 
 // src/types/booleans.ts
 function isTrue(x) {
@@ -381,6 +387,29 @@ function stringToNumber(s) {
     return null;
   return Number(s);
 }
+function pad(str, n, char, where = "left") {
+  const length = ensureDefined(str).length;
+  if (length >= ensureDefined(n)) return str;
+  if (ensureDefined(char).length !== 1)
+    throw new Error("Illegal pad character");
+  const padding = repeat(char, n - length);
+  return (where === "left" ? padding : "") + str + (where === "right" ? padding : "");
+}
+function padLeft(str, n, char) {
+  return pad(str, n, char, "left");
+}
+function padRight(str, n, char) {
+  return pad(str, n, char, "right");
+}
+function ellipsis(str, maxLength, padChar, padWhere = "left") {
+  if (maxLength < 4)
+    throw new Error("Invalid argument maxLength");
+  if (str.length <= maxLength) {
+    return pad(str, maxLength, padChar, padWhere);
+  } else {
+    return str.substring(0, maxLength - 3) + "...";
+  }
+}
 var StringParts = class _StringParts {
   _parts;
   constructor(...parts) {
@@ -821,397 +850,25 @@ function randomPercentage(min2, max2) {
   return randomInterval(min2, max2) / 100;
 }
 
-// src/utils/bindThis.ts
-function bindThis(fn, _this) {
-  return fn.bind(_this);
-}
-
-// src/utils/constant.ts
-function constant(v) {
-  return () => v;
-}
-function identity(t) {
-  return t;
-}
-var constantNull = constant(null);
-var constantTrue = constant(true);
-var constantFalse = constant(false);
-var constantZero = constant(0);
-var constantOne = constant(1);
-
-// src/utils/entries.ts
-function dictToEntries(obj) {
-  return Object.entries(obj);
-}
-function entriesToDict(entries) {
-  return Object.fromEntries(entries);
-}
-function mapEntries(dict, mapper) {
-  return entriesToDict(dictToEntries(dict).map((entry) => mapper(entry)));
-}
-
-// src/utils/groupBy.ts
-function groupByString(arr, field) {
-  return groupByStringWith(arr, (t) => t[field]);
-}
-function groupByNumber(arr, field) {
-  return groupByNumberWith(arr, (t) => t[field]);
-}
-function groupBySymbol(arr, field) {
-  return groupBySymbolWith(arr, (t) => t[field]);
-}
-function groupByStringWith(arr, getter) {
-  return doGroupByWith(arr, getter);
-}
-function groupByNumberWith(arr, getter) {
-  return doGroupByWith(arr, getter);
-}
-function groupBySymbolWith(arr, getter) {
-  return doGroupByWith(arr, getter);
-}
-function doGroupByWith(arr, getter) {
-  return arr.reduce((dict, cur) => {
-    const key = getter(cur);
-    if (key !== null && key !== void 0) {
-      const arr2 = dict[key] ?? [];
-      arr2.push(cur);
-      dict[key] = arr2;
-    }
-    return dict;
-  }, {});
-}
-
-// src/utils/iff.ts
-function iff(firstPredicate, valueIfTrue) {
-  if (firstPredicate === true || firstPredicate instanceof Function && firstPredicate() === true) {
-    const ret = {
-      elseIf: () => ret,
-      otherwise: () => valueIfTrue
-    };
-    return ret;
-  } else {
-    const ret = {
-      elseIf: (elseIf, valueIfElseIfTrue) => iff(elseIf, valueIfElseIfTrue),
-      otherwise: (valueIfElse) => valueIfElse
-    };
-    return ret;
+// src/time/TimeDuration.ts
+var TimeDuration = class _TimeDuration extends TimeBase {
+  constructor(value, unit) {
+    super(value, unit);
+    if (value < 0)
+      throw new Error("Duration cannot be less than 0");
   }
-}
-
-// src/utils/indexBy.ts
-function indexByString(arr, field) {
-  return indexByStringWith(arr, (t) => t[field]);
-}
-function indexByNumber(arr, field) {
-  return indexByNumberWith(arr, (t) => t[field]);
-}
-function indexBySymbol(arr, field) {
-  return indexBySymbolWith(arr, (t) => t[field]);
-}
-function indexByStringWith(arr, getter) {
-  return doIndexByWith(arr, getter);
-}
-function indexByNumberWith(arr, getter) {
-  return doIndexByWith(arr, getter);
-}
-function indexBySymbolWith(arr, getter) {
-  return doIndexByWith(arr, getter);
-}
-function doIndexByWith(arr, getter) {
-  return arr.reduce((dict, cur) => {
-    const key = getter(cur);
-    if (key !== null && key !== void 0)
-      dict[key] = cur;
-    return dict;
-  }, {});
-}
-
-// src/utils/jsonCloneDeep.ts
-function jsonCloneDeep(a) {
-  if (null === a || "object" !== typeof a) return a;
-  if (a instanceof Date) {
-    return new Date(a.getTime());
-  } else if (a instanceof Array) {
-    const copy = [];
-    for (let i = 0, len = a.length; i < len; i++) {
-      copy[i] = jsonCloneDeep(a[i]);
-    }
-    return copy;
-  } else if (a instanceof Object) {
-    const copy = {};
-    for (let attr in a) {
-      if (a.hasOwnProperty(attr))
-        copy[attr] = jsonCloneDeep(a[attr]);
-    }
-    return copy;
+  create(value, unit) {
+    return new _TimeDuration(value, unit);
   }
-  throw new Error("Unable to copy obj! Its type isn't supported.");
-}
-
-// src/utils/math.ts
-function clamp(n, min2, max2) {
-  if (min2 === null || max2 === null || n === null || isNaN(min2) || isNaN(max2) || isNaN(n) || min2 > max2)
-    throw new Error();
-  if (n > max2) {
-    return max2;
-  } else if (n < min2) {
-    return min2;
-  } else {
-    return n;
+  addDuration(duration) {
+    return this.addUnits(duration.ms, TimeUnit.MILLISECONDS);
   }
-}
-function average(arr) {
-  const f = 1 / arr.length;
-  return arr.reduce((tot, cur) => tot + cur * f, 0);
-}
-function sum(arr) {
-  return arr.reduce((tot, cur) => tot + cur, 0);
-}
-function sumBy(arr, getter) {
-  return sum(arr.map(getter));
-}
-function min(arr) {
-  if (arr.length === 0) throw new Error("Cannot calculate value on empty array");
-  return arr.reduce((min2, cur) => cur < min2 ? cur : min2);
-}
-function minBy(arr, getter) {
-  return min(arr.map(getter));
-}
-function max(arr) {
-  if (arr.length === 0) throw new Error("Cannot calculate value on empty array");
-  return arr.reduce((max2, cur) => cur > max2 ? cur : max2);
-}
-function maxBy(arr, getter) {
-  return max(arr.map(getter));
-}
-
-// src/utils/noop.ts
-function noop() {
-}
-
-// src/utils/omit.ts
-function omit(o, ...keys) {
-  return keys.reduce((obj, key) => {
-    delete obj[key];
-    return obj;
-  }, { ...o });
-}
-
-// src/utils/pad.ts
-function pad(str, n, char, where = "left") {
-  const length = ensureDefined(str).length;
-  if (length >= ensureDefined(n)) return str;
-  if (ensureDefined(char).length !== 1)
-    throw new Error("Illegal pad character");
-  const padding = repeat(char, n - length);
-  return (where === "left" ? padding : "") + str + (where === "right" ? padding : "");
-}
-
-// src/utils/pluralize.ts
-function pluralize(n, singular, plural) {
-  if (!singular || !singular.length)
-    throw new Error();
-  if (n === 1)
-    return singular;
-  plural = plural ?? singular + "s";
-  const firstUppercase = singular.charAt(0) === singular.charAt(0).toUpperCase();
-  if (firstUppercase) {
-    const PLURAL = plural.toUpperCase();
-    const isAllUppercase = plural === PLURAL;
-    plural = isAllUppercase ? PLURAL : plural.charAt(0).toUpperCase() + plural.slice(1).toLowerCase();
+  removeDuration(duration) {
+    return this.removeUnits(duration.ms, TimeUnit.MILLISECONDS);
   }
-  return plural;
-}
-
-// src/utils/round.ts
-var roundModes = {
-  "toNearest": Math.round,
-  "toLower": Math.floor,
-  "toUpper": Math.ceil,
-  "towardsZero": (n) => n > 0 ? Math.floor(n) : Math.ceil(n),
-  "awayFromZero": (n) => n > 0 ? Math.ceil(n) : Math.floor(n)
-};
-function round(n, precision = 0, mode = "toNearest") {
-  const base = 10;
-  const power = Math.pow(base, precision);
-  return roundModes[mode](n * power) / power;
-}
-var roundToNearest = (n, precision = 0) => round(n, precision, "toNearest");
-var roundToLower = (n, precision = 0) => round(n, precision, "toLower");
-var roundToUpper = (n, precision = 0) => round(n, precision, "toUpper");
-var roundTowardsZero = (n, precision = 0) => round(n, precision, "towardsZero");
-var roundAwayFromZero = (n, precision = 0) => round(n, precision, "awayFromZero");
-
-// src/utils/sortBy.ts
-function sortBy(keyOrGetter, direction = "ASC", nulls = "LAST") {
-  const directionNum = direction === "ASC" ? -1 : 1;
-  const nullsNum = nulls === "LAST" ? -1 : 1;
-  const sortByNum = (a, b) => {
-    if (a === b)
-      return -1;
-    const aDefined = !(a === null || a === void 0 || isNaN(a));
-    const bDefined = !(b === null || b === void 0 || isNaN(b));
-    if (!aDefined && !bDefined)
-      return -1;
-    if (aDefined !== bDefined)
-      return nullsNum * (aDefined ? 1 : -1);
-    return (a > b ? -1 : 1) * directionNum;
-  };
-  if (typeof keyOrGetter === "function") {
-    return (a, b) => sortByNum(keyOrGetter(a), keyOrGetter(b));
-  } else {
-    return (a, b) => sortByNum(a[keyOrGetter], b[keyOrGetter]);
-  }
-}
-
-// src/async/RateThrottler.ts
-var RateThrottler = class {
-  constructor(_frequency) {
-    this._frequency = _frequency;
-    const initialOffset = this.cooldown.divideBy(_frequency.times);
-    this._availableSlots = new Array(_frequency.times).fill(0).map((_, i) => TimeInstant.now().addMs(i * initialOffset.ms));
-    this._waitingRequests = [];
-  }
-  _availableSlots;
-  _waitingRequests;
-  get cooldown() {
-    return this._frequency.period;
-  }
-  async execute(fn) {
-    const wrappedFn = async () => {
-      const slot = this._availableSlots.shift();
-      try {
-        return slot.promise().then(() => fn());
-      } finally {
-        this._availableSlots.push(TimeInstant.now().addDuration(this.cooldown));
-        if (this._waitingRequests.length > 0) this._waitingRequests.shift().resolve();
-      }
-    };
-    if (this._availableSlots.length > 0) {
-      return wrappedFn();
-    } else {
-      const waitingRequest = new Deferred_default();
-      this._waitingRequests.push(waitingRequest);
-      return waitingRequest.then(() => wrappedFn());
-    }
-  }
-};
-
-// src/async/Semaphore.ts
-var Semaphore = class {
-  constructor(_availableSlots = 1) {
-    this._availableSlots = _availableSlots;
-    this._queuedRequests = [];
-  }
-  _queuedRequests;
-  _inProgress = 0;
-  async _awaitSlot() {
-    if (this._availableSlots > 0) {
-      this._availableSlots -= 1;
-      this._inProgress += 1;
-      return void 0;
-    } else {
-      const deferred = new Deferred_default();
-      this._queuedRequests.push(deferred);
-      return deferred.asPromise();
-    }
-  }
-  _releaseSlot() {
-    const waitingSlotToResolve = this._queuedRequests.shift();
-    if (waitingSlotToResolve) {
-      waitingSlotToResolve.resolve();
-    } else {
-      this._availableSlots += 1;
-      this._inProgress -= 1;
-    }
-  }
-  async execute(fn, cooldown = TimeDuration.ZERO) {
-    return this._awaitSlot().then(() => fn()).finally(() => {
-      void cooldown.promise().then(() => this._releaseSlot());
-    });
-  }
-  get availableSlots() {
-    return this._availableSlots;
-  }
-  get queueSize() {
-    return this._queuedRequests.length;
-  }
-  get inProgressSize() {
-    return this._inProgress;
-  }
-};
-
-// src/utils/throttle.ts
-function throttle(fn, frequence) {
-  const semaphore = new RateThrottler(frequence);
-  return (...t) => {
-    return semaphore.execute(async () => fn(...t));
-  };
-}
-
-// src/utils/uniqBy.ts
-function uniqBy(arr, getter) {
-  return arr.reduce((dict, cur) => {
-    const key = getter(cur);
-    if (dict.keys.includes(key)) {
-      return dict;
-    } else {
-      return {
-        keys: [...dict.keys, key],
-        values: [...dict.values, cur]
-      };
-    }
-  }, { keys: [], values: [] }).values;
-}
-
-// src/utils/uniq.ts
-function uniq(arr) {
-  return uniqBy(arr, identity);
-}
-
-// src/utils/uniqByKey.ts
-function uniqByKey(arr, key) {
-  return uniqBy(arr, (item) => item[key]);
-}
-
-// src/utils/withTryCatch.ts
-function withTryCatch(fn) {
-  try {
-    return fn();
-  } catch (e) {
-    return asError(e);
-  }
-}
-
-// src/utils/withTryCatchAsync.ts
-async function withTryCatchAsync(fn) {
-  return fn().catch((e) => asError(e));
-}
-
-// src/utils/wrap.ts
-function wrap(str, delimiter) {
-  return delimiter + str + delimiter;
-}
-
-// src/time/TimeDuration.ts
-var TimeDuration = class _TimeDuration extends TimeBase {
-  constructor(value, unit) {
-    super(value, unit);
-    if (value < 0)
-      throw new Error("Duration cannot be less than 0");
-  }
-  create(value, unit) {
-    return new _TimeDuration(value, unit);
-  }
-  addDuration(duration) {
-    return this.addUnits(duration.ms, TimeUnit.MILLISECONDS);
-  }
-  removeDuration(duration) {
-    return this.removeUnits(duration.ms, TimeUnit.MILLISECONDS);
-  }
-  removeUnits(n, unit) {
-    const nn = Math.min(n, this.getUnit(unit));
-    return super.removeUnits(nn, unit);
+  removeUnits(n, unit) {
+    const nn = Math.min(n, this.getUnit(unit));
+    return super.removeUnits(nn, unit);
   }
   /** @deprecated: Use multiplyBy instead **/
   multiply(times) {
@@ -1857,6 +1514,10 @@ function isTimeInstant(x) {
 }
 var TimeInstant_default = TimeInstant;
 
+// src/utils/noop.ts
+function noop() {
+}
+
 // src/Logger.ts
 var LEVELS = ["log", "debug", "info", "warn", "error"];
 var timestamp = () => TimeInstant_default.now().asTimeString();
@@ -2008,6 +1669,96 @@ var ErrorCannotInstantiatePresentOptionalWithEmptyValue = class extends Error {
   }
 };
 
+// src/async/RateThrottler.ts
+var RateThrottler = class {
+  constructor(_frequency) {
+    this._frequency = _frequency;
+    const initialOffset = this.cooldown.divideBy(_frequency.times);
+    this._availableSlots = new Array(_frequency.times).fill(0).map((_, i) => TimeInstant.now().addMs(i * initialOffset.ms));
+    this._waitingRequests = [];
+  }
+  _availableSlots;
+  _waitingRequests;
+  get cooldown() {
+    return this._frequency.period;
+  }
+  async execute(fn) {
+    const wrappedFn = async () => {
+      const slot = this._availableSlots.shift();
+      try {
+        return slot.promise().then(() => fn());
+      } finally {
+        this._availableSlots.push(TimeInstant.now().addDuration(this.cooldown));
+        if (this._waitingRequests.length > 0) this._waitingRequests.shift().resolve();
+      }
+    };
+    if (this._availableSlots.length > 0) {
+      return wrappedFn();
+    } else {
+      const waitingRequest = new Deferred_default();
+      this._waitingRequests.push(waitingRequest);
+      return waitingRequest.then(() => wrappedFn());
+    }
+  }
+};
+
+// src/async/Semaphore.ts
+var Semaphore = class {
+  constructor(_availableSlots = 1) {
+    this._availableSlots = _availableSlots;
+    this._queuedRequests = [];
+  }
+  _queuedRequests;
+  _inProgress = 0;
+  async _awaitSlot() {
+    if (this._availableSlots > 0) {
+      this._availableSlots -= 1;
+      this._inProgress += 1;
+      return void 0;
+    } else {
+      const deferred = new Deferred_default();
+      this._queuedRequests.push(deferred);
+      return deferred.asPromise();
+    }
+  }
+  _releaseSlot() {
+    const waitingSlotToResolve = this._queuedRequests.shift();
+    if (waitingSlotToResolve) {
+      waitingSlotToResolve.resolve();
+    } else {
+      this._availableSlots += 1;
+      this._inProgress -= 1;
+    }
+  }
+  async execute(fn, cooldown = TimeDuration.ZERO) {
+    return this._awaitSlot().then(() => fn()).finally(() => {
+      void cooldown.promise().then(() => this._releaseSlot());
+    });
+  }
+  get availableSlots() {
+    return this._availableSlots;
+  }
+  get queueSize() {
+    return this._queuedRequests.length;
+  }
+  get inProgressSize() {
+    return this._inProgress;
+  }
+};
+
+// src/utils/constant.ts
+function constant(v) {
+  return () => v;
+}
+function identity(t) {
+  return t;
+}
+var constantNull = constant(null);
+var constantTrue = constant(true);
+var constantFalse = constant(false);
+var constantZero = constant(0);
+var constantOne = constant(1);
+
 // src/sorting/ComparisonChain.ts
 var defaultCompareValueOptions = {
   nullsFirst: false,
@@ -2456,6 +2207,258 @@ var TimeRange = class _TimeRange {
   }
 };
 
+// src/utils/bindThis.ts
+function bindThis(fn, _this) {
+  return fn.bind(_this);
+}
+
+// src/utils/entries.ts
+function dictToEntries(obj) {
+  return Object.entries(obj);
+}
+function entriesToDict(entries) {
+  return Object.fromEntries(entries);
+}
+function mapEntries(dict, mapper) {
+  return entriesToDict(dictToEntries(dict).map((entry) => mapper(entry)));
+}
+
+// src/utils/groupBy.ts
+function groupByString(arr, field) {
+  return groupByStringWith(arr, (t) => t[field]);
+}
+function groupByNumber(arr, field) {
+  return groupByNumberWith(arr, (t) => t[field]);
+}
+function groupBySymbol(arr, field) {
+  return groupBySymbolWith(arr, (t) => t[field]);
+}
+function groupByStringWith(arr, getter) {
+  return doGroupByWith(arr, getter);
+}
+function groupByNumberWith(arr, getter) {
+  return doGroupByWith(arr, getter);
+}
+function groupBySymbolWith(arr, getter) {
+  return doGroupByWith(arr, getter);
+}
+function doGroupByWith(arr, getter) {
+  return arr.reduce((dict, cur) => {
+    const key = getter(cur);
+    if (key !== null && key !== void 0) {
+      const arr2 = dict[key] ?? [];
+      arr2.push(cur);
+      dict[key] = arr2;
+    }
+    return dict;
+  }, {});
+}
+
+// src/utils/iff.ts
+function iff(firstPredicate, valueIfTrue) {
+  if (firstPredicate === true || firstPredicate instanceof Function && firstPredicate() === true) {
+    const ret = {
+      elseIf: () => ret,
+      otherwise: () => valueIfTrue
+    };
+    return ret;
+  } else {
+    const ret = {
+      elseIf: (elseIf, valueIfElseIfTrue) => iff(elseIf, valueIfElseIfTrue),
+      otherwise: (valueIfElse) => valueIfElse
+    };
+    return ret;
+  }
+}
+
+// src/utils/indexBy.ts
+function indexByString(arr, field) {
+  return indexByStringWith(arr, (t) => t[field]);
+}
+function indexByNumber(arr, field) {
+  return indexByNumberWith(arr, (t) => t[field]);
+}
+function indexBySymbol(arr, field) {
+  return indexBySymbolWith(arr, (t) => t[field]);
+}
+function indexByStringWith(arr, getter) {
+  return doIndexByWith(arr, getter);
+}
+function indexByNumberWith(arr, getter) {
+  return doIndexByWith(arr, getter);
+}
+function indexBySymbolWith(arr, getter) {
+  return doIndexByWith(arr, getter);
+}
+function doIndexByWith(arr, getter) {
+  return arr.reduce((dict, cur) => {
+    const key = getter(cur);
+    if (key !== null && key !== void 0)
+      dict[key] = cur;
+    return dict;
+  }, {});
+}
+
+// src/utils/jsonCloneDeep.ts
+function jsonCloneDeep(a) {
+  if (null === a || "object" !== typeof a) return a;
+  if (a instanceof Date) {
+    return new Date(a.getTime());
+  } else if (a instanceof Array) {
+    const copy = [];
+    for (let i = 0, len = a.length; i < len; i++) {
+      copy[i] = jsonCloneDeep(a[i]);
+    }
+    return copy;
+  } else if (a instanceof Object) {
+    const copy = {};
+    for (let attr in a) {
+      if (a.hasOwnProperty(attr))
+        copy[attr] = jsonCloneDeep(a[attr]);
+    }
+    return copy;
+  }
+  throw new Error("Unable to copy obj! Its type isn't supported.");
+}
+
+// src/utils/math.ts
+function clamp(n, min2, max2) {
+  if (min2 === null || max2 === null || n === null || isNaN(min2) || isNaN(max2) || isNaN(n) || min2 > max2)
+    throw new Error();
+  if (n > max2) {
+    return max2;
+  } else if (n < min2) {
+    return min2;
+  } else {
+    return n;
+  }
+}
+function average(arr) {
+  const f = 1 / arr.length;
+  return arr.reduce((tot, cur) => tot + cur * f, 0);
+}
+function sum(arr) {
+  return arr.reduce((tot, cur) => tot + cur, 0);
+}
+function sumBy(arr, getter) {
+  return sum(arr.map(getter));
+}
+function min(arr) {
+  if (arr.length === 0) throw new Error("Cannot calculate value on empty array");
+  return arr.reduce((min2, cur) => cur < min2 ? cur : min2);
+}
+function minBy(arr, getter) {
+  return min(arr.map(getter));
+}
+function max(arr) {
+  if (arr.length === 0) throw new Error("Cannot calculate value on empty array");
+  return arr.reduce((max2, cur) => cur > max2 ? cur : max2);
+}
+function maxBy(arr, getter) {
+  return max(arr.map(getter));
+}
+
+// src/utils/omit.ts
+function omit(o, ...keys) {
+  return keys.reduce((obj, key) => {
+    delete obj[key];
+    return obj;
+  }, { ...o });
+}
+
+// src/utils/round.ts
+var roundModes = {
+  "toNearest": Math.round,
+  "toLower": Math.floor,
+  "toUpper": Math.ceil,
+  "towardsZero": (n) => n > 0 ? Math.floor(n) : Math.ceil(n),
+  "awayFromZero": (n) => n > 0 ? Math.ceil(n) : Math.floor(n)
+};
+function round(n, precision = 0, mode = "toNearest") {
+  const base = 10;
+  const power = Math.pow(base, precision);
+  return roundModes[mode](n * power) / power;
+}
+var roundToNearest = (n, precision = 0) => round(n, precision, "toNearest");
+var roundToLower = (n, precision = 0) => round(n, precision, "toLower");
+var roundToUpper = (n, precision = 0) => round(n, precision, "toUpper");
+var roundTowardsZero = (n, precision = 0) => round(n, precision, "towardsZero");
+var roundAwayFromZero = (n, precision = 0) => round(n, precision, "awayFromZero");
+
+// src/utils/sortBy.ts
+function sortBy(keyOrGetter, direction = "ASC", nulls = "LAST") {
+  const directionNum = direction === "ASC" ? -1 : 1;
+  const nullsNum = nulls === "LAST" ? -1 : 1;
+  const sortByNum = (a, b) => {
+    if (a === b)
+      return -1;
+    const aDefined = !(a === null || a === void 0 || isNaN(a));
+    const bDefined = !(b === null || b === void 0 || isNaN(b));
+    if (!aDefined && !bDefined)
+      return -1;
+    if (aDefined !== bDefined)
+      return nullsNum * (aDefined ? 1 : -1);
+    return (a > b ? -1 : 1) * directionNum;
+  };
+  if (typeof keyOrGetter === "function") {
+    return (a, b) => sortByNum(keyOrGetter(a), keyOrGetter(b));
+  } else {
+    return (a, b) => sortByNum(a[keyOrGetter], b[keyOrGetter]);
+  }
+}
+
+// src/utils/throttle.ts
+function throttle(fn, frequence) {
+  const semaphore = new RateThrottler(frequence);
+  return (...t) => {
+    return semaphore.execute(async () => fn(...t));
+  };
+}
+
+// src/utils/uniqBy.ts
+function uniqBy(arr, getter) {
+  return arr.reduce((dict, cur) => {
+    const key = getter(cur);
+    if (dict.keys.includes(key)) {
+      return dict;
+    } else {
+      return {
+        keys: [...dict.keys, key],
+        values: [...dict.values, cur]
+      };
+    }
+  }, { keys: [], values: [] }).values;
+}
+
+// src/utils/uniq.ts
+function uniq(arr) {
+  return uniqBy(arr, identity);
+}
+
+// src/utils/uniqByKey.ts
+function uniqByKey(arr, key) {
+  return uniqBy(arr, (item) => item[key]);
+}
+
+// src/utils/withTryCatch.ts
+function withTryCatch(fn) {
+  try {
+    return fn();
+  } catch (e) {
+    return asError(e);
+  }
+}
+
+// src/utils/withTryCatchAsync.ts
+async function withTryCatchAsync(fn) {
+  return fn().catch((e) => asError(e));
+}
+
+// src/utils/wrap.ts
+function wrap(str, delimiter) {
+  return delimiter + str + delimiter;
+}
+
 // src/upgrade/errors.ts
 var UnavailableUpgradeError = class extends Error {
   constructor(data, from, to) {
@@ -2625,6 +2628,7 @@ export {
   dictToEntries,
   dictToList,
   divideBy,
+  ellipsis,
   ensureArray,
   ensureDefined,
   ensureNegativeNumber,
@@ -2636,6 +2640,7 @@ export {
   extendArray,
   extendArrayWith,
   fill,
+  flatMapTruthys,
   groupByNumber,
   groupByNumberWith,
   groupByString,
@@ -2675,6 +2680,7 @@ export {
   last,
   mapDefined,
   mapEntries,
+  mapTruthys,
   max,
   maxBy,
   min,
@@ -2683,8 +2689,9 @@ export {
   noop,
   omit,
   pad,
+  padLeft,
+  padRight,
   pick,
-  pluralize,
   promiseSequence,
   randomInterval,
   randomPercentage,