@zelgadis87/utils-core 4.6.1 → 4.6.2

package/esbuild/index.cjs

@@ -0,0 +1,2965 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../node_modules/.pnpm/small-date@2.0.1/node_modules/small-date/lib/format.js
+var require_format = __commonJS({
+  "../../node_modules/.pnpm/small-date@2.0.1/node_modules/small-date/lib/format.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    exports2["default"] = format2;
+    function ownKeys(object, enumerableOnly) {
+      var keys = Object.keys(object);
+      if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+          symbols = symbols.filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+          });
+        }
+        keys.push.apply(keys, symbols);
+      }
+      return keys;
+    }
+    function _objectSpread(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i] != null ? arguments[i] : {};
+        if (i % 2) {
+          ownKeys(Object(source), true).forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+          });
+        } else if (Object.getOwnPropertyDescriptors) {
+          Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+        } else {
+          ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+          });
+        }
+      }
+      return target;
+    }
+    function _defineProperty(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    var PATTERN_REGEX = /(M|y|d|D|h|H|m|s|S|G|Z|P|a)+/g;
+    var ESCAPE_REGEX = /\\"|"((?:\\"|[^"])*)"|(\+)/g;
+    var optionNames = {
+      y: "year",
+      M: "month",
+      d: "day",
+      D: "weekday",
+      S: "fractionalSecondDigits",
+      G: "era",
+      Z: "timeZoneName",
+      P: "dayPeriod",
+      a: "hour12",
+      h: "hour",
+      H: "hour",
+      m: "minute",
+      s: "second"
+    };
+    var values = {
+      y: ["numeric", "2-digit", void 0, "numeric"],
+      M: ["narrow", "2-digit", "short", "long"],
+      d: ["numeric", "2-digit"],
+      D: ["narrow", "short", "long"],
+      S: [1, 2, 3],
+      G: ["narrow", "short", "long"],
+      Z: ["short", "long"],
+      P: ["narrow", "short", "long"],
+      a: [true],
+      h: ["numeric", "2-digit"],
+      H: ["numeric", "2-digit"],
+      m: ["numeric", "2-digit"],
+      s: ["numeric", "2-digit"]
+    };
+    function padIf(condition, value, length) {
+      return condition && length === 2 && value / 10 < 1 ? "0" + value : value;
+    }
+    function formatType(date, type, length) {
+      var _options;
+      var _ref = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {}, locale = _ref.locale, timeZone = _ref.timeZone;
+      var option = optionNames[type];
+      var value = values[type][length - 1];
+      if (!value) {
+        return;
+      }
+      var options = (_options = {}, _defineProperty(_options, option, value), _defineProperty(_options, "timeZone", timeZone), _options);
+      if (type === "a") {
+        return Intl.DateTimeFormat(locale, _objectSpread(_objectSpread({}, options), {}, {
+          hour: "numeric"
+        })).formatToParts(date).pop().value;
+      }
+      if (type === "G" || type === "Z") {
+        return Intl.DateTimeFormat(locale, options).formatToParts(date).pop().value;
+      }
+      if (type === "H" || type === "h") {
+        return Intl.DateTimeFormat("en-GB", _objectSpread(_objectSpread({}, options), {}, {
+          hourCycle: type === "H" ? "h23" : "h11"
+        })).format(date).toLocaleLowerCase().replace(" am", "").replace(" pm", "");
+      }
+      return padIf(["m", "s"].includes(type) && value === "2-digit", Intl.DateTimeFormat(locale, options).format(date), 2);
+    }
+    function format2(date, pattern, config) {
+      return pattern.split(ESCAPE_REGEX).filter(function(sub) {
+        return sub !== void 0;
+      }).map(function(sub, index) {
+        if (index % 2 !== 0) {
+          return sub;
+        }
+        return sub.replace(PATTERN_REGEX, function(match) {
+          var type = match.charAt(0);
+          return formatType(date, type, match.length, config) || match;
+        });
+      }).join("");
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/small-date@2.0.1/node_modules/small-date/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/.pnpm/small-date@2.0.1/node_modules/small-date/lib/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    exports2.format = void 0;
+    var _format = require_format();
+    var _format2 = _interopRequireDefault(_format);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    exports2.format = _format2["default"];
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ComparisonChain: () => ComparisonChain_default,
+  DataUpgrader: () => DataUpgrader,
+  Deferred: () => Deferred,
+  DeferredCanceledError: () => DeferredCanceledError,
+  ErrorCannotInstantiatePresentOptionalWithEmptyValue: () => ErrorCannotInstantiatePresentOptionalWithEmptyValue,
+  ErrorGetEmptyOptional: () => ErrorGetEmptyOptional,
+  ErrorSetEmptyOptional: () => ErrorSetEmptyOptional,
+  Lazy: () => Lazy,
+  LazyAsync: () => LazyAsync,
+  Logger: () => Logger,
+  Optional: () => Optional,
+  RandomTimeDuration: () => RandomTimeDuration,
+  RateThrottler: () => RateThrottler,
+  Semaphore: () => Semaphore,
+  Sorter: () => Sorter,
+  Sorting: () => Sorting,
+  StringParts: () => StringParts,
+  TimeDuration: () => TimeDuration,
+  TimeFrequency: () => TimeFrequency,
+  TimeInstant: () => TimeInstant,
+  TimeRange: () => TimeRange,
+  TimeUnit: () => TimeUnit,
+  alwaysFalse: () => alwaysFalse,
+  alwaysTrue: () => alwaysTrue,
+  and: () => and,
+  asError: () => asError,
+  asPromise: () => asPromise,
+  average: () => average,
+  capitalizeWord: () => capitalizeWord,
+  clamp: () => clamp,
+  constant: () => constant,
+  constantFalse: () => constantFalse,
+  constantNull: () => constantNull,
+  constantOne: () => constantOne,
+  constantTrue: () => constantTrue,
+  constantZero: () => constantZero,
+  createSorterFor: () => createSorterFor,
+  decrement: () => decrement,
+  decrementBy: () => decrementBy,
+  delayPromise: () => delayPromise,
+  dictToEntries: () => dictToEntries,
+  dictToList: () => dictToList,
+  divideBy: () => divideBy,
+  ellipsis: () => ellipsis,
+  ensureArray: () => ensureArray,
+  ensureDefined: () => ensureDefined,
+  ensureNegativeNumber: () => ensureNegativeNumber,
+  ensureNonNegativeNumber: () => ensureNonNegativeNumber,
+  ensureNonPositiveNumber: () => ensureNonPositiveNumber,
+  ensurePositiveNumber: () => ensurePositiveNumber,
+  ensureReadableArray: () => ensureReadableArray,
+  entriesToDict: () => entriesToDict,
+  extendArray: () => extendArray,
+  extendArrayWith: () => extendArrayWith,
+  fill: () => fill,
+  filterMap: () => filterMap,
+  filterMapReduce: () => filterMapReduce,
+  filterWithTypePredicate: () => filterWithTypePredicate,
+  first: () => first,
+  flatMapTruthys: () => flatMapTruthys,
+  groupByBoolean: () => groupByBoolean,
+  groupByBooleanWith: () => groupByBooleanWith,
+  groupByNumber: () => groupByNumber,
+  groupByNumberWith: () => groupByNumberWith,
+  groupByString: () => groupByString,
+  groupByStringWith: () => groupByStringWith,
+  groupBySymbol: () => groupBySymbol,
+  groupBySymbolWith: () => groupBySymbolWith,
+  hashCode: () => hashCode,
+  head: () => head,
+  identity: () => identity,
+  ifDefined: () => ifDefined,
+  ifNullOrUndefined: () => ifNullOrUndefined,
+  iff: () => iff,
+  includes: () => includes,
+  increment: () => increment,
+  incrementBy: () => incrementBy,
+  indexByNumber: () => indexByNumber,
+  indexByNumberWith: () => indexByNumberWith,
+  indexByString: () => indexByString,
+  indexByStringWith: () => indexByStringWith,
+  indexBySymbol: () => indexBySymbol,
+  indexBySymbolWith: () => indexBySymbolWith,
+  isAllowedTimeDuration: () => isAllowedTimeDuration,
+  isArray: () => isArray,
+  isDefined: () => isDefined,
+  isError: () => isError,
+  isFalse: () => isFalse,
+  isFunction: () => isFunction,
+  isNegativeNumber: () => isNegativeNumber,
+  isNullOrUndefined: () => isNullOrUndefined,
+  isNumber: () => isNumber,
+  isPositiveNumber: () => isPositiveNumber,
+  isTimeInstant: () => isTimeInstant,
+  isTrue: () => isTrue,
+  isUpgradable: () => isUpgradable,
+  isZero: () => isZero,
+  jsonCloneDeep: () => jsonCloneDeep,
+  last: () => last,
+  makeArrayEmpty: () => makeArrayEmpty,
+  mapDefined: () => mapDefined,
+  mapEntries: () => mapEntries,
+  mapFirstTruthy: () => mapFirstTruthy,
+  mapTruthys: () => mapTruthys,
+  max: () => max,
+  maxBy: () => maxBy,
+  min: () => min,
+  minBy: () => minBy,
+  multiplyBy: () => multiplyBy,
+  noop: () => noop,
+  not: () => not,
+  omit: () => omit,
+  omitFromJsonObject: () => omitFromJsonObject,
+  or: () => or,
+  pad: () => pad,
+  padLeft: () => padLeft,
+  padRight: () => padRight,
+  partition: () => partition,
+  pick: () => pick,
+  pluralize: () => pluralize,
+  promiseSequence: () => promiseSequence,
+  randomId: () => randomId,
+  randomInterval: () => randomInterval,
+  randomNumberInInterval: () => randomNumberInInterval,
+  randomPercentage: () => randomPercentage,
+  range: () => range,
+  repeat: () => repeat,
+  reverse: () => reverse,
+  round: () => round,
+  roundAwayFromZero: () => roundAwayFromZero,
+  roundToLower: () => roundToLower,
+  roundToNearest: () => roundToNearest,
+  roundToUpper: () => roundToUpper,
+  roundTowardsZero: () => roundTowardsZero,
+  sortedArray: () => sortedArray,
+  splitWords: () => splitWords,
+  stringToNumber: () => stringToNumber,
+  sum: () => sum,
+  sumBy: () => sumBy,
+  tail: () => tail,
+  throttle: () => throttle,
+  tryToParseJson: () => tryToParseJson,
+  tryToParseNumber: () => tryToParseNumber,
+  uniq: () => uniq,
+  uniqBy: () => uniqBy,
+  uniqByKey: () => uniqByKey,
+  upsert: () => upsert,
+  withTryCatch: () => withTryCatch,
+  withTryCatchAsync: () => withTryCatchAsync,
+  wrap: () => wrap,
+  wrapWithString: () => wrapWithString,
+  xor: () => xor
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/async/Deferred.ts
+var DeferredCanceledError = class extends Error {
+  constructor() {
+    super("Execution canceled");
+  }
+};
+var Deferred = class {
+  _pending;
+  _internals;
+  get pending() {
+    return this._pending;
+  }
+  /** @deprecated: Use resolve, then and catch directly; use asPromise to return a promise type. */
+  get promise() {
+    return this._internals.promise;
+  }
+  constructor() {
+    this._pending = true;
+    this._internals = this.createInternals();
+  }
+  resolve(val) {
+    if (!this._pending)
+      throw new Error("Illegal state exception");
+    this.resolveIfPending(val);
+  }
+  reject(reason) {
+    if (!this._pending)
+      throw new Error("Illegal state exception");
+    this.rejectIfPending(reason);
+  }
+  cancel() {
+    if (!this._pending)
+      throw new Error("Illegal state exception");
+    this.cancelIfPending();
+  }
+  resolveIfPending(val) {
+    if (!this._pending)
+      return;
+    this._pending = false;
+    this._internals.resolve(val);
+  }
+  rejectIfPending(reason) {
+    if (!this._pending)
+      return;
+    this._pending = false;
+    this._internals.reject(reason);
+  }
+  cancelIfPending() {
+    if (!this._pending)
+      return;
+    this.reject(new DeferredCanceledError());
+  }
+  then(onFulfilled, onRejected) {
+    return this._internals.promise.then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    return this._internals.promise.catch(onRejected);
+  }
+  finally(onfinally) {
+    return this._internals.promise.finally(onfinally);
+  }
+  asPromise() {
+    return this;
+  }
+  asCancelablePromise() {
+    return this;
+  }
+  createInternals() {
+    let resolveSelf, rejectSelf;
+    const promise = new Promise((resolve, reject) => {
+      resolveSelf = resolve;
+      rejectSelf = reject;
+    });
+    return {
+      promise,
+      resolve: resolveSelf,
+      reject: rejectSelf
+    };
+  }
+  get [Symbol.toStringTag]() {
+    return "[object Deferred]";
+  }
+};
+var Deferred_default = Deferred;
+
+// 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());
+    }
+  }
+};
+function throttle(fn, frequence) {
+  const semaphore = new RateThrottler(frequence);
+  return (...t) => {
+    return semaphore.execute(async () => fn(...t));
+  };
+}
+
+// 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.delay(() => this._releaseSlot());
+    });
+  }
+  get availableSlots() {
+    return this._availableSlots;
+  }
+  get queueSize() {
+    return this._queuedRequests.length;
+  }
+  get inProgressSize() {
+    return this._inProgress;
+  }
+};
+
+// src/utils/nulls.ts
+function ensureDefined(v, name = "value") {
+  if (isDefined(v))
+    return v;
+  throw new Error("Expected " + name + " to be defined, got: " + v);
+}
+function isDefined(x) {
+  return x !== null && x !== void 0;
+}
+function isNullOrUndefined(x) {
+  return x === null || x === void 0;
+}
+function ifDefined(source, callback) {
+  if (isDefined(source))
+    callback(source);
+}
+function mapDefined(source, mapper) {
+  if (isDefined(source))
+    return mapper(source);
+  return null;
+}
+function ifNullOrUndefined(source, callback) {
+  if (isNullOrUndefined(source))
+    callback();
+}
+
+// src/utils/arrays/groupBy.ts
+function groupByString(arr, field) {
+  return groupByStringWith(arr, (t) => t[field]);
+}
+function groupByNumber(arr, field) {
+  return groupByNumberWith(arr, (t) => t[field]);
+}
+function groupByBoolean(arr, field) {
+  return groupByBooleanWith(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 groupByBooleanWith(arr, getter) {
+  return doGroupByWith(arr, (item) => getter(item) ? "true" : "false");
+}
+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/arrays/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/arrays/statistics.ts
+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/functions/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 alwaysTrue = constantTrue;
+var alwaysFalse = constantFalse;
+var constantZero = constant(0);
+var constantOne = constant(1);
+
+// src/utils/functions/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/functions.ts
+function isFunction(t) {
+  return typeof t === "function";
+}
+function noop() {
+}
+function filterWithTypePredicate(filter) {
+  return (t) => filter(t);
+}
+function not(predicate) {
+  return (t) => !predicate(t);
+}
+function and(...predicates) {
+  if (predicates.length === 0) return constantTrue;
+  else if (predicates.length === 1) return predicates[0];
+  return (t) => predicates.reduce((prev, cur) => prev ? cur(t) : false, true);
+}
+function or(...predicates) {
+  if (predicates.length === 0) return constantTrue;
+  else if (predicates.length === 1) return predicates[0];
+  return (t) => predicates.reduce((prev, cur) => prev ? true : cur(t), false);
+}
+function xor(a, b) {
+  return (t) => a(t) !== b(t);
+}
+
+// src/utils/arrays/uniqBy.ts
+function uniq(arr) {
+  return uniqBy(arr, identity);
+}
+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;
+}
+function uniqByKey(arr, key) {
+  return uniqBy(arr, (item) => item[key]);
+}
+
+// src/utils/arrays.ts
+function ensureArray(t) {
+  if (isNullOrUndefined(t)) return [];
+  return t instanceof Array ? t : [t];
+}
+function ensureReadableArray(t) {
+  if (isNullOrUndefined(t)) return [];
+  return t instanceof Array ? t : [t];
+}
+function isArray(t) {
+  return t instanceof Array;
+}
+function upsert(arr, item, isEqual) {
+  const index = arr.findIndex((a) => isEqual(a, item));
+  if (index === -1) {
+    return [...arr, item];
+  } else {
+    return [
+      ...arr.slice(0, index),
+      item,
+      ...arr.slice(index + 1)
+    ];
+  }
+}
+function range(start, end) {
+  if (end < start) throw new Error();
+  let length = end - start + 1;
+  return new Array(length).fill(1).map((_, i) => start + i);
+}
+function fill(length, value) {
+  return new Array(length).fill(value);
+}
+function extendArray(arr, props) {
+  return arr.map((t) => ({
+    ...t,
+    ...props
+  }));
+}
+function extendArrayWith(arr, propsFn) {
+  return arr.map((t) => ({
+    ...t,
+    ...propsFn(t)
+  }));
+}
+function reverse(arr) {
+  return [...arr].reverse();
+}
+function first(arr, defaultValue = null) {
+  return arr.length ? arr[0] : defaultValue;
+}
+function last(arr, defaultValue = null) {
+  return arr.length ? arr[arr.length - 1] : defaultValue;
+}
+var head = first;
+function tail(arr) {
+  return arr.length ? arr.slice(1) : [];
+}
+function sortedArray(arr, sortFn) {
+  return [...arr].sort(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);
+}
+function filterMap(array, filterFn, mapFn) {
+  return array.filter(filterFn).map(mapFn);
+}
+function filterMapReduce(array, filterFn, mapFn, reduceFn, initialValue) {
+  return array.filter(filterFn).map(mapFn).reduce(reduceFn, initialValue);
+}
+function partition(arr, predicate) {
+  return arr.reduce((partition2, item) => {
+    partition2[predicate(item) ? 0 : 1].push(item);
+    return partition2;
+  }, [[], []]);
+}
+function mapFirstTruthy(arr, mapFn) {
+  for (let i = 0; i < arr.length; i++) {
+    const result = mapFn(arr[i]);
+    if (result) return result;
+  }
+  return null;
+}
+function makeArrayEmpty(arr) {
+  arr.splice(0, arr.length);
+}
+
+// src/utils/booleans.ts
+function isTrue(x) {
+  return x === true;
+}
+function isFalse(x) {
+  return x === false;
+}
+
+// src/utils/errors/withTryCatch.ts
+function withTryCatch(fn, errMapFn) {
+  try {
+    return [fn(), void 0];
+  } catch (e) {
+    return [void 0, (errMapFn ?? identity)(asError(e))];
+  }
+}
+async function withTryCatchAsync(fn, errMapFn) {
+  return fn().then((value) => [value, void 0], (e) => [void 0, (errMapFn ?? identity)(asError(e))]);
+}
+
+// src/utils/errors.ts
+function asError(e) {
+  if (e === void 0 || e === null)
+    return new Error("Void message");
+  if (isError(e))
+    return e;
+  if (typeof e === "string")
+    return new Error(e);
+  if (e instanceof String)
+    return new Error(e.toString());
+  return new Error(JSON.stringify(e));
+}
+function isError(e) {
+  return e instanceof Error;
+}
+
+// src/utils/json.ts
+function tryToParseJson(jsonContent) {
+  return withTryCatch(() => JSON.parse(jsonContent));
+}
+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.");
+}
+function omitFromJsonObject(o, ...keys) {
+  return keys.reduce((obj, key) => {
+    delete obj[key];
+    return obj;
+  }, { ...o });
+}
+var omit = omitFromJsonObject;
+
+// src/utils/numbers/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/numbers.ts
+function ensurePositiveNumber(v, name = "value") {
+  if (v !== void 0 && v !== null && v > 0)
+    return v;
+  throw new Error(`Expected ${name} to be positive, got: ${v}`);
+}
+function ensureNonNegativeNumber(v, name = "value") {
+  if (v !== void 0 && v !== null && v >= 0)
+    return v;
+  throw new Error(`Expected ${name} to be non-negative, got: ${v}`);
+}
+function ensureNonPositiveNumber(v, name = "value") {
+  if (v !== void 0 && v !== null && v <= 0)
+    return v;
+  throw new Error(`Expected ${name} to be non-positive, got: ${v}`);
+}
+function ensureNegativeNumber(v, name = "value") {
+  if (v !== void 0 && v !== null && v < 0)
+    return v;
+  throw new Error(`Expected ${name} to be negative, got: ${v}`);
+}
+function incrementBy(n) {
+  return (v) => v + n;
+}
+function multiplyBy(n) {
+  return (v) => v * n;
+}
+function divideBy(n) {
+  return (v) => v / n;
+}
+var increment = incrementBy(1);
+var decrement = incrementBy(-1);
+var decrementBy = (n) => incrementBy(-n);
+function isNumber(v) {
+  return typeof v === "number";
+}
+function isPositiveNumber(v) {
+  return v > 0;
+}
+function isNegativeNumber(v) {
+  return v < 0;
+}
+function isZero(v) {
+  return v === 0;
+}
+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 tryToParseNumber(numberStr) {
+  return withTryCatch(() => {
+    const type = typeof ensureDefined(numberStr);
+    if (type !== "string") throw new Error("Invalid number given: " + numberStr);
+    if (numberStr.trim().length === 0) throw new Error("Invalid number given: " + numberStr);
+    const num = Number(numberStr);
+    if (isNaN(num)) throw new Error("Invalid number given: " + numberStr);
+    return num;
+  });
+}
+
+// src/utils/promises.ts
+function asPromise(promisable) {
+  return Promise.resolve(promisable);
+}
+function promiseSequence(...fns) {
+  const fn = async function() {
+    const results = [];
+    for (let i = 0; i < fns.length; i++) {
+      results[i] = await fns[i]();
+    }
+    return results;
+  };
+  return fn;
+}
+function delayPromise(duration) {
+  return (result) => duration.promise().then(() => result);
+}
+
+// src/utils/random.ts
+var randomInterval = (min2, max2) => randomNumberInInterval(min2, max2);
+var randomPercentage = (min2, max2) => randomNumberInInterval(min2, max2) / 100;
+function randomNumberInInterval(min2, max2) {
+  return Math.floor(Math.random() * (max2 - min2 + 1) + min2);
+}
+var randomId = (length) => {
+  return Math.random().toString(36).substring(2, length + 2);
+};
+
+// src/utils/records/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/records.ts
+function dictToList(obj) {
+  return Object.keys(obj).map((key) => obj[key]);
+}
+function pick(o, keys) {
+  return keys.reduce((obj, key) => {
+    obj[key] = o[key];
+    return obj;
+  }, {});
+}
+
+// src/utils/strings/StringParts.ts
+var StringParts = class _StringParts {
+  _parts;
+  constructor(...parts) {
+    this._parts = parts;
+  }
+  toUpperCase() {
+    return new _StringParts(...this.parts.map((part) => part.toUpperCase()));
+  }
+  toLowerCase() {
+    return new _StringParts(...this.parts.map((part) => part.toLowerCase()));
+  }
+  capitalizeFirst() {
+    if (!this.length) return this;
+    return new _StringParts(capitalizeWord(this.first), ...this.tail.map((part) => part.toLowerCase()));
+  }
+  capitalizeEach() {
+    return new _StringParts(...this.parts.map((part) => capitalizeWord(part)));
+  }
+  get parts() {
+    return this._parts;
+  }
+  get tail() {
+    const [_first, ...tail2] = this.parts;
+    return tail2;
+  }
+  get first() {
+    return this._parts[0] ?? null;
+  }
+  get last() {
+    return this._parts[this.length - 1] ?? null;
+  }
+  get length() {
+    return this._parts.length;
+  }
+  trim() {
+    return new _StringParts(...this.parts.map((part) => part.trim()));
+  }
+  toSnakeCase() {
+    return this.toLowerCase().join("_");
+  }
+  toCamelCase() {
+    if (!this.length) return "";
+    return [this.first.toLowerCase(), ...this.tail.map(capitalizeWord)].join("");
+  }
+  toKebabCase() {
+    return this.toLowerCase().join("-");
+  }
+  toPascalCase() {
+    return this.capitalizeEach().join("");
+  }
+  toHumanCase() {
+    return this.capitalizeFirst().join(" ");
+  }
+  join(separator) {
+    return this.parts.join(separator);
+  }
+  mergeWith({ parts: otherParts }) {
+    return new _StringParts(...this.parts, ...otherParts);
+  }
+  slice(start, end) {
+    return new _StringParts(...this.parts.slice(start, end));
+  }
+  splice(start, deleteCount, ...items) {
+    return new _StringParts(...this.parts.splice(start, deleteCount, ...items));
+  }
+  push(part) {
+    return new _StringParts(...this.parts, part);
+  }
+  shift(part) {
+    return new _StringParts(part, ...this.parts);
+  }
+  reverse() {
+    return new _StringParts(...this.parts.reverse());
+  }
+  static fromString = (s, separator = /\s+/g) => {
+    if (s === null || separator === null)
+      throw new Error("Invalid arguments");
+    return new _StringParts(...s.split(separator));
+  };
+  static fromParts = (...parts) => {
+    return new _StringParts(...parts);
+  };
+};
+
+// src/utils/strings.ts
+function hashCode(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; ++i)
+    hash = Math.imul(31, hash) + str.charCodeAt(i);
+  return hash | 0;
+}
+function repeat(char, times) {
+  return times > 0 ? range(0, times - 1).map((_) => char).join("") : "";
+}
+function capitalizeWord(word) {
+  return word[0].toUpperCase() + word.substring(1).toLowerCase();
+}
+function splitWords(text, regEx = /\s+/) {
+  return text.split(regEx).filter((t) => t.length > 0);
+}
+function stringToNumber(s) {
+  if (isNullOrUndefined(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) {
+  if (maxLength < 4)
+    throw new Error("Invalid argument maxLength");
+  if (str.length <= maxLength) {
+    return str;
+  } else {
+    return str.substring(0, maxLength - 3) + "...";
+  }
+}
+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();
+  }
+  return plural;
+}
+function wrapWithString(str, delimiter) {
+  return delimiter + str + delimiter;
+}
+var wrap = wrapWithString;
+
+// src/lazy/Lazy.ts
+var Lazy = class _Lazy {
+  _value = void 0;
+  _initialized = false;
+  _generator;
+  constructor(generator) {
+    this._generator = ensureDefined(generator);
+  }
+  get value() {
+    return this._value;
+  }
+  getOrCreate() {
+    if (!this._initialized) {
+      this._value = this._generator();
+      this._initialized = true;
+    }
+    return this._value;
+  }
+  getOrThrow(errorMessage) {
+    if (!this._initialized)
+      throw new Error(errorMessage);
+    return this._value;
+  }
+  or(t) {
+    if (!this._initialized) {
+      return t;
+    } else {
+      return this._value;
+    }
+  }
+  isPresent() {
+    return this._initialized;
+  }
+  isEmpty() {
+    return !this._initialized;
+  }
+  ifPresent(fn) {
+    if (this.isPresent()) {
+      fn(this._value);
+    }
+  }
+  ifEmpty(fn) {
+    if (this.isEmpty()) {
+      fn();
+    }
+  }
+  apply(fnPresent, fnEmpty) {
+    if (this.isPresent()) {
+      fnPresent(this._value);
+    } else {
+      fnEmpty();
+    }
+  }
+  static of(generator) {
+    return new _Lazy(generator);
+  }
+};
+
+// src/lazy/LazyAsync.ts
+var LazyAsync = class _LazyAsync {
+  _promise = void 0;
+  _pending = false;
+  _resolvedValue = void 0;
+  _error = void 0;
+  _generator;
+  constructor(generator) {
+    this._generator = ensureDefined(generator);
+  }
+  getOrCreate() {
+    if (this.isEmpty()) {
+      this._pending = true;
+      this._promise = this._generator();
+      this._promise.then((value) => {
+        this._pending = false;
+        this._resolvedValue = value;
+      }, (err) => {
+        this._pending = false;
+        this._error = err;
+      });
+    }
+    return this._promise;
+  }
+  isPresent() {
+    return this._promise !== void 0;
+  }
+  isEmpty() {
+    return this._promise === void 0;
+  }
+  isPending() {
+    return this.isPresent() && this._pending === true;
+  }
+  isReady() {
+    return this.isPresent() && this._pending === false;
+  }
+  isResolved() {
+    return this.isReady() && this._error === void 0;
+  }
+  isError() {
+    return this.isReady() && this._error !== void 0;
+  }
+  ifPresent(fn) {
+    if (this.isPresent()) {
+      fn(this._promise);
+    }
+  }
+  ifEmpty(fn) {
+    if (this.isEmpty()) {
+      fn();
+    }
+  }
+  ifPending(fn) {
+    if (this.isPending()) {
+      fn(this._promise);
+    }
+  }
+  ifReady(fn) {
+    if (this.isReady()) {
+      fn(this._promise);
+    }
+  }
+  ifResolved(fn) {
+    if (this.isResolved()) {
+      fn(this._resolvedValue);
+    }
+  }
+  ifError(fn) {
+    if (this.isError()) {
+      fn(this._error);
+    }
+  }
+  getOrThrow(errorMessage) {
+    if (!this._promise)
+      throw new Error(errorMessage);
+    return this._promise;
+  }
+  static of(generator) {
+    return new _LazyAsync(generator);
+  }
+};
+
+// src/time/TimeInstant.ts
+var import_small_date = __toESM(require_lib());
+
+// src/time/TimeUnit.ts
+var TimeUnit = class _TimeUnit {
+  constructor(multiplier) {
+    this.multiplier = multiplier;
+  }
+  toUnit(value, unit) {
+    return value * (this.multiplier / unit.multiplier);
+  }
+  toMs(value) {
+    return this.toUnit(value, _TimeUnit.MILLISECONDS);
+  }
+  toSeconds(value) {
+    return this.toUnit(value, _TimeUnit.SECONDS);
+  }
+  toMinutes(value) {
+    return this.toUnit(value, _TimeUnit.MINUTES);
+  }
+  toHours(value) {
+    return this.toUnit(value, _TimeUnit.HOURS);
+  }
+  toDays(value) {
+    return this.toUnit(value, _TimeUnit.DAYS);
+  }
+  toWeeks(value) {
+    return this.toUnit(value, _TimeUnit.WEEKS);
+  }
+  static MILLISECONDS = new _TimeUnit(1);
+  static SECONDS = new _TimeUnit(1e3 * _TimeUnit.MILLISECONDS.multiplier);
+  static MINUTES = new _TimeUnit(60 * _TimeUnit.SECONDS.multiplier);
+  static HOURS = new _TimeUnit(60 * _TimeUnit.MINUTES.multiplier);
+  static DAYS = new _TimeUnit(24 * _TimeUnit.HOURS.multiplier);
+  static WEEKS = new _TimeUnit(7 * _TimeUnit.DAYS.multiplier);
+};
+
+// src/time/TimeBase.ts
+var TimeBase = class {
+  _ms;
+  constructor(value, unit) {
+    this._ms = unit.toMs(value);
+  }
+  get ms() {
+    return Math.floor(this._ms / TimeUnit.MILLISECONDS.multiplier);
+  }
+  get seconds() {
+    return Math.floor(this._ms / TimeUnit.SECONDS.multiplier);
+  }
+  get minutes() {
+    return Math.floor(this._ms / TimeUnit.MINUTES.multiplier);
+  }
+  get hours() {
+    return Math.floor(this._ms / TimeUnit.HOURS.multiplier);
+  }
+  get days() {
+    return Math.floor(this._ms / TimeUnit.DAYS.multiplier);
+  }
+  addMs(milliseconds) {
+    return this.addUnits(milliseconds, TimeUnit.MILLISECONDS);
+  }
+  addSeconds(seconds) {
+    return this.addUnits(seconds, TimeUnit.SECONDS);
+  }
+  addMinutes(minutes) {
+    return this.addUnits(minutes, TimeUnit.MINUTES);
+  }
+  addHours(hours) {
+    return this.addUnits(hours, TimeUnit.HOURS);
+  }
+  addDays(days) {
+    return this.addUnits(days, TimeUnit.DAYS);
+  }
+  removeDays(days) {
+    return this.removeUnits(days, TimeUnit.DAYS);
+  }
+  addUnits(n, unit) {
+    return this.create(this._ms + unit.toMs(n), TimeUnit.MILLISECONDS);
+  }
+  removeMs(milliseconds) {
+    return this.addUnits(-milliseconds, TimeUnit.MILLISECONDS);
+  }
+  removeSeconds(seconds) {
+    return this.addUnits(-seconds, TimeUnit.SECONDS);
+  }
+  removeMinutes(minutes) {
+    return this.addUnits(-minutes, TimeUnit.MINUTES);
+  }
+  removeHours(hours) {
+    return this.addUnits(-hours, TimeUnit.HOURS);
+  }
+  removeUnits(n, unit) {
+    return this.addUnits(-n, unit);
+  }
+  getUnit(unit) {
+    return this._ms / unit.multiplier;
+  }
+  toUnits() {
+    return {
+      days: Math.floor(this._ms / TimeUnit.DAYS.multiplier),
+      hours: Math.floor(this._ms / TimeUnit.HOURS.multiplier % 24),
+      minutes: Math.floor(this._ms / TimeUnit.MINUTES.multiplier % 60),
+      seconds: Math.floor(this._ms / TimeUnit.SECONDS.multiplier % 60)
+    };
+  }
+  static toMs(units) {
+    if (!units)
+      throw new Error("Invalid units given");
+    let ms = 0;
+    ms += units.ms ?? 0 * TimeUnit.MILLISECONDS.multiplier;
+    ms += (units.seconds ?? 0) * TimeUnit.SECONDS.multiplier;
+    ms += (units.minutes ?? 0) * TimeUnit.MINUTES.multiplier;
+    ms += (units.hours ?? 0) * TimeUnit.HOURS.multiplier;
+    ms += (units.days ?? 0) * TimeUnit.DAYS.multiplier;
+    return ms;
+  }
+  toJSON() {
+    return this._ms;
+  }
+};
+
+// 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);
+  }
+  /** @deprecated: Use multiplyBy instead **/
+  multiply(times) {
+    return this.multiplyBy(times);
+  }
+  multiplyBy(times) {
+    ensureNonNegativeNumber(times, "times");
+    return _TimeDuration.ms(this.ms * times);
+  }
+  divideBy(times) {
+    ensurePositiveNumber(times, "times");
+    return _TimeDuration.ms(this.ms / times);
+  }
+  /**
+  	* Returns the current duration in a human readable format, prioritizing the most significant unit of time and excluding the rest.
+  	* @todo[2023-06] Should allow more customization options
+  	* @todo[2023-06] By default should show the secondary unit only when actually needed (eg, 1h 20m & 3h, instead of 1h 20m & 3h 28m)
+  	* @todo[2023-06] Should not allow negative durations, as this is a duration and not an instant.
+  	* @returns the duration, with only the most significant units displayed as a human readable string, eg: 1d 20h, 10m 30s.
+  */
+  get formatted() {
+    const format2 = (x, u1, y, u2) => `${x}${u1} ${pad(y.toString(), 2, "0")}${u2}`;
+    const units = this.toUnits();
+    if (units.days >= 1) return format2(units.days, "d", units.hours, "h");
+    else if (units.hours >= 1)
+      return format2(units.hours, "h", units.minutes, "m");
+    else if (units.minutes >= 1)
+      return format2(units.minutes, "m", units.seconds, "s");
+    else if (units.seconds >= 0)
+      return units.seconds.toString() + "s";
+    else if (units.seconds > -60)
+      return "A few moments ago";
+    else
+      return "Some time ago";
+  }
+  /**
+  	* @deprecated[2023-06] this method makes no sense, as durations are positive by default.
+  	*/
+  absolute() {
+    return this.ms < 0 ? new _TimeDuration(-this.ms, TimeUnit.MILLISECONDS) : this;
+  }
+  interval(cb) {
+    return setInterval(cb, this.ms);
+  }
+  timeout(cb) {
+    return setTimeout(cb, this.ms);
+  }
+  cancelablePromise() {
+    const deferred = new Deferred_default();
+    if (this.ms > 0) {
+      this.timeout(() => deferred.resolve());
+    } else {
+      deferred.resolve();
+    }
+    return deferred.asCancelablePromise();
+  }
+  promise() {
+    if (this.isEmpty())
+      return Promise.resolve();
+    const deferred = new Deferred_default();
+    this.timeout(() => deferred.resolve());
+    return deferred.asPromise();
+  }
+  delay(cb) {
+    void this.promise().then(() => cb());
+  }
+  cancelableDelay(cb) {
+    const deferred = this.cancelablePromise();
+    void deferred.then(() => {
+      cb();
+    }, (err) => {
+      if (err instanceof DeferredCanceledError)
+        return;
+      throw err;
+    });
+    return { cancel: () => deferred.cancel() };
+  }
+  debounce(fn) {
+    let handle = null;
+    return (t) => {
+      if (handle)
+        clearTimeout(handle);
+      handle = this.timeout(() => {
+        handle = null;
+        fn(t);
+      });
+    };
+  }
+  toDigitalClock() {
+    const units = this.toUnits();
+    return pad(units.hours.toString(), 2, "0") + ":" + pad(units.minutes.toString(), 2, "0") + ":" + pad(units.seconds.toString(), 2, "0");
+  }
+  get asSeconds() {
+    if (this.ms < 0)
+      return "0";
+    if (this.ms < 1e3)
+      return (this.ms / 1e3).toFixed(1);
+    return Math.floor(this.seconds).toString();
+  }
+  fromNow() {
+    return TimeInstant_default.now().addDuration(this);
+  }
+  differenceFrom(other) {
+    return new _TimeDuration(Math.abs(this.ms - other.ms), TimeUnit.MILLISECONDS);
+  }
+  /** @deprecated: Use fromNow instead **/
+  addCurrentTime() {
+    return this.fromNow();
+  }
+  isGreaterThan(other) {
+    return this.ms > other.ms;
+  }
+  isLessThan(other) {
+    return this.ms < other.ms;
+  }
+  compareTo(other) {
+    if (this.ms === other.ms) {
+      return 0;
+    } else if (this.isLessThan(other)) {
+      return -1;
+    } else {
+      return 1;
+    }
+  }
+  atLeast(other) {
+    if (!this.isLessThan(other)) {
+      return this;
+    } else {
+      return other;
+    }
+  }
+  atMost(other) {
+    if (!this.isGreaterThan(other)) {
+      return this;
+    } else {
+      return other;
+    }
+  }
+  isEmpty() {
+    return this.ms <= 0;
+  }
+  isNotEmpty() {
+    return this.ms > 0;
+  }
+  /**
+  	* This method is used to provide a better DX when inspecting a TimeInstant object in DevTools.
+  	*/
+  get _duration() {
+    return this.formatted;
+  }
+  toString() {
+    return `${this.constructor.name}[${this.formatted}]`;
+  }
+  static parseHumanTime(humanTime) {
+    const match = humanTime.trim().match(/^(?:([0-9]+)d|)\s*(?:([0-9]+)h|)\s*(?:([0-9]+)m|)\s*(?:([0-9]+)s|)$/);
+    if (match) {
+      const [_, days, hours, minutes, seconds] = match;
+      return new _TimeDuration(TimeBase.toMs({ days: Number(days ?? 0), hours: Number(hours ?? 0), minutes: Number(minutes ?? 0), seconds: Number(seconds ?? 0) }), TimeUnit.MILLISECONDS);
+    }
+    throw new Error("Failed to parse time: " + humanTime);
+  }
+  static compare(a, b) {
+    return a.compareTo(b);
+  }
+  static ms = durationConstructor(TimeUnit.MILLISECONDS);
+  static seconds = durationConstructor(TimeUnit.SECONDS);
+  static minutes = durationConstructor(TimeUnit.MINUTES);
+  static hours = durationConstructor(TimeUnit.HOURS);
+  static days = durationConstructor(TimeUnit.DAYS);
+  static shamefulUnref = (ms) => {
+    if (ms instanceof _TimeDuration) {
+      return ms.ms;
+    }
+    return ms;
+  };
+  static shamefulRef = (ms) => {
+    if (ms instanceof _TimeDuration) {
+      return ms;
+    }
+    if (ms < 0) {
+      ms = 0;
+    }
+    return _TimeDuration.ms(ms);
+  };
+  static unref = (ms) => {
+    return _TimeDuration.shamefulUnref(ms);
+  };
+  static ref = (ms) => {
+    return _TimeDuration.shamefulRef(ms);
+  };
+  static fromMs(ms) {
+    return new _TimeDuration(ms, TimeUnit.MILLISECONDS);
+  }
+  static distanceFromNow(instant) {
+    return _TimeDuration.distance(TimeInstant_default.now(), instant);
+  }
+  static distance(instant1, instant2) {
+    return instant1.distanceFrom(instant2);
+  }
+  static greatest(duration1, duration2) {
+    return duration1.isGreaterThan(duration2) ? duration1 : duration2;
+  }
+  static lowest(duration1, duration2) {
+    return duration1.isLessThan(duration2) ? duration1 : duration2;
+  }
+  static ZERO = new _TimeDuration(0, TimeUnit.MILLISECONDS);
+  static fromJSON(ms) {
+    return _TimeDuration.ms(ms);
+  }
+};
+function durationConstructor(unit) {
+  return (a, b) => {
+    const aMs = unit.toMs(a);
+    const bMs = b ? unit.toMs(b) : aMs;
+    return TimeDuration.fromMs(randomInterval(aMs, bMs));
+  };
+}
+function isAllowedTimeDuration(t) {
+  return typeof t === "number" && t > 0 || t instanceof TimeDuration;
+}
+var TimeDuration_default = TimeDuration;
+
+// src/time/TimeInstantBuilder.ts
+var isRelativeNumber = (x) => x !== void 0 && x.length > 0 && (x[0] === "+" || x[0] === "-");
+var defaultTimeInstantCreationParameters = {
+  year: { relative: 0, relativeTo: "now" },
+  month: { relative: 0, relativeTo: "now" },
+  date: { relative: 0, relativeTo: "now" },
+  hours: { relative: 0, relativeTo: "now" },
+  minutes: { relative: 0, relativeTo: "now" },
+  seconds: { relative: 0, relativeTo: "now" },
+  milliseconds: { relative: 0, relativeTo: "now" }
+};
+var timeInstantCreationRelativeAliases = {
+  current: 0,
+  last: -1,
+  next: 1
+};
+var monthNames = {
+  january: 1,
+  february: 2,
+  march: 3,
+  april: 4,
+  may: 5,
+  june: 6,
+  july: 7,
+  august: 8,
+  september: 9,
+  october: 10,
+  november: 11,
+  december: 12
+};
+var timeInstantResolveValue = (getFromDate2, referenceDate, x) => {
+  if (x === void 0) {
+    return getFromDate2(referenceDate);
+  } else if (typeof x === "number") {
+    return x;
+  } else if (typeof x === "string") {
+    if (isRelativeNumber(x)) {
+      return getFromDate2(referenceDate) + parseInt(x);
+    } else if (x in timeInstantCreationRelativeAliases) {
+      return getFromDate2(referenceDate) + timeInstantCreationRelativeAliases[x];
+    } else if (x in monthNames) {
+      return monthNames[x];
+    } else {
+      throw new Error("Uparseable string detected: " + x);
+    }
+  } else if ("relative" in x) {
+    const { relative, relativeTo } = x;
+    if (relativeTo === void 0 || relativeTo === "now") {
+      return getFromDate2(referenceDate) + relative;
+    } else {
+      return getFromDate2(relativeTo.toDate()) + relative;
+    }
+  } else if ("absolute" in x) {
+    return x.absolute;
+  } else {
+    throw new Error("Uparseable value detected: " + x);
+  }
+};
+var getFromDate = {
+  year: (d) => d.getFullYear(),
+  month: (d) => d.getMonth(),
+  date: (d) => d.getDate(),
+  hours: (d) => d.getHours(),
+  minutes: (d) => d.getMinutes(),
+  seconds: (d) => d.getSeconds(),
+  milliseconds: (d) => d.getMilliseconds()
+};
+var toReferenceDate = (x) => {
+  ensureDefined(x);
+  if (isTimeInstant(x)) return x.toDate();
+  return x;
+};
+function createTimeInstantFromParameters(aParameters, aReferenceDate = TimeInstant.now()) {
+  const { year, month, date, hours, minutes, seconds, milliseconds } = { ...defaultTimeInstantCreationParameters, ...aParameters };
+  const referenceDate = toReferenceDate(aReferenceDate);
+  const timestamp2 = Date.UTC(
+    timeInstantResolveValue(getFromDate.year, referenceDate, year),
+    timeInstantResolveValue(getFromDate.month, referenceDate, month),
+    timeInstantResolveValue(getFromDate.date, referenceDate, date),
+    timeInstantResolveValue(getFromDate.hours, referenceDate, hours),
+    timeInstantResolveValue(getFromDate.minutes, referenceDate, minutes),
+    timeInstantResolveValue(getFromDate.seconds, referenceDate, seconds),
+    timeInstantResolveValue(getFromDate.milliseconds, referenceDate, milliseconds)
+  );
+  if (isNaN(timestamp2))
+    throw new Error(`Unparseable date: ${JSON.stringify(aParameters)} }`);
+  return TimeInstant.fromUnixTimestamp(timestamp2);
+}
+function timeInstantBuilder() {
+  let referenceDate = TimeInstant.now().toDate();
+  const value = { ...defaultTimeInstantCreationParameters };
+  const ret = {
+    year: (x) => {
+      value.year = x;
+      return ret;
+    },
+    month: (x) => {
+      value.month = x;
+      return ret;
+    },
+    date: (x) => {
+      value.date = x;
+      return ret;
+    },
+    hours: (x) => {
+      value.hours = x;
+      return ret;
+    },
+    minutes: (x) => {
+      value.minutes = x;
+      return ret;
+    },
+    seconds: (x) => {
+      value.seconds = x;
+      return ret;
+    },
+    milliseconds: (x) => {
+      value.milliseconds = x;
+      return ret;
+    },
+    values: (x) => {
+      Object.keys(value).forEach((key) => value[key] = x[key] ?? value[key]);
+      return ret;
+    },
+    relativeTo: (x) => {
+      referenceDate = toReferenceDate(x);
+      return ret;
+    },
+    build: () => createTimeInstantFromParameters(value, referenceDate)
+  };
+  return ret;
+}
+
+// src/time/TimeInstant.ts
+var TimeInstant = class _TimeInstant extends TimeBase {
+  constructor(number, unit) {
+    super(number, unit);
+  }
+  create(value, unit) {
+    return new _TimeInstant(value, unit);
+  }
+  addDuration(duration) {
+    return _TimeInstant.fromUnixTimestamp(this.ms + duration.ms);
+  }
+  removeDuration(duration) {
+    return _TimeInstant.fromUnixTimestamp(this.ms - duration.ms);
+  }
+  distanceFrom(instant) {
+    return TimeDuration_default.fromMs(Math.abs(this.ms - instant.ms));
+  }
+  distanceFromNow() {
+    return TimeDuration_default.fromMs(Math.abs(this.ms - Date.now()));
+  }
+  timeLeftFrom(instant) {
+    const distance = this.ms - instant.ms;
+    return TimeDuration_default.fromMs(Math.max(distance, 0));
+  }
+  timeLeftFromNow() {
+    const distance = this.ms - Date.now();
+    return TimeDuration_default.fromMs(Math.max(distance, 0));
+  }
+  distanceFromStartOfDay() {
+    return this.distanceFrom(this.atStartOfDay());
+  }
+  atStartOfDay() {
+    return this.atTime({ hours: 0, minutes: 0, seconds: 0, milliseconds: 0 });
+  }
+  distanceFromEndOfDay() {
+    return this.distanceFrom(this.atEndOfDay());
+  }
+  atEndOfDay() {
+    return this.atTime({ hours: 23, minutes: 59, seconds: 59, milliseconds: 999 });
+  }
+  promise() {
+    return this.timeLeftFromNow().promise();
+  }
+  cancelablePromise() {
+    return this.timeLeftFromNow().cancelablePromise();
+  }
+  delay(cb) {
+    return this.timeLeftFromNow().delay(cb);
+  }
+  cancelableDelay(cb) {
+    return this.timeLeftFromNow().cancelableDelay(cb);
+  }
+  ensureInTheFuture() {
+    if (!this.isInTheFuture)
+      throw new Error("Instant is in the past");
+  }
+  ensureInThePast() {
+    if (!this.isInThePast)
+      throw new Error("Instant is in the future");
+  }
+  isToday() {
+    return Math.floor(this.days) === Math.floor(_TimeInstant.now().days);
+  }
+  /**
+   * @returns the time as HH:mm:ss
+   * @deprecated [2024-12-11] this method is too ambigous and should be removed.
+   */
+  asTimeString() {
+    return this.format("HH:mm:ss");
+  }
+  /**
+   * @returns the date as dd/MM/yyyy
+   * @deprecated [2024-12-11] this method is too ambigous and should be removed.
+   */
+  asDateString() {
+    return this.format("dd/MM/yyyy");
+  }
+  /**
+   * Formats this instant using the given pattern. The pattern can contain the following tokens:
+   * 
+   * | Token | Description                     | Example                       |
+   * |:------|:--------------------------------|:------------------------------|
+   * | D     | Weekday, 1 letter               | W                             |
+   * | DD    | Weekday, 3 letters              | Wed                           |
+   * | DDD   | Weekday, long                   | Wednesday                     |
+   * | d     | Day of the month, no padding    | 3                             |
+   * | dd    | Day of the month, padded to 2   | 03                            |
+   * | M     | Month, numeric                  | 3                             |
+   * | MM    | Month, 2 digits                 | 03                            |
+   * | MMM   | Month, 3 letters                | Mar                           |
+   * | MMMM  | Month, long                     | March                         |
+   * | y     | Year, numeric                   | 2021                          |
+   * | yy    | Year, 2 digits                  | 21                            |
+   * | yyyy  | Year, numeric                   | 2021                          |
+   * | h     | Hours, no padding               | 6                             |
+   * | hh    | Hours, padded to 2              | 06                            |
+   * | H     | Hours in 24-format, no padding  | 18                            |
+   * | HH    | Hours in 24-format, padded to 2 | 18                            |
+   * | m     | Minutes, no padding             | 7                             |
+   * | m     | Minutes, padded to 2            | 07                            |
+   * | s     | Seconds, no padding             | 8                             |
+   * | ss    | Seconds, padded to 2            | 08                            |
+   * | S     | Milliseconds, no padding        | 9                             |
+   * | SS    | Milliseconds, padded to 2       | 09                            |
+   * | SSS   | Milliseconds, padded to 3       | 009                           |
+   * | G     | Era, narrow                     | A                             |
+   * | GG    | Era, short                      | AD                            |
+   * | GGG   | Era, long                       | Anno Domino                   |
+   * | Z     | Time zone, short                | GMT+1                         |
+   * | ZZ    | Time short, long	C              | entral European Standard Time |
+   * | P     | Period of the day, narrow       | in the morning                |
+   * | PP    | Period of the day, short        | in the morning                |
+   * | PPP   | Period of the day, long         | in the morning                |
+   * | a     | Meridiem                        | pm                            |
+   * @param pattern The pattern to use. Refer to the token table above for details.
+   * @param config An optional locale and timeZone definition to use during the format.
+   * @returns a string, formatted using the given pattern, at the given timeZone with the given locale.
+   */
+  format(pattern, config = {}) {
+    return (0, import_small_date.format)(this.toDate(), pattern, config);
+  }
+  /**
+  * @returns this instant, in ISO 8601 format (eg, 2024-11-01T15:49:22.024Z). The format is meant to always be realiable.
+  */
+  asIso8601() {
+    return this.format('yyyy-MM-dd"T"HH:mm:ss.SSS"Z"', { timeZone: "UTC" });
+  }
+  /**
+   * @returns this instant, in a human readable format. The format COULD change in the future, do NOT use this method for consistent outputs.
+   * @deprecated [2024-12-11] this method is too broad and ambigous and should be removed.
+   */
+  asHumanTimestamp() {
+    return this.format("yyyy-MM-dd HH:mm:ss");
+  }
+  toUnixTimestamp() {
+    return this.ms;
+  }
+  toDate() {
+    return new Date(this.ms);
+  }
+  toDateUTC() {
+    return new Date(this.ms + (/* @__PURE__ */ new Date()).getTimezoneOffset() * 60 * 1e3);
+  }
+  get isInThePast() {
+    return this.ms < Date.now();
+  }
+  get isInTheFuture() {
+    return this.ms > Date.now();
+  }
+  isAfter(other) {
+    return this.ms > other.ms;
+  }
+  isBefore(other) {
+    return this.ms < other.ms;
+  }
+  compareTo(other) {
+    if (this.ms === other.ms) {
+      return 0;
+    } else if (this.isBefore(other)) {
+      return -1;
+    } else {
+      return 1;
+    }
+  }
+  /**
+   * @deprecated: Use {@link distanceFromNow} instead
+  */
+  // TODO[2023-07-04, Deprecated]: Remove this method in a future version
+  fromNow() {
+    return TimeDuration_default.ms(this.ms - Date.now());
+  }
+  /**
+   * @deprecated: Use {@link distanceFrom} instead
+  */
+  // TODO[2023-07-04, Deprecated]: Remove this method in a future version
+  from(instant) {
+    return TimeDuration_default.ms(this.ms - instant.ms);
+  }
+  /**
+   * @deprecated: Use {@link distanceFromUnixTimestamp} instead
+  */
+  // TODO[2023-07-04, Deprecated]: Remove this method in a future version
+  fromTimestamp(timestamp2) {
+    return TimeDuration_default.ms(this.ms - timestamp2);
+  }
+  distanceFromUnixTimestamp(timestamp2) {
+    return TimeDuration_default.ms(this.ms - timestamp2);
+  }
+  atTime(parameters) {
+    return _TimeInstant.fromParameters(parameters, this);
+  }
+  atDate(parameters) {
+    return _TimeInstant.fromParameters(parameters, this);
+  }
+  at(parameters) {
+    return _TimeInstant.fromParameters(parameters, this);
+  }
+  isBetween(start, end) {
+    return this.ms >= start.ms && this.ms <= end.ms;
+  }
+  static fromDate(date) {
+    return this.fromUnixTimestamp(date.getTime());
+  }
+  static fromUnixTimestamp(unixTimestamp) {
+    return new _TimeInstant(unixTimestamp, TimeUnit.MILLISECONDS);
+  }
+  static fromUnixSeconds(unixSeconds) {
+    return new _TimeInstant(unixSeconds, TimeUnit.SECONDS);
+  }
+  static fromParameters(parameters, referenceDate) {
+    return createTimeInstantFromParameters(parameters, referenceDate);
+  }
+  static highest(instant1, instant2) {
+    return instant1.isAfter(instant2) ? instant1 : instant2;
+  }
+  static lowest(instant1, instant2) {
+    return instant1.isBefore(instant2) ? instant1 : instant2;
+  }
+  static builder() {
+    return timeInstantBuilder();
+  }
+  /**
+   * @deprecated[19/07/2023] Use {@link fromParameters} instead.
+   */
+  static fromUnits({ date, month, year, hours, minutes, seconds }) {
+    const dt = Date.UTC(year, month - 1, date, hours ?? 0, minutes ?? 0, seconds ?? 0);
+    if (isNaN(dt))
+      throw new Error(`Unparseable date: ${date}, ${month}, ${year}, ${hours ?? "-"}, ${minutes ?? "-"}, ${seconds ?? "-"}`);
+    return _TimeInstant.fromUnixTimestamp(dt);
+  }
+  static fromIso8601(str) {
+    return _TimeInstant.fromUnixTimestamp(new Date(str).getTime());
+  }
+  static tryFromIso8601(str) {
+    if (!str.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:.\d{3}|)(?:Z|[+-]\d{2}:\d{2})?$/))
+      throw new Error("Invalid date given: " + str);
+    return _TimeInstant.fromUnixTimestamp(new Date(str).getTime());
+  }
+  static now() {
+    return _TimeInstant.fromUnixTimestamp(Date.now());
+  }
+  static get currentTimeStamp() {
+    return Date.now();
+  }
+  static compare(a, b) {
+    return a.compareTo(b);
+  }
+  roundedToStartOf(unit) {
+    return _TimeInstant.fromUnixTimestamp(this.ms - this.ms % unit.multiplier);
+  }
+  roundedToEndOf(unit) {
+    return _TimeInstant.fromUnixTimestamp(this.ms - this.ms % unit.multiplier + unit.toMs(1) - 1);
+  }
+  roundedToNext(unit, factor = 1) {
+    const unitMs = unit.toMs(factor);
+    const timestamp2 = Math.ceil(this.ms / unitMs) * unitMs;
+    return _TimeInstant.fromUnixTimestamp(timestamp2);
+  }
+  roundedToPrevious(unit, factor = 1) {
+    const unitMs = unit.toMs(factor);
+    const timestamp2 = Math.floor(this.ms / unitMs) * unitMs;
+    return _TimeInstant.fromUnixTimestamp(timestamp2);
+  }
+  roundedTo(unit, factor = 1) {
+    const unitMs = unit.toMs(factor);
+    const timestamp2 = Math.round(this.ms / unitMs) * unitMs;
+    return _TimeInstant.fromUnixTimestamp(timestamp2);
+  }
+  get dayOfMonth() {
+    return this.toDate().getDate();
+  }
+  get dayOfWeek() {
+    return this.toDate().getDay() + 1;
+  }
+  get month() {
+    return this.toDate().getMonth() + 1;
+  }
+  get year() {
+    return this.toDate().getFullYear();
+  }
+  /**
+   * Returns the week number represented by this instant, according to the ISO 8601 standard.
+  	* Please note that the instant and the week number could be of two different years, eg the friday 1st january is actually part of week 52 of the previous year.
+   */
+  get weekNumber() {
+    const date = this.toDate();
+    const oneDay = 1e3 * 60 * 60 * 24;
+    const thursdayOfThisWeek = new Date(date.getFullYear(), date.getMonth(), date.getDate() + 4 - (date.getDay() || 7), 14, 0, 0);
+    const firstOfJanuary = new Date(thursdayOfThisWeek.getFullYear(), 0, 1, 14, 0, 0);
+    const dayOfTheYear = Math.round((thursdayOfThisWeek.getTime() - firstOfJanuary.getTime()) / oneDay);
+    const weekNumber = Math.floor(dayOfTheYear / 7) + 1;
+    return { weekNumber, year: thursdayOfThisWeek.getFullYear() };
+  }
+  /**
+   * This method is used to provide a better DX when inspecting a TimeInstant object in DevTools.
+   */
+  get _time() {
+    return this.asHumanTimestamp();
+  }
+  toString() {
+    return `${this.constructor.name}[${this.asHumanTimestamp()}]`;
+  }
+  static ZERO = _TimeInstant.fromUnixTimestamp(0);
+  static fromJSON(ms) {
+    return _TimeInstant.fromUnixTimestamp(ms);
+  }
+};
+function isTimeInstant(x) {
+  return x !== null && x !== void 0 && x instanceof TimeInstant;
+}
+var TimeInstant_default = TimeInstant;
+
+// src/Logger.ts
+var LEVELS = ["log", "debug", "info", "warn", "error"];
+var timestamp = () => TimeInstant_default.now().asTimeString();
+var Logger = class {
+  constructor(name, args) {
+    this.name = name;
+    this.console = args?.console ?? globalThis.console;
+    this.enabled = args?.enabled ?? true;
+    this.minLevel = LEVELS.indexOf((args?.minLevel ?? "DEBUG").toLowerCase());
+  }
+  enabled = true;
+  console;
+  minLevel;
+  get log() {
+    return this.logWrap("log");
+  }
+  get debug() {
+    return this.logWrap("debug");
+  }
+  get info() {
+    return this.logWrap("info");
+  }
+  get warn() {
+    return this.logWrap("warn");
+  }
+  get error() {
+    return this.logWrap("error");
+  }
+  logWrap(methodName) {
+    if (!this.console[methodName])
+      throw new Error("Invalid method name: " + methodName);
+    if (!this.enabled || !this.console || LEVELS.indexOf(methodName) < this.minLevel)
+      return noop;
+    return this.console[methodName].bind(this.console, timestamp(), methodName.toUpperCase(), this.name);
+  }
+};
+
+// src/Optional.ts
+var Optional = class _Optional {
+  _present;
+  _value;
+  constructor(t) {
+    const defined = isDefined(t);
+    this._value = defined ? t : void 0;
+    this._present = defined;
+  }
+  get rawValue() {
+    return this._value;
+  }
+  get() {
+    if (this.isEmpty())
+      throw new ErrorGetEmptyOptional();
+    return this.rawValue;
+  }
+  set(t) {
+    if (isNullOrUndefined(t))
+      throw new ErrorSetEmptyOptional();
+    this._value = t;
+    this._present = true;
+  }
+  clear() {
+    this._value = void 0;
+    this._present = false;
+  }
+  isEmpty() {
+    return !this._present;
+  }
+  isPresent() {
+    return this._present;
+  }
+  ifEmpty(callback) {
+    if (this.isEmpty())
+      callback();
+  }
+  ifPresent(callback) {
+    if (this.isPresent())
+      callback(this.rawValue);
+  }
+  apply(callbackIfPresent, callbackIfEmpty) {
+    if (this.isEmpty()) {
+      callbackIfEmpty();
+    } else {
+      callbackIfPresent(this.rawValue);
+    }
+  }
+  orElse(newValue) {
+    if (this.isEmpty())
+      return _Optional.ofNullable(newValue);
+    return this;
+  }
+  orElseGet(produceValue) {
+    if (this.isEmpty()) {
+      const newValue = produceValue();
+      return _Optional.ofNullable(newValue);
+    }
+    return this;
+  }
+  orElseThrow(produceError) {
+    if (this.isEmpty())
+      throw produceError();
+    return this;
+  }
+  mapTo(mapper) {
+    return this.flatMapTo((t) => _Optional.ofNullable(mapper(t)));
+  }
+  flatMapTo(mapper) {
+    if (this.isPresent()) {
+      const newValue = mapper(this.rawValue);
+      return newValue;
+    }
+    return this;
+  }
+  filter(predicate) {
+    if (this.isPresent()) {
+      if (predicate(this.rawValue)) {
+        return this;
+      } else {
+        return _Optional.empty();
+      }
+    } else {
+      return this;
+    }
+  }
+  static empty() {
+    return new _Optional(void 0);
+  }
+  static of(t) {
+    if (isNullOrUndefined(t))
+      throw new ErrorCannotInstantiatePresentOptionalWithEmptyValue();
+    return new _Optional(t);
+  }
+  static ofNullable(t) {
+    return new _Optional(t);
+  }
+};
+var ErrorGetEmptyOptional = class extends Error {
+  constructor() {
+    super("Cannot retrieve a value from an EmptyOptional.");
+  }
+};
+var ErrorSetEmptyOptional = class extends Error {
+  constructor() {
+    super("Cannot set a null or undefined value.");
+  }
+};
+var ErrorCannotInstantiatePresentOptionalWithEmptyValue = class extends Error {
+  constructor() {
+    super("Cannot initialize a PresentOptional with a null or undefined value.");
+  }
+};
+
+// src/sorting/ComparisonChain.ts
+var defaultCompareValueOptions = {
+  nullsFirst: false,
+  direction: "ASC"
+};
+function looseOptionsToStrict(x) {
+  return { ...defaultCompareValueOptions, ...typeof x === "string" ? { direction: x } : x };
+}
+function compareValues(a, b, options) {
+  if (a === b)
+    return 0;
+  const nullA = a === null || a === void 0;
+  const nullB = b === null || b === void 0;
+  if (nullA && nullB)
+    return 0;
+  if (nullA !== nullB)
+    return nullA === options.nullsFirst ? -1 : 1;
+  return a < b ? -1 : 1;
+}
+function compareFunction(fn, options) {
+  return (a, b) => applyDirection(compareValues(fn(a), fn(b), options), options.direction);
+}
+function applyDirection(res, direction) {
+  return res * (direction === "ASC" ? 1 : -1);
+}
+function compareUsingGetter(getter, options) {
+  return compareFunction(getter, looseOptionsToStrict(options));
+}
+function compareUsingField(field, options) {
+  return compareFunction((t) => t[field], looseOptionsToStrict(options));
+}
+function compareUsingNaturalOrder(options) {
+  return compareFunction(identity, looseOptionsToStrict(options));
+}
+function compareStrings(options) {
+  return compareFunction((t) => options?.ignoreCase === true ? t.toLowerCase() : t, looseOptionsToStrict(options));
+}
+function compareBooleans(options) {
+  const opts = { ...defaultCompareValueOptions, ...options };
+  const fn = (a, b) => {
+    if (a === b)
+      return 0;
+    if (isNullOrUndefined(a)) return opts.nullsFirst ? -1 : 1;
+    if (isNullOrUndefined(b)) return opts.nullsFirst ? 1 : -1;
+    return a === true && opts.truesFirst || a === false && !opts.truesFirst ? -1 : 1;
+  };
+  return (a, b) => applyDirection(fn(a, b), opts.direction);
+}
+function compareUsingFunction(fn) {
+  return fn;
+}
+function compareUsingSet(arr) {
+  const fn = (a, b) => {
+    if (a === b)
+      return 0;
+    const aIncluded = isDefined(a) && arr.includes(a);
+    const bIncluded = isDefined(b) && arr.includes(b);
+    if (aIncluded === bIncluded) {
+      return 0;
+    } else {
+      return aIncluded ? -1 : 1;
+    }
+  };
+  return fn;
+}
+function compareUsingArray(arr) {
+  const fn = (a, b) => {
+    if (a === b)
+      return 0;
+    const aIncluded = isDefined(a) && arr.includes(a);
+    const bIncluded = isDefined(b) && arr.includes(b);
+    if (!aIncluded && !bIncluded) {
+      return 0;
+    } else if (aIncluded && bIncluded) {
+      return arr.indexOf(a) < arr.indexOf(b) ? -1 : 1;
+    } else {
+      return aIncluded ? -1 : 1;
+    }
+  };
+  return fn;
+}
+function reverse2(fn) {
+  return (a, b) => fn(a, b) * -1;
+}
+var ComparisonChain = class _ComparisonChain {
+  constructor(_fns, _reversed = false) {
+    this._fns = _fns;
+    this._reversed = _reversed;
+  }
+  compare = (a, b) => {
+    return this.doCompare(a, b) * (this._reversed ? -1 : 1);
+  };
+  sort = (arr) => {
+    return [...arr].sort(this.compare);
+  };
+  then(getFn) {
+    const cmp = getFn(createCompare());
+    return this.thenBy(cmp);
+  }
+  thenBy(cmp) {
+    return new _ComparisonChain([...this._fns, getComparisonFunction(cmp)]);
+  }
+  thenChain(transform, getFn) {
+    const cmp = getFn(createCompare());
+    return this.thenChainBy(transform, cmp);
+  }
+  thenChainBy(transform, cmp) {
+    return new _ComparisonChain([...this._fns, applyTransformationBeforeComparison(transform, getComparisonFunction(cmp))]);
+  }
+  reversed() {
+    return new _ComparisonChain([...this._fns], !this._reversed);
+  }
+  doCompare(a, b) {
+    return this._fns.reduce((ret, fn) => {
+      return ret !== 0 ? ret : fn(a, b);
+    }, 0);
+  }
+  static create() {
+    return {
+      using: (getFn) => {
+        return new _ComparisonChain([]).then(getFn);
+      },
+      usingTransformation: (transform, getFn) => {
+        return new _ComparisonChain([]).thenChain(transform, getFn);
+      }
+    };
+  }
+  static createWith(getFn) {
+    return this.create().using(getFn);
+  }
+  static createWithTransformation(transform, getFn) {
+    return this.create().usingTransformation(transform, getFn);
+  }
+};
+var ComparisonChain_default = ComparisonChain;
+function createCompare() {
+  return {
+    compareUsingGetter,
+    compareUsingField,
+    compareUsingStrings: compareStrings,
+    compareUsingStringsIgnoringCase: (options) => compareStrings({ ...looseOptionsToStrict(options), ignoreCase: true }),
+    compareUsingBooleans: compareBooleans,
+    compareUsingNumbers: compareUsingNaturalOrder,
+    compareUsingDates: compareUsingNaturalOrder,
+    compareUsingFunction,
+    placeFirst: (arr) => compareUsingSet(arr),
+    placeFirstInOrder: (arr) => compareUsingArray(arr),
+    placeLast: (arr) => reverse2(compareUsingSet(arr)),
+    placeLastInOrder: (arr) => reverse2(compareUsingArray([...arr].reverse()))
+  };
+}
+function applyTransformationBeforeComparison(transform, fn) {
+  return (a, b) => fn(transform(a), transform(b));
+}
+function getComparisonFunction(arg) {
+  return arg instanceof ComparisonChain ? arg.compare : arg;
+}
+
+// src/sorting/Sorter.ts
+var defaultCompareValuesOptions = {
+  nullsFirst: false
+};
+var defaultCompareFunctionOptions = {
+  ...defaultCompareValuesOptions,
+  direction: "ASC"
+};
+var naturalOrderComparison = (a, b) => a < b ? -1 : 1;
+function compareValues2(a, b, cmp, { nullsFirst }) {
+  if (a === b)
+    return 0;
+  const nullA = isNullOrUndefined(a);
+  const nullB = isNullOrUndefined(b);
+  if (nullA && nullB)
+    return 0;
+  if (nullA !== nullB)
+    return nullA === nullsFirst ? -1 : 1;
+  return cmp(a, b);
+}
+function compareFunction2(fn, cmp, { nullsFirst, direction }) {
+  return (a, b) => applyDirection2(compareValues2(fn(a), fn(b), cmp, { nullsFirst }), direction);
+}
+function applyDirection2(res, direction) {
+  return res * (direction === "ASC" ? 1 : -1);
+}
+function combine(f, g) {
+  return (t) => g(f(t));
+}
+function reverse3(fn) {
+  return (a, b) => fn(a, b) * -1;
+}
+var chain = (fns, cmpFn) => {
+  return doCreateWithFunctions([...fns, cmpFn]);
+};
+var transformAndChain = (fns, transform, cmpFn) => {
+  const fn = (a, b) => cmpFn(transform(a), transform(b));
+  return chain(fns, fn);
+};
+var compareStrings2 = (fns, transform, options = {}) => {
+  const { nullsFirst, direction, ignoreCase } = { ...defaultStringComparisonOptions, ...options };
+  if (ignoreCase)
+    transform = combine(transform, (t) => t.toLowerCase());
+  return chain(fns, compareFunction2(transform, naturalOrderComparison, { nullsFirst, direction }));
+};
+var compareNumbers = (fns, transform, options = {}) => {
+  const { nullsFirst, direction } = { ...defaultNumberComparisonOptions, ...options };
+  return chain(fns, compareFunction2(transform, naturalOrderComparison, { nullsFirst, direction }));
+};
+var compareDates = (fns, transform, options = {}) => {
+  const { nullsFirst, direction } = { ...defaultDateComparisonOptions, ...options };
+  return chain(fns, compareFunction2(transform, naturalOrderComparison, { nullsFirst, direction }));
+};
+var compareBooleans2 = (fns, transform, options) => {
+  const { nullsFirst, truesFirst } = { ...defaultBooleanComparisonOptions, ...options };
+  return chain(fns, compareFunction2(transform, naturalOrderComparison, { nullsFirst, direction: truesFirst ? "DESC" : "ASC" }));
+};
+var prioritizeSet = (fns, transform, set, reversed = false) => {
+  return compareBooleans2(fns, (t) => {
+    const r = transform(t);
+    return isDefined(r) && set.includes(r);
+  }, { truesFirst: !reversed, nullsFirst: false });
+};
+var prioritizeArray = (fns, transform, arr, reversed = false) => {
+  return compareNumbers(fns, (t) => {
+    const r = transform(t);
+    if (!isDefined(r)) return Number.MAX_VALUE;
+    const indexOf = arr.indexOf(r);
+    return indexOf === -1 ? Number.MAX_VALUE : indexOf;
+  }, { direction: reversed ? "DESC" : "ASC", nullsFirst: false });
+};
+var next = (fns, transform) => {
+  const using = (transformToX) => {
+    return next(fns, combine(transform, transformToX));
+  };
+  const retAsChainable = {
+    chain(chain2) {
+      return transformAndChain(fns, transform, chain2.compare);
+    }
+  };
+  const retAsUsing = {
+    using
+  };
+  const retAsPrioritizable = {
+    prioritizing(arr, _options = {}) {
+      return prioritizeArray(fns, transform, arr);
+    },
+    deprioritizing(arr, _options = {}) {
+      return prioritizeArray(fns, transform, arr, true);
+    },
+    prioritizingWithEqualWeight(arr, _options = {}) {
+      return prioritizeSet(fns, transform, arr);
+    },
+    deprioritizingWithEqualWeight(arr, _options = {}) {
+      return prioritizeSet(fns, transform, arr, true);
+    }
+  };
+  const retForRecords = {
+    ...retAsUsing,
+    usingStrings: (field) => using((t) => t[field]),
+    usingNumbers: (field) => using((t) => t[field]),
+    usingBooleans: (field) => using((t) => t[field]),
+    usingDates: (field) => using((t) => t[field])
+  };
+  const retForNumbers = {
+    ...retAsUsing,
+    inAscendingOrder(opts = {}) {
+      return compareNumbers(fns, transform, { direction: "ASC", ...opts });
+    },
+    inDescendingOrder(opts = {}) {
+      return compareNumbers(fns, transform, { direction: "DESC", ...opts });
+    }
+  };
+  const retForStrings = {
+    ...retAsUsing,
+    inLexographicalOrder(opts = {}) {
+      return compareStrings2(fns, transform, { direction: "ASC", ignoreCase: false, ...opts });
+    },
+    inLexographicalOrderIgnoringCase(opts = {}) {
+      return compareStrings2(fns, transform, { direction: "ASC", ignoreCase: true, ...opts });
+    },
+    inReverseLexographicalOrder(opts = {}) {
+      return compareStrings2(fns, transform, { direction: "DESC", ignoreCase: false, ...opts });
+    },
+    inReverseLexographicalOrderIgnoringCase(opts = {}) {
+      return compareStrings2(fns, transform, { direction: "DESC", ignoreCase: true, ...opts });
+    }
+  };
+  const retForBooleans = {
+    ...retAsUsing,
+    truesFirst(opts = {}) {
+      return compareBooleans2(fns, transform, { truesFirst: true, ...opts });
+    },
+    falsesFirst(opts = {}) {
+      return compareBooleans2(fns, transform, { truesFirst: false, ...opts });
+    }
+  };
+  const retForDates = {
+    ...retAsUsing,
+    mostAncientFirst(opts = {}) {
+      return compareDates(fns, transform, { direction: "ASC", ...opts });
+    },
+    mostRecentFirst(opts = {}) {
+      return compareDates(fns, transform, { direction: "DESC", ...opts });
+    }
+  };
+  return {
+    ...retAsPrioritizable,
+    ...retAsChainable,
+    ...retForRecords,
+    ...retForNumbers,
+    ...retForStrings,
+    ...retForBooleans,
+    ...retForDates
+  };
+};
+var createComparisonFunction = (fns) => {
+  return (a, b) => {
+    let cmp = 0, i = 0;
+    while (i < fns.length && cmp === 0) {
+      cmp = fns[i++](a, b);
+    }
+    return cmp;
+  };
+};
+var compare = (fns, a, b) => {
+  return createComparisonFunction(fns)(a, b);
+};
+var sort = (fns, arr) => {
+  const comparisonFn = createComparisonFunction(fns);
+  return [...arr].sort(comparisonFn);
+};
+var top = (fns, arr, n) => {
+  return sort(fns, arr).slice(0, Math.max(0, n));
+};
+var bottom = (fns, arr, n) => {
+  return sort(fns, arr).slice(-Math.max(0, n)).reverse();
+};
+var first2 = (fns, arr) => {
+  return arr.length ? top(fns, arr, 1)[0] : null;
+};
+var last2 = (fns, arr) => {
+  return arr.length ? bottom(fns, arr, 1)[0] : null;
+};
+function doCreateEmpty() {
+  return next([], (x) => x);
+}
+function doCreateWithFunctions(fns) {
+  return {
+    get then() {
+      return next(fns, identity);
+    },
+    reversed() {
+      return doCreateWithFunctions([...fns.map(reverse3)]);
+    },
+    compare: (a, b) => {
+      return compare(fns, a, b);
+    },
+    sort: (arr) => {
+      return sort(fns, arr);
+    },
+    top: (arr, n) => {
+      return top(fns, arr, n);
+    },
+    bottom: (arr, n) => {
+      return bottom(fns, arr, n);
+    },
+    first: (arr) => {
+      return first2(fns, arr);
+    },
+    last: (arr) => {
+      return last2(fns, arr);
+    }
+  };
+}
+var defaultStringComparisonOptions = { ...defaultCompareFunctionOptions, ignoreCase: false };
+var defaultNumberComparisonOptions = { ...defaultCompareFunctionOptions };
+var defaultDateComparisonOptions = { ...defaultCompareFunctionOptions };
+var defaultBooleanComparisonOptions = { ...defaultCompareValuesOptions };
+function createSorterFor() {
+  return doCreateEmpty();
+}
+var Sorter = {
+  createFor: () => doCreateEmpty(),
+  sort: (arr, builder) => builder(doCreateEmpty()).sort(arr),
+  top: (arr, n, builder) => builder(doCreateEmpty()).top(arr, n),
+  bottom: (arr, n, builder) => builder(doCreateEmpty()).bottom(arr, n),
+  first: (arr, builder) => builder(doCreateEmpty()).first(arr),
+  last: (arr, builder) => builder(doCreateEmpty()).last(arr)
+};
+var Sorting = Sorter;
+
+// src/time/RandomTimeDuration.ts
+function randomize(unit) {
+  return (a, b) => {
+    return TimeDuration_default.fromMs(randomInterval(unit.toMs(a), unit.toMs(b)));
+  };
+}
+var RandomTimeDuration = class {
+  constructor() {
+  }
+  static ms = randomize(TimeUnit.MILLISECONDS);
+  static seconds = randomize(TimeUnit.SECONDS);
+  static minutes = randomize(TimeUnit.MINUTES);
+  static hours = randomize(TimeUnit.HOURS);
+  static days = randomize(TimeUnit.DAYS);
+};
+
+// src/time/TimeFrequency.ts
+var TimeFrequency = class _TimeFrequency {
+  constructor(times, period) {
+    this.times = times;
+    this.period = period;
+    if (isNaN(times) || times <= 0)
+      throw new Error();
+    if (period.isEmpty())
+      throw new Error();
+  }
+  get frequency() {
+    return this.period.divideBy(this.times);
+  }
+  static onceEvery(period) {
+    return new _TimeFrequency(1, period);
+  }
+  static twiceEvery(period) {
+    return new _TimeFrequency(2, period);
+  }
+};
+
+// src/time/TimeRange.ts
+var TimeRange = class _TimeRange {
+  constructor(start, duration) {
+    this.start = start;
+    this.duration = duration;
+    this.end = start.addDuration(duration);
+  }
+  end;
+  static fromInstants(a, b) {
+    const lowest = TimeInstant_default.lowest(a, b);
+    const highest = TimeInstant_default.highest(a, b);
+    return new _TimeRange(lowest, lowest.distanceFrom(highest));
+  }
+  static fromInstantWithDuration(a, d) {
+    return new _TimeRange(a, d);
+  }
+  static fromNowWithDuration(d) {
+    return new _TimeRange(TimeInstant_default.now(), d);
+  }
+};
+
+// src/upgrade/errors.ts
+var UnavailableUpgradeError = class extends Error {
+  constructor(data, from, to) {
+    super(`No transition found to upgrade data from version ${from} to version ${to}.`);
+    this.data = data;
+    this.from = from;
+    this.to = to;
+  }
+};
+var EmptyUpgradeError = class extends Error {
+  constructor(data, from, to) {
+    super(`Transition from version ${from} to version ${to} resulted in empty data`);
+    this.data = data;
+    this.from = from;
+    this.to = to;
+  }
+};
+
+// src/upgrade/getTransitionsPath.ts
+var DEBUG_ENABLED = false;
+function getTransitionsPath(matrix, from, to) {
+  return internalGetTransitionsPath(matrix, from, to, 0, DEBUG_ENABLED);
+}
+function internalGetTransitionsPath(matrix, from, to, depth, debug) {
+  debugLog(debug, depth, from, to, "Search started.");
+  const transitionsTo = matrix[to];
+  if (!transitionsTo) {
+    debugLog(debug, depth, from, to, "No transitions available to this version");
+    return null;
+  }
+  const exactTransition = transitionsTo[from];
+  if (exactTransition) {
+    debugLog(debug, depth, from, to, "Found exact transition.");
+    return [exactTransition];
+  }
+  const keys = Object.keys(transitionsTo);
+  return keys.reduce((curBestPath, transitionKey) => {
+    const transition = transitionsTo[transitionKey];
+    const path = internalGetTransitionsPath(matrix, from, transition.from, depth + 1, debug);
+    if (path === null) {
+      debugLog(debug, depth + 1, from, transition.from, "No path found.");
+      return curBestPath;
+    } else {
+      if (curBestPath === null || curBestPath.length > path.length + 1) {
+        debugLog(debug, depth + 1, from, transition.from, "New best path found: " + printTransitions(path));
+        return [...path, transition];
+      } else {
+        return curBestPath;
+      }
+    }
+  }, null);
+}
+function debugLog(enabled, depth, from, to, message) {
+  if (!enabled)
+    return;
+  console.info(
+    "#".repeat(depth + 1),
+    from + " -> " + to,
+    message
+  );
+}
+function printTransitions(transitions) {
+  return transitions.reduce((ret, cur) => {
+    return ret + " -> " + cur.to;
+  }, "" + transitions[0].from);
+}
+
+// src/upgrade/DataUpgrader.ts
+var VERSION_FIELD = "$version";
+var DataUpgrader = class _DataUpgrader {
+  constructor(latestVersion) {
+    this.latestVersion = latestVersion;
+  }
+  transitions = {};
+  addTransition(from, to, apply) {
+    if (from === void 0 || from < 0)
+      throw new Error(`Invalid argument from, non-negative number expected, got: ${from}`);
+    if (to === void 0 || to <= 0)
+      throw new Error(`Invalid argument to, positive number expected, got: ${to}`);
+    if (to <= from)
+      throw new Error(`Invalid argument to, expected number greater than ${from}, got: ${to}`);
+    if (to > this.latestVersion)
+      throw new Error(`Invalid argument to, expected number lower than ${this.latestVersion}, got: ${to}`);
+    if (this.transitions[to]?.[from])
+      throw new Error(`Invalid transition arguments, duplicated transition found from ${from} to ${to}`);
+    const toMatrix = this.transitions[to] ?? {};
+    toMatrix[from] = { from, to, apply };
+    this.transitions[to] = toMatrix;
+    return this;
+  }
+  async upgrade(data) {
+    if (!data || typeof data !== "object")
+      throw new Error(`Invalid argument data, object expected, got: ${typeof data}.`);
+    if (data.$version === null || data.$version === void 0 || typeof data.$version !== "number")
+      throw new Error(`Invalid argument data, version metadata required, got: ${data.$version}`);
+    if (data.$version > this.latestVersion)
+      throw new Error(`Invalid argument data, version metadata is in the future: ${data.$version}, current: ${this.latestVersion}`);
+    if (this.isLatestVersion(data))
+      return data;
+    const from = data.$version;
+    const to = this.latestVersion;
+    const path = getTransitionsPath(this.transitions, from, to);
+    if (path === null)
+      throw new UnavailableUpgradeError(data, from, to);
+    let current = jsonCloneDeep(data);
+    for (const transition of path) {
+      const next2 = await transition.apply(current);
+      if (next2 === null || next2 === void 0)
+        throw new EmptyUpgradeError(current, from, to);
+      current = next2;
+    }
+    return current;
+  }
+  isLatestVersion(data) {
+    return data.$version === this.latestVersion;
+  }
+  static create(latest) {
+    return new _DataUpgrader(latest);
+  }
+  static Errors = {
+    EmptyUpgrade: EmptyUpgradeError,
+    UnavailableUpgrade: UnavailableUpgradeError
+  };
+};
+function isUpgradable(obj) {
+  return isDefined(obj) && typeof obj === "object" && VERSION_FIELD in obj && isNumber(obj.$version) && isPositiveNumber(obj.$version);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ComparisonChain,
+  DataUpgrader,
+  Deferred,
+  DeferredCanceledError,
+  ErrorCannotInstantiatePresentOptionalWithEmptyValue,
+  ErrorGetEmptyOptional,
+  ErrorSetEmptyOptional,
+  Lazy,
+  LazyAsync,
+  Logger,
+  Optional,
+  RandomTimeDuration,
+  RateThrottler,
+  Semaphore,
+  Sorter,
+  Sorting,
+  StringParts,
+  TimeDuration,
+  TimeFrequency,
+  TimeInstant,
+  TimeRange,
+  TimeUnit,
+  alwaysFalse,
+  alwaysTrue,
+  and,
+  asError,
+  asPromise,
+  average,
+  capitalizeWord,
+  clamp,
+  constant,
+  constantFalse,
+  constantNull,
+  constantOne,
+  constantTrue,
+  constantZero,
+  createSorterFor,
+  decrement,
+  decrementBy,
+  delayPromise,
+  dictToEntries,
+  dictToList,
+  divideBy,
+  ellipsis,
+  ensureArray,
+  ensureDefined,
+  ensureNegativeNumber,
+  ensureNonNegativeNumber,
+  ensureNonPositiveNumber,
+  ensurePositiveNumber,
+  ensureReadableArray,
+  entriesToDict,
+  extendArray,
+  extendArrayWith,
+  fill,
+  filterMap,
+  filterMapReduce,
+  filterWithTypePredicate,
+  first,
+  flatMapTruthys,
+  groupByBoolean,
+  groupByBooleanWith,
+  groupByNumber,
+  groupByNumberWith,
+  groupByString,
+  groupByStringWith,
+  groupBySymbol,
+  groupBySymbolWith,
+  hashCode,
+  head,
+  identity,
+  ifDefined,
+  ifNullOrUndefined,
+  iff,
+  includes,
+  increment,
+  incrementBy,
+  indexByNumber,
+  indexByNumberWith,
+  indexByString,
+  indexByStringWith,
+  indexBySymbol,
+  indexBySymbolWith,
+  isAllowedTimeDuration,
+  isArray,
+  isDefined,
+  isError,
+  isFalse,
+  isFunction,
+  isNegativeNumber,
+  isNullOrUndefined,
+  isNumber,
+  isPositiveNumber,
+  isTimeInstant,
+  isTrue,
+  isUpgradable,
+  isZero,
+  jsonCloneDeep,
+  last,
+  makeArrayEmpty,
+  mapDefined,
+  mapEntries,
+  mapFirstTruthy,
+  mapTruthys,
+  max,
+  maxBy,
+  min,
+  minBy,
+  multiplyBy,
+  noop,
+  not,
+  omit,
+  omitFromJsonObject,
+  or,
+  pad,
+  padLeft,
+  padRight,
+  partition,
+  pick,
+  pluralize,
+  promiseSequence,
+  randomId,
+  randomInterval,
+  randomNumberInInterval,
+  randomPercentage,
+  range,
+  repeat,
+  reverse,
+  round,
+  roundAwayFromZero,
+  roundToLower,
+  roundToNearest,
+  roundToUpper,
+  roundTowardsZero,
+  sortedArray,
+  splitWords,
+  stringToNumber,
+  sum,
+  sumBy,
+  tail,
+  throttle,
+  tryToParseJson,
+  tryToParseNumber,
+  uniq,
+  uniqBy,
+  uniqByKey,
+  upsert,
+  withTryCatch,
+  withTryCatchAsync,
+  wrap,
+  wrapWithString,
+  xor
+});
+//# sourceMappingURL=index.cjs.map