@zelgadis87/utils-core 4.0.0

package/esbuild/index.mjs

@@ -0,0 +1,2518 @@
+// src/types/arrays.ts
+function ensureArray(t) {
+  return t instanceof Array ? t : [t];
+}
+function ensureReadableArray(t) {
+  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 head(arr, defaultValue = null) {
+  return arr.length ? arr[0] : defaultValue;
+}
+function last(arr, defaultValue = null) {
+  return head(reverse(arr), defaultValue);
+}
+function sortedArray(arr, sortFn) {
+  return [...arr].sort(sortFn);
+}
+function includes(arr, item, fromIndex) {
+  return arr.includes(item, fromIndex);
+}
+function filterTruthy(arr) {
+  return arr.filter((x) => x !== false);
+}
+
+// src/types/booleans.ts
+function isTrue(x) {
+  return x === true;
+}
+function isFalse(x) {
+  return x === false;
+}
+
+// src/types/functions.ts
+function isFunction(t) {
+  return typeof t === "function";
+}
+
+// src/types/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/types/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;
+}
+
+// src/types/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/types/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/types/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);
+}
+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, ...tail] = this.parts;
+    return tail;
+  }
+  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/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/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/async/Deferred.ts
+var DeferredCanceledError = class extends Error {
+};
+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._pending = false;
+    this._internals.resolve(val);
+  }
+  reject(reason) {
+    if (!this._pending) throw new Error("Illegal state exception");
+    this._pending = false;
+    this._internals.reject(reason);
+  }
+  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);
+  }
+  cancel() {
+    if (!this._pending) throw new Error("Illegal state exception");
+    this._internals.reject(new DeferredCanceledError("Execution aborted by the user"));
+  }
+  get asPromise() {
+    return this;
+  }
+  get 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/utils/asError.ts
+function asError(e) {
+  if (e === void 0 || e === null)
+    return new Error("Void message");
+  if (e instanceof Error)
+    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));
+}
+
+// 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/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/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();
+  }
+  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._waitingRequests = [];
+  }
+  _waitingRequests;
+  async _awaitSlot() {
+    if (this._availableSlots > 0) {
+      this._availableSlots -= 1;
+      return void 0;
+    } else {
+      const deferred = new Deferred_default();
+      this._waitingRequests.push(deferred);
+      return deferred.asPromise;
+    }
+  }
+  _releaseSlot() {
+    const waitingSlotToResolve = this._waitingRequests.shift();
+    if (waitingSlotToResolve) {
+      waitingSlotToResolve.resolve();
+    } else {
+      this._availableSlots += 1;
+    }
+  }
+  async execute(fn, cooldown = TimeDuration.ZERO) {
+    return this._awaitSlot().then(() => fn()).finally(() => {
+      void cooldown.promise().then(() => this._releaseSlot());
+    });
+  }
+};
+
+// 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/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 this._ms / TimeUnit.MILLISECONDS.multiplier;
+  }
+  get seconds() {
+    return this._ms / TimeUnit.SECONDS.multiplier;
+  }
+  get minutes() {
+    return this._ms / TimeUnit.MINUTES.multiplier;
+  }
+  get hours() {
+    return this._ms / TimeUnit.HOURS.multiplier;
+  }
+  get days() {
+    return 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/random/randomInterval.ts
+function randomInterval(min2, max2) {
+  return Math.floor(Math.random() * (max2 - min2 + 1) + min2);
+}
+
+// src/random/randomPercentage.ts
+function randomPercentage(min2, max2) {
+  return randomInterval(min2, max2) / 100;
+}
+
+// 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 format = (x, u1, y, u2) => `${x}${u1} ${pad(y.toString(), 2, "0")}${u2}`;
+    const units = this.toUnits();
+    if (units.days >= 1)
+      return format(units.days, "d", units.hours, "h");
+    else if (units.hours >= 1)
+      return format(units.hours, "h", units.minutes, "m");
+    else if (units.minutes >= 1)
+      return format(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);
+  }
+  promise() {
+    const deferred = new Deferred_default();
+    if (this.isEmpty()) {
+      deferred.resolve();
+    } else {
+      this.timeout(() => deferred.resolve());
+    }
+    return deferred.asCancelablePromise;
+  }
+  delay(cb) {
+    const deferred = this.promise();
+    void deferred.then(() => {
+      cb();
+    }, (_err) => {
+      return;
+    });
+    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.asDateUTC()) + 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.asDateUTC();
+  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().asDateUTC();
+  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()));
+  }
+  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 });
+  }
+  /** @deprecated[2024-10-24]: Use #promise() instead. */
+  timeout(cb) {
+    if (!this.isInTheFuture) {
+      throw new Error("Instant is in the past");
+    } else {
+      return this.distanceFromNow().timeout(() => cb());
+    }
+  }
+  promise() {
+    const deferred = new Deferred_default();
+    if (!this.isInTheFuture) {
+      deferred.resolve();
+    } else {
+      this.distanceFromNow().timeout(() => deferred.resolve());
+    }
+    return deferred.asCancelablePromise;
+  }
+  delay(cb) {
+    const deferred = this.promise();
+    void deferred.then(() => {
+      cb();
+    }, (_err) => {
+      return;
+    });
+    return { cancel: () => deferred.cancel() };
+  }
+  isToday() {
+    return Math.floor(this.days) === Math.floor(_TimeInstant.now().days);
+  }
+  asTimeString() {
+    const date = this.asDate();
+    return `${this.doGetTwoDigitsHours(date)}:${this.doGetTwoDigitsMinutes(date)}:${this.doGetTwoDigitsSeconds(date)}`;
+  }
+  asDateString() {
+    const date = this.asDate();
+    return `${this.doGetTwoDigitsDays(date)}/${this.doGetTwoDigitsMonths(date)}/${this.doGetFourDigitsYears(date)}`;
+  }
+  asIso8601() {
+    const dash = "-", colon = ".", doublecolon = ":", T = "T", date = this.asDate();
+    return this.doGetFourDigitsYears(date) + dash + this.doGetTwoDigitsMonths(date) + dash + this.doGetTwoDigitsDays(date) + T + this.doGetTwoDigitsHours(date) + doublecolon + this.doGetTwoDigitsMinutes(date) + doublecolon + this.doGetTwoDigitsSeconds(date) + colon + this.doGetThreeDigitsMilliseconds(date) + this.doGetFourDigitsTimezoneOffset(date);
+  }
+  asIso8601UTC() {
+    const dash = "-", colon = ".", doublecolon = ":", T = "T", utcDate = this.asDateUTC();
+    return this.doGetFourDigitsYears(utcDate) + dash + this.doGetTwoDigitsMonths(utcDate) + dash + this.doGetTwoDigitsDays(utcDate) + T + this.doGetTwoDigitsHours(utcDate) + doublecolon + this.doGetTwoDigitsMinutes(utcDate) + doublecolon + this.doGetTwoDigitsSeconds(utcDate) + colon + this.doGetThreeDigitsMilliseconds(utcDate) + "Z";
+  }
+  asHumanTimestamp() {
+    const dash = "-", colon = ".", doublecolon = ":", T = "T", date = this.asDate();
+    return this.doGetFourDigitsYears(date) + dash + this.doGetTwoDigitsMonths(date) + dash + this.doGetTwoDigitsDays(date) + T + this.doGetTwoDigitsHours(date) + doublecolon + this.doGetTwoDigitsMinutes(date) + doublecolon + this.doGetTwoDigitsSeconds(date) + colon + this.doGetThreeDigitsMilliseconds(date);
+  }
+  // Please do not use this method internally, as it is not optimized for continued usage.
+  get twoDigitsDays() {
+    return this.doGetTwoDigitsDays(this.asDate());
+  }
+  // Please do not use this method internally, as it is not optimized for continued usage.
+  get twoDigitsMonths() {
+    return this.doGetTwoDigitsMonths(this.asDate());
+  }
+  // Please do not use this method internally, as it is not optimized for continued usage.
+  get fourDigitsYears() {
+    return this.doGetFourDigitsYears(this.asDate());
+  }
+  // Please do not use this method internally, as it is not optimized for continued usage.
+  get twoDigitsHours() {
+    return this.doGetTwoDigitsHours(this.asDate());
+  }
+  // Please do not use this method internally, as it is not optimized for continued usage.
+  get twoDigitsMinutes() {
+    return this.doGetTwoDigitsMinutes(this.asDate());
+  }
+  // Please do not use this method internally, as it is not optimized for continued usage.
+  get twoDigitsSeconds() {
+    return this.doGetTwoDigitsSeconds(this.asDate());
+  }
+  // Please do not use this method internally, as it is not optimized for continued usage.
+  get threeDigitsMilliseconds() {
+    return this.doGetThreeDigitsMilliseconds(this.asDate());
+  }
+  // Please do not use this method internally, as it is not optimized for continued usage.
+  get twoDigitsDaysUTC() {
+    return this.doGetTwoDigitsDays(this.asDateUTC());
+  }
+  // Please do not use this method internally, as it is not optimized for continued usage.
+  get twoDigitsMonthsUTC() {
+    return this.doGetTwoDigitsMonths(this.asDateUTC());
+  }
+  // Please do not use this method internally, as it is not optimized for continued usage.
+  get fourDigitsYearsUTC() {
+    return this.doGetFourDigitsYears(this.asDateUTC());
+  }
+  // Please do not use this method internally, as it is not optimized for continued usage.
+  get twoDigitsHoursUTC() {
+    return this.doGetTwoDigitsHours(this.asDateUTC());
+  }
+  // Please do not use this method internally, as it is not optimized for continued usage.
+  get twoDigitsMinutesUTC() {
+    return this.doGetTwoDigitsMinutes(this.asDateUTC());
+  }
+  // Please do not use this method internally, as it is not optimized for continued usage.
+  get twoDigitsSecondsUTC() {
+    return this.doGetTwoDigitsSeconds(this.asDateUTC());
+  }
+  // Please do not use this method internally, as it is not optimized for continued usage.
+  get threeDigitsMillisecondsUTC() {
+    return this.doGetThreeDigitsMilliseconds(this.asDateUTC());
+  }
+  // Please do not use this method internally, as it is not optimized for continued usage.
+  get fourDigitsTimezoneOffset() {
+    const offset = this.asDate().getTimezoneOffset();
+    return (offset >= 0 ? "+" : "-") + pad(Math.floor(Math.abs(offset) / 60).toString(), 2, "0") + pad((Math.abs(offset) % 60).toString(), 2, "0");
+  }
+  doGetTwoDigitsDays(date) {
+    return pad(date.getDate().toString(), 2, "0");
+  }
+  doGetTwoDigitsMonths(date) {
+    return pad((date.getMonth() + 1).toString(), 2, "0");
+  }
+  doGetFourDigitsYears(date) {
+    return pad(date.getFullYear().toString(), 4, "0");
+  }
+  doGetTwoDigitsHours(date) {
+    return pad(date.getHours().toString(), 2, "0");
+  }
+  doGetTwoDigitsMinutes(date) {
+    return pad(date.getMinutes().toString(), 2, "0");
+  }
+  doGetTwoDigitsSeconds(date) {
+    return pad(date.getSeconds().toString(), 2, "0");
+  }
+  doGetThreeDigitsMilliseconds(date) {
+    return pad(date.getMilliseconds().toString(), 3, "0");
+  }
+  doGetFourDigitsTimezoneOffset(date) {
+    const offset = date.getTimezoneOffset();
+    return (offset >= 0 ? "+" : "-") + pad(Math.floor(Math.abs(offset) / 60).toString(), 2, "0") + pad((Math.abs(offset) % 60).toString(), 2, "0");
+  }
+  asUnixTimestamp() {
+    return this.ms;
+  }
+  asDate() {
+    return new Date(this.ms);
+  }
+  asDateUTC() {
+    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[04/07/2023]: Use distanceFromNow instead
+  	*/
+  fromNow() {
+    return TimeDuration_default.ms(this.ms - Date.now());
+  }
+  /**
+  	* @deprecated[04/07/2023]: Use distanceFrom instead
+  	*/
+  from(instant) {
+    return TimeDuration_default.ms(this.ms - instant.ms);
+  }
+  /**
+  	* @deprecated[04/07/2023]: Use distanceFromUnixTimestamp instead
+  	*/
+  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 greatest(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 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.asDate().getDate();
+  }
+  get dayOfWeek() {
+    return this.asDate().getDay() + 1;
+  }
+  get month() {
+    return this.asDate().getMonth() + 1;
+  }
+  get year() {
+    return this.asDate().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.asDate();
+    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 first = (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 first(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/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);
+}
+export {
+  ComparisonChain_default as ComparisonChain,
+  DataUpgrader,
+  Deferred,
+  DeferredCanceledError,
+  ErrorCannotInstantiatePresentOptionalWithEmptyValue,
+  ErrorGetEmptyOptional,
+  ErrorSetEmptyOptional,
+  Lazy,
+  LazyAsync,
+  Logger,
+  Optional,
+  RandomTimeDuration,
+  RateThrottler,
+  Semaphore,
+  Sorter,
+  Sorting,
+  StringParts,
+  TimeDuration,
+  TimeFrequency,
+  TimeInstant,
+  TimeUnit,
+  asError,
+  asPromise,
+  average,
+  bindThis,
+  capitalizeWord,
+  clamp,
+  constant,
+  constantFalse,
+  constantNull,
+  constantOne,
+  constantTrue,
+  constantZero,
+  createSorterFor,
+  decrement,
+  decrementBy,
+  delayPromise,
+  dictToEntries,
+  dictToList,
+  divideBy,
+  ensureArray,
+  ensureDefined,
+  ensureNegativeNumber,
+  ensureNonNegativeNumber,
+  ensureNonPositiveNumber,
+  ensurePositiveNumber,
+  ensureReadableArray,
+  entriesToDict,
+  extendArray,
+  extendArrayWith,
+  fill,
+  filterTruthy,
+  groupByNumber,
+  groupByNumberWith,
+  groupByString,
+  groupByStringWith,
+  groupBySymbol,
+  groupBySymbolWith,
+  hashCode,
+  head,
+  identity,
+  ifDefined,
+  ifNullOrUndefined,
+  iff,
+  includes,
+  increment,
+  incrementBy,
+  indexByNumber,
+  indexByNumberWith,
+  indexByString,
+  indexByStringWith,
+  indexBySymbol,
+  indexBySymbolWith,
+  isAllowedTimeDuration,
+  isArray,
+  isDefined,
+  isFalse,
+  isFunction,
+  isNegativeNumber,
+  isNullOrUndefined,
+  isNumber,
+  isPositiveNumber,
+  isTimeInstant,
+  isTrue,
+  isUpgradable,
+  isZero,
+  jsonCloneDeep,
+  last,
+  mapDefined,
+  mapEntries,
+  max,
+  maxBy,
+  min,
+  minBy,
+  multiplyBy,
+  noop,
+  omit,
+  pad,
+  pick,
+  pluralize,
+  promiseSequence,
+  randomInterval,
+  randomPercentage,
+  range,
+  repeat,
+  reverse,
+  round,
+  roundAwayFromZero,
+  roundToLower,
+  roundToNearest,
+  roundToUpper,
+  roundTowardsZero,
+  sortBy,
+  sortedArray,
+  splitWords,
+  stringToNumber,
+  sum,
+  sumBy,
+  throttle,
+  uniq,
+  uniqBy,
+  uniqByKey,
+  upsert,
+  withTryCatch,
+  withTryCatchAsync,
+  wrap
+};