@zelgadis87/utils-core 5.2.11 → 5.3.0

package/esbuild/index.cjs

@@ -1,3380 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  DataUpgrader: () => DataUpgrader,
-  Deferred: () => Deferred,
-  DeferredCanceledError: () => DeferredCanceledError,
-  ErrorCannotInstantiatePresentOptionalWithEmptyValue: () => ErrorCannotInstantiatePresentOptionalWithEmptyValue,
-  ErrorGetEmptyOptional: () => ErrorGetEmptyOptional,
-  ErrorSetEmptyOptional: () => ErrorSetEmptyOptional,
-  Lazy: () => Lazy,
-  LazyAsync: () => LazyAsync,
-  LazyDictionary: () => LazyDictionary,
-  Logger: () => Logger,
-  NEVER: () => NEVER,
-  NonExhaustiveSwitchError: () => NonExhaustiveSwitchError,
-  Operation: () => Operation,
-  Optional: () => Optional,
-  PredicateBuilder: () => PredicateBuilder,
-  RandomTimeDuration: () => RandomTimeDuration,
-  RateThrottler: () => RateThrottler,
-  Semaphore: () => Semaphore,
-  Sorter: () => Sorter,
-  StringParts: () => StringParts,
-  TimeDuration: () => TimeDuration,
-  TimeFrequency: () => TimeFrequency,
-  TimeInstant: () => TimeInstant,
-  TimeRange: () => TimeRange,
-  TimeUnit: () => TimeUnit,
-  TimeoutError: () => TimeoutError,
-  alwaysFalse: () => alwaysFalse,
-  alwaysTrue: () => alwaysTrue,
-  and: () => and,
-  arrayGet: () => arrayGet,
-  asError: () => asError,
-  asPromise: () => asPromise,
-  average: () => average,
-  awaitAtMost: () => awaitAtMost,
-  capitalizeWord: () => capitalizeWord,
-  clamp: () => clamp,
-  clampInt0_100: () => clampInt0_100,
-  constant: () => constant,
-  constantFalse: () => constantFalse,
-  constantNull: () => constantNull,
-  constantOne: () => constantOne,
-  constantTrue: () => constantTrue,
-  constantUndefined: () => constantUndefined,
-  constantZero: () => constantZero,
-  cssDeclarationRulesDictionaryToCss: () => cssDeclarationRulesDictionaryToCss,
-  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,
-  entriesToEntries: () => entriesToEntries,
-  entriesToList: () => entriesToList,
-  extendArray: () => extendArray,
-  extendArrayWith: () => extendArrayWith,
-  fill: () => fill,
-  filterMap: () => filterMap,
-  filterMapReduce: () => filterMapReduce,
-  filterWithTypePredicate: () => filterWithTypePredicate,
-  findInArray: () => findInArray,
-  findIndexInArray: () => findIndexInArray,
-  first: () => first,
-  flatMapTruthys: () => flatMapTruthys,
-  getCauseMessageFromError: () => getCauseMessageFromError,
-  getCauseStackFromError: () => getCauseStackFromError,
-  getMessageFromError: () => getMessageFromError,
-  getStackFromError: () => getStackFromError,
-  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,
-  isEmpty: () => isEmpty,
-  isError: () => isError,
-  isFalse: () => isFalse,
-  isFunction: () => isFunction,
-  isNegativeNumber: () => isNegativeNumber,
-  isNullOrUndefined: () => isNullOrUndefined,
-  isNullOrUndefinedOrEmpty: () => isNullOrUndefinedOrEmpty,
-  isNumber: () => isNumber,
-  isPositiveNumber: () => isPositiveNumber,
-  isString: () => isString,
-  isTimeInstant: () => isTimeInstant,
-  isTrue: () => isTrue,
-  isUpgradable: () => isUpgradable,
-  isZero: () => isZero,
-  jsonCloneDeep: () => jsonCloneDeep,
-  last: () => last,
-  listToDict: () => listToDict,
-  mapDefined: () => mapDefined,
-  mapEntries: () => mapEntries,
-  mapFirstTruthy: () => mapFirstTruthy,
-  mapTruthys: () => mapTruthys,
-  max: () => max,
-  maxBy: () => maxBy,
-  min: () => min,
-  minBy: () => minBy,
-  multiplyBy: () => multiplyBy,
-  noop: () => noop,
-  not: () => not,
-  omitFromJsonObject: () => omitFromJsonObject,
-  or: () => or,
-  pad: () => pad,
-  padLeft: () => padLeft,
-  padRight: () => padRight,
-  parseJson: () => parseJson,
-  partition: () => partition,
-  pick: () => pick,
-  pipedInvoke: () => pipedInvoke,
-  pipedInvokeFromArray: () => pipedInvokeFromArray,
-  pluralize: () => pluralize,
-  promiseSequence: () => promiseSequence,
-  randomId: () => randomId,
-  randomNumberInInterval: () => randomNumberInInterval,
-  range: () => range,
-  repeat: () => repeat,
-  reverse: () => reverse,
-  round: () => round,
-  roundAwayFromZero: () => roundAwayFromZero,
-  roundToLower: () => roundToLower,
-  roundToNearest: () => roundToNearest,
-  roundToUpper: () => roundToUpper,
-  roundTowardsZero: () => roundTowardsZero,
-  shallowArrayEquals: () => shallowArrayEquals,
-  shallowRecordEquals: () => shallowRecordEquals,
-  sortedArray: () => sortedArray,
-  splitWords: () => splitWords,
-  stringToNumber: () => stringToNumber,
-  stringifyJson: () => stringifyJson,
-  sum: () => sum,
-  sumBy: () => sumBy,
-  tail: () => tail,
-  throttle: () => throttle,
-  throwIfNullOrUndefined: () => throwIfNullOrUndefined,
-  transformCssDictionary: () => transformCssDictionary,
-  tryToParseJson: () => tryToParseJson,
-  tryToParseNumber: () => tryToParseNumber,
-  uniq: () => uniq,
-  uniqBy: () => uniqBy,
-  uniqByKey: () => uniqByKey,
-  unzip: () => unzip,
-  upsert: () => upsert,
-  withTryCatch: () => withTryCatch,
-  withTryCatchAsync: () => withTryCatchAsync,
-  wrapWithString: () => wrapWithString,
-  xor: () => xor,
-  zip: () => zip
-});
-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;
-  }
-  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();
-}
-function throwIfNullOrUndefined(source, errorProducer = () => new Error(`Unexpected ${source} value`)) {
-  return ifNullOrUndefined(source, () => {
-    throw errorProducer();
-  });
-}
-
-// src/Optional.ts
-var Optional = class _Optional {
-  _present;
-  _value;
-  constructor(t) {
-    const defined = isDefined(t);
-    this._value = defined ? t : void 0;
-    this._present = defined;
-  }
-  getRawValue() {
-    return this._value;
-  }
-  get() {
-    return this.getOrElseThrow(() => new ErrorGetEmptyOptional());
-  }
-  getOrElseThrow(errorProducer) {
-    if (this.isEmpty())
-      throw errorProducer();
-    return this._value;
-  }
-  set(t) {
-    if (isNullOrUndefined(t))
-      throw new ErrorSetEmptyOptional();
-    this._value = t;
-    this._present = true;
-  }
-  setNullable(t) {
-    if (isDefined(t)) {
-      return this.set(t);
-    }
-    return this;
-  }
-  clear() {
-    this._value = void 0;
-    this._present = false;
-  }
-  isEmpty() {
-    return !this._present;
-  }
-  isPresent() {
-    return this._present;
-  }
-  ifEmpty(callback) {
-    if (this.isEmpty())
-      return callback();
-  }
-  ifPresent(callback) {
-    if (this.isPresent())
-      return callback(this.get());
-  }
-  ifPresentThenClear(callback) {
-    if (this.isPresent()) {
-      callback(this.get());
-      this.clear();
-    }
-  }
-  apply(callbackIfPresent, callbackIfEmpty) {
-    if (this.isEmpty()) {
-      return callbackIfEmpty();
-    } else {
-      return callbackIfPresent(this.get());
-    }
-  }
-  orElseReturn(newValue) {
-    if (this.isPresent()) {
-      return this.get();
-    } else {
-      return newValue;
-    }
-  }
-  orElse = this.orElseReturn.bind(this);
-  orElseProduce(newValueProducer) {
-    if (this.isPresent()) {
-      return this.get();
-    } else {
-      return newValueProducer();
-    }
-  }
-  orElseGet = this.orElseProduce.bind(this);
-  orElseReturnAndApply(newValue) {
-    if (this.isPresent()) {
-      return this.get();
-    } else {
-      this.set(newValue);
-      return newValue;
-    }
-  }
-  orElseProduceAndApply(newValueProducer) {
-    if (this.isPresent()) {
-      return this.get();
-    } else {
-      const newValue = newValueProducer();
-      this.set(newValue);
-      return newValue;
-    }
-  }
-  orElseReturnNullableAndApply(newValue) {
-    if (this.isPresent()) {
-      return this;
-    } else {
-      this.setNullable(newValue);
-      return this;
-    }
-  }
-  orElseProduceNullableAndApply(newValueProducer) {
-    if (this.isPresent()) {
-      return this;
-    } else {
-      const newValue = newValueProducer();
-      this.setNullable(newValue);
-      return this;
-    }
-  }
-  orElseReturnNullable(newValue) {
-    if (this.isEmpty()) return _Optional.ofNullable(newValue);
-    return this;
-  }
-  orElseNullable = this.orElseReturnNullable.bind(this);
-  orElseProduceNullable(newValueProducer) {
-    if (this.isEmpty()) {
-      const newValue = newValueProducer();
-      return _Optional.ofNullable(newValue);
-    }
-    return this;
-  }
-  orElseGetNullable = this.orElseProduceNullable.bind(this);
-  orElseThrow(errorProducer) {
-    if (this.isEmpty())
-      throw errorProducer();
-    return this;
-  }
-  throwIfPresent(errorProducer) {
-    if (this.isEmpty())
-      return this;
-    throw errorProducer(this.get());
-  }
-  mapTo(mapper) {
-    return this.flatMapTo((t) => _Optional.ofNullable(mapper(t)));
-  }
-  flatMapTo(mapper) {
-    return this.isPresent() ? mapper(this.get()) : _Optional.empty();
-  }
-  filter(predicate) {
-    if (this.isEmpty())
-      return this;
-    if (predicate(this.get()))
-      return this;
-    return _Optional.empty();
-  }
-  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 Optional_default = Optional;
-var ErrorGetEmptyOptional = class extends Error {
-  constructor() {
-    super("Cannot retrieve a value from an empty Optional.");
-  }
-};
-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/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) {
-      if (dict[key]) {
-        throw new Error(`Multiple values indexed by same key "${String(key)}".`);
-      }
-      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 constantUndefined = constant(void 0);
-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/predicateBuilder.ts
-var PredicateBuilder = class {
-  _currentPredicate = constantTrue;
-  and(predicate) {
-    const curPredicate = this._currentPredicate.bind(void 0);
-    const newPredicate = (t) => curPredicate(t) && predicate(t);
-    this._currentPredicate = newPredicate;
-    return this;
-  }
-  or(predicate) {
-    const newPredicate = (t) => this._currentPredicate(t) || predicate(t);
-    this._currentPredicate = newPredicate;
-    return this;
-  }
-  toPredicate() {
-    return this._currentPredicate;
-  }
-};
-
-// 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);
-}
-function pipedInvoke(...fns) {
-  return pipedInvokeFromArray(fns);
-}
-function pipedInvokeFromArray(fns) {
-  if (fns.length === 0) {
-    return identity;
-  }
-  if (fns.length === 1) {
-    return fns[0];
-  }
-  return function piped(input) {
-    return fns.reduce((prev, fn) => fn(prev), input);
-  };
-}
-
-// 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 listToDict(arr, mapFn) {
-  return arr.reduce((dict, cur) => {
-    const [key, value] = mapFn(cur);
-    return { ...dict, [key]: value };
-  }, {});
-}
-function shallowArrayEquals(a, b) {
-  if (a === b) return true;
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) return false;
-  }
-  return true;
-}
-function findInArray(arr, predicate) {
-  return Optional_default.ofNullable(arr.find(predicate));
-}
-function findIndexInArray(arr, predicate) {
-  const idx = arr.findIndex(predicate);
-  return idx === -1 ? Optional_default.empty() : Optional_default.of(idx);
-}
-function zip(ts, rs) {
-  if (ts.length !== rs.length)
-    throw new Error(`Arrays must have the same length. Got ${ts.length} and ${rs.length}`);
-  return ts.map((t, i) => [t, rs[i]]);
-}
-function unzip(arr) {
-  return arr.reduce(([ts, rs], [t, r]) => {
-    return [[...ts, t], [...rs, r]];
-  }, [[], []]);
-}
-function arrayGet(arr, index) {
-  if (index < 0 || index >= arr.length)
-    return Optional_default.empty();
-  return Optional_default.of(arr[index]);
-}
-
-// src/utils/booleans.ts
-function isTrue(x) {
-  return x === true;
-}
-function isFalse(x) {
-  return x === false;
-}
-
-// src/utils/css.ts
-var newLine = "\n";
-var tabulation = "	";
-var colon = ":";
-var semiColon = ";";
-var space = " ";
-var openBracket = "{";
-var closeBracket = "}";
-function cssDeclarationRulesDictionaryToCss(syleDeclarationRulesForSelectorsProduceable, indent = 0) {
-  const syleDeclarationRulesForSelectors = produceableToValue(syleDeclarationRulesForSelectorsProduceable);
-  return Object.entries(syleDeclarationRulesForSelectors).map(([selector, styleDeclarationRules]) => {
-    const cssRules = cssSelectorDeclarationRulesDictionaryToCss(styleDeclarationRules, indent + 1);
-    if (!cssRules.length) return null;
-    return repeat(tabulation, indent) + selector + space + openBracket + newLine + cssRules.join(newLine) + newLine + closeBracket;
-  }).filter(Boolean).join(newLine + newLine);
-}
-function cssSelectorDeclarationRulesDictionaryToCss(styleDeclarationRules, indent = 0) {
-  return Object.entries(styleDeclarationRules).map(([key, value]) => {
-    if (typeof value === "string") {
-      if (key.startsWith("--")) {
-        return repeat(tabulation, indent) + key + colon + space + value + semiColon;
-      } else {
-        return repeat(tabulation, indent) + pascalCaseToKebabCase(key) + colon + space + value + semiColon;
-      }
-    } else {
-      return repeat(tabulation, indent) + key + space + openBracket + newLine + cssSelectorDeclarationRulesDictionaryToCss(value, indent + 1).join(newLine) + newLine + repeat(tabulation, indent) + closeBracket;
-    }
-  });
-}
-function transformCssDictionary(dict, transformer) {
-  const recurse = (dict2) => {
-    const newDict = {};
-    for (const [key, value] of Object.entries(dict2)) {
-      if (typeof value === "string") {
-        const newValue = transformer(key, value);
-        if (isDefined(newValue)) {
-          newDict[key] = newValue;
-        }
-      } else {
-        newDict[key] = transformCssDictionary(value, transformer);
-      }
-    }
-    return newDict;
-  };
-  return recurse(dict);
-}
-function pascalCaseToKebabCase(s) {
-  return s.split(/([A-Z][a-z]*)/).filter(Boolean).map((n) => n.toLowerCase()).join("-");
-}
-function produceableToValue(t) {
-  return isFunction(t) ? t() : t;
-}
-
-// src/utils/errors/withTryCatch.ts
-function withTryCatch(fn, errMapFn = identity) {
-  try {
-    return [fn(), void 0];
-  } catch (e) {
-    return [void 0, errMapFn(asError(e))];
-  }
-}
-async function withTryCatchAsync(fn, errMapFn = identity) {
-  try {
-    return [await fn(), void 0];
-  } catch (e) {
-    return [void 0, errMapFn(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;
-}
-function getMessageFromError(error) {
-  return `${error.name}: ${error.message}${getCauseMessageFromError(error)}`;
-}
-function getStackFromError(error) {
-  const stack = error.stack && error.stack.includes(error.message) ? error.stack : error.message + " " + (error.stack ?? "");
-  return `${error.name}: ${stack}${getCauseStackFromError(error)}`;
-}
-function getCauseMessageFromError(error) {
-  if (isNullOrUndefined(error.cause))
-    return "";
-  return `
-caused by: ${getMessageFromError(asError(error.cause))}`;
-}
-function getCauseStackFromError(error) {
-  if (isNullOrUndefined(error.cause))
-    return "";
-  return `
-caused by: ${getStackFromError(asError(error.cause))}`;
-}
-var NonExhaustiveSwitchError = class extends Error {
-  constructor(value) {
-    super("Expected switch to be exhaustive, got: " + value);
-  }
-};
-
-// src/utils/json.ts
-function tryToParseJson(jsonContent) {
-  return withTryCatch(() => parseJson(jsonContent));
-}
-function parseJson(jsonContent) {
-  return JSON.parse(jsonContent);
-}
-function stringifyJson(jsonSerializable, minify = false) {
-  return JSON.stringify(jsonSerializable, void 0, minify ? void 0 : 2);
-}
-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 });
-}
-
-// 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 clampInt0_100(n) {
-  return clamp(Math.round(n), 0, 100);
-}
-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/operations.ts
-var Operation = {
-  ok: (data) => {
-    return { success: true, data };
-  },
-  ko: (error) => {
-    return { success: false, error };
-  }
-};
-
-// 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);
-}
-var TimeoutError = class extends Error {
-};
-async function awaitAtMost(promise, duration) {
-  return Promise.race([
-    promise.then((value) => ({ status: "ok", value })),
-    duration.promise().then(() => ({ status: "timeout" }))
-  ]).then(({ status, value }) => {
-    if (status === "ok")
-      return value;
-    throw new TimeoutError("Time out reached while waiting for a promise to resolve.");
-  });
-}
-var NEVER = new Promise((_resolve) => {
-});
-
-// src/utils/random.ts
-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 entriesToEntries(dict, mapper) {
-  return entriesToDict(dictToEntries(dict).map((entry) => mapper(entry)));
-}
-var mapEntries = entriesToEntries;
-function entriesToList(dict, mapper) {
-  return 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;
-  }, {});
-}
-function shallowRecordEquals(a, b) {
-  if (a === b) return true;
-  const aKeys = Object.keys(a), bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length) return false;
-  for (const key of aKeys) {
-    if (a[key] !== b[key]) return false;
-  }
-  return true;
-}
-
-// 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);
-  };
-  /**
-   * Tries to convert a word in PascalCase to an array of words. Will not work if there are spaces or special characters. Does not cope well on uppercase abbreviations (eg, "CSS").
-   * @param s a string in PascalCase. 
-   * @returns a StringParts where each sub-word in PascalCase is now a part.
-   */
-  static tryToParsePascalCaseWord(s) {
-    return new _StringParts(...s.split(/([A-Z][a-z]*)/).filter(Boolean).map((n) => n.toLowerCase()));
-  }
-};
-
-// 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 isString(source) {
-  return isDefined(source) && typeof source === "string";
-}
-function isEmpty(source) {
-  return source.trim().length === 0;
-}
-function isNullOrUndefinedOrEmpty(source) {
-  return isNullOrUndefined(source) || isEmpty(source);
-}
-function wrapWithString(str, start, end = start) {
-  if (isNullOrUndefinedOrEmpty(str))
-    throw new Error(`Expected string to be non-empty, got: "${str}"`);
-  if (isNullOrUndefinedOrEmpty(start))
-    throw new Error(`Expected start delimiter to be non-empty, got: "${start}"`);
-  if (isNullOrUndefinedOrEmpty(end))
-    throw new Error(`Expected end delimiter to be non-empty, got: "${end}"`);
-  return start + str + end;
-}
-
-// 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/lazy/LazyDictionary.ts
-var LazyDictionary = class _LazyDictionary {
-  constructor(_generator) {
-    this._generator = _generator;
-  }
-  _dictionary = {};
-  static of(generator) {
-    return new _LazyDictionary(generator);
-  }
-  getOrCreate(key) {
-    if (key in this._dictionary) {
-      return this._dictionary[key];
-    }
-    const value = this._generator(key);
-    this._dictionary[key] = value;
-    return value;
-  }
-  getOrThrow(key, errorMessage) {
-    if (key in this._dictionary) {
-      return this._dictionary[key];
-    }
-    throw new Error(errorMessage);
-  }
-};
-
-// 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);
-  }
-  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);
-};
-
-// src/time/TimeBase.ts
-var TimeBase = class {
-  _ms;
-  constructor(value, unit) {
-    this._ms = unit.toMs(value);
-  }
-  /**
-   * Total number of milliseconds, rounded down.
-   */
-  get ms() {
-    return Math.floor(this._ms / TimeUnit.MILLISECONDS.multiplier);
-  }
-  /**
-   * Total number of seconds, rounded down.
-   */
-  get seconds() {
-    return Math.floor(this._ms / TimeUnit.SECONDS.multiplier);
-  }
-  /**
-   * Total number of minutes, rounded down.
-   */
-  get minutes() {
-    return Math.floor(this._ms / TimeUnit.MINUTES.multiplier);
-  }
-  /**
-   * Total number of hours, rounded down.
-   */
-  get hours() {
-    return Math.floor(this._ms / TimeUnit.HOURS.multiplier);
-  }
-  /**
-   * Total number of days, rounded down.
-   */
-  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 {
-      milliseconds: this.ms % TimeUnit.SECONDS.multiplier,
-      seconds: Math.floor(this.seconds % 60),
-      minutes: Math.floor(this.minutes % 60),
-      hours: Math.floor(this.hours % 24),
-      days: Math.floor(this.days)
-    };
-  }
-  static unitsToMs(units) {
-    if (!units)
-      throw new Error("Invalid units given");
-    let ms = 0;
-    ms += (units.milliseconds ?? 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);
-  }
-  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";
-  }
-  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);
-  }
-  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;
-  }
-  toUnits() {
-    return super.toUnits();
-  }
-  /**
-  	* 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.unitsToMs({ 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 = (value) => new _TimeDuration(value, TimeUnit.MILLISECONDS);
-  static seconds = (value) => new _TimeDuration(value, TimeUnit.SECONDS);
-  static minutes = (value) => new _TimeDuration(value, TimeUnit.MINUTES);
-  static hours = (value) => new _TimeDuration(value, TimeUnit.HOURS);
-  static days = (value) => new _TimeDuration(value, 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);
-  }
-  static fromUnits(parameters) {
-    return _TimeDuration.ms(TimeBase.unitsToMs(parameters));
-  }
-};
-function isAllowedTimeDuration(t) {
-  return typeof t === "number" && t > 0 || t instanceof TimeDuration;
-}
-var TimeDuration_default = TimeDuration;
-
-// src/time/constants.ts
-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
-};
-
-// 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 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() + 1,
-  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) - 1,
-    // Convert from 1-based to 0-based for Date.UTC()
-    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()));
-  }
-  distanceFromUnixTimestamp(timestamp2) {
-    return TimeDuration_default.ms(this.ms - timestamp2);
-  }
-  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() {
-    const params = this.toParameters();
-    const msInDay = params.hours * 36e5 + params.minutes * 6e4 + params.seconds * 1e3 + params.milliseconds;
-    return TimeDuration_default.fromMs(msInDay);
-  }
-  atStartOfDay() {
-    return this.atTime({ hours: 0, minutes: 0, seconds: 0, milliseconds: 0 });
-  }
-  distanceFromEndOfDay() {
-    const params = this.toParameters();
-    const msInDay = params.hours * 36e5 + params.minutes * 6e4 + params.seconds * 1e3 + params.milliseconds;
-    const msUntilEndOfDay = 86399999 - msInDay;
-    return TimeDuration_default.fromMs(msUntilEndOfDay);
-  }
-  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 not in the future");
-  }
-  ensureInThePast() {
-    if (!this.isInThePast())
-      throw new Error("Instant is not in the past");
-  }
-  isToday() {
-    return Math.floor(this.ms / 864e5) === Math.floor(Date.now() / 864e5);
-  }
-  /**
-   * Formats this instant using the given pattern. The pattern can contain the following tokens:
-   * 
-   * Note: Implementation inspired by the small-date library (https://github.com/robinweser/small-date).
-   * 
-   * | 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 formatTimeInstant(this, pattern, config);
-  }
-  /**
-   * Parses a date string using the given pattern and creates a TimeInstant.
-   * This method is the inverse of format() - parsing a formatted string should recreate the original instant.
-   * 
-   * For partial patterns (e.g., time-only or date-only), the missing components are taken from the base instant.
-   * For example, parsing "14:30" with base set to yesterday at midnight will result in yesterday at 14:30.
-   * 
-   * Note: Currently performs basic validation (e.g., month 1-12, day 1-31) but does not validate
-   * calendar-specific constraints (e.g., February 30th, April 31st). Invalid dates may be
-   * normalized by the underlying Date constructor.
-   * 
-   * @param dateString The date string to parse
-   * @param pattern The pattern used to parse the string (same tokens as format())
-   * @param base The base TimeInstant to use for partial patterns (defaults to now)
-   * @param config An optional locale and timeZone definition to use during parsing
-   * @returns A TimeInstant parsed from the string
-   * @throws Error if the string doesn't match the pattern or contains invalid basic values
-   * @todo Add calendar-aware validation to reject dates like February 30th, April 31st
-   */
-  static fromString(dateString, pattern, base = _TimeInstant.now(), config = {}) {
-    return parseTimeInstant(dateString, pattern, base, config);
-  }
-  static parse(dateString, pattern, config = {}) {
-    return parseTimeInstantComponents(dateString, 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, containing both the date and the time. The format COULD change in the future, do NOT use this method for consistent outputs.
-   */
-  asHumanTimestamp() {
-    return this.format("yyyy-MM-dd HH:mm:ss");
-  }
-  toUnixTimestamp() {
-    return this.ms;
-  }
-  toDate() {
-    return new Date(this.ms);
-  }
-  toParameters() {
-    const d = this.toDate();
-    return {
-      year: d.getUTCFullYear(),
-      month: d.getUTCMonth() + 1,
-      date: d.getUTCDate(),
-      hours: d.getUTCHours(),
-      minutes: d.getUTCMinutes(),
-      seconds: d.getUTCSeconds(),
-      milliseconds: d.getUTCMilliseconds()
-    };
-  }
-  /**
-   * @returns true if the instant is in the past, false otherwise
-   */
-  isInThePast() {
-    return this.ms < Date.now();
-  }
-  /**
-   * @returns true if the instant is in the future, false otherwise
-   */
-  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;
-    }
-  }
-  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();
-  }
-  static fromIso8601(str) {
-    const iso8601Regex = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\.(\d{3})(Z|[+-]\d{2}:\d{2})?$/;
-    const match = str.match(iso8601Regex);
-    if (!match) {
-      throw new Error("Invalid ISO 8601 date format: " + str);
-    }
-    const [, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr, millisecondStr] = match;
-    const year = parseInt(yearStr, 10);
-    const month = parseInt(monthStr, 10);
-    const date = parseInt(dayStr, 10);
-    const hours = parseInt(hourStr, 10);
-    const minutes = parseInt(minuteStr, 10);
-    const seconds = parseInt(secondStr, 10);
-    const milliseconds = parseInt(millisecondStr, 10);
-    if (!isValidYear(year))
-      throw new Error("Invalid year in: " + str);
-    if (!isValidMonth(month))
-      throw new Error("Invalid month in: " + str);
-    if (!isValidDayOfMonth(date))
-      throw new Error("Invalid day in: " + str);
-    if (!isValidHour(hours))
-      throw new Error("Invalid hour in: " + str);
-    if (!isValidMinute(minutes))
-      throw new Error("Invalid minute in: " + str);
-    if (!isValidSecond(seconds))
-      throw new Error("Invalid second in: " + str);
-    if (!isValidMillisecond(milliseconds))
-      throw new Error("Invalid millisecond in: " + str);
-    return _TimeInstant.fromParameters({
-      year,
-      month,
-      date,
-      hours,
-      minutes,
-      seconds,
-      milliseconds
-    });
-  }
-  /**
-   * @deprecated [2025.10.19]: Use fromIso8601 instead.
-   */
-  static tryFromIso8601 = this.fromIso8601;
-  static now() {
-    return _TimeInstant.fromUnixTimestamp(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);
-  }
-  /**
-   * 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 dayOfWeek = date.getUTCDay() || 7;
-    const thursdayMs = this.ms + (4 - dayOfWeek) * oneDay;
-    const thursdayDate = new Date(thursdayMs);
-    const thursdayYear = thursdayDate.getUTCFullYear();
-    const firstOfJanMs = Date.UTC(thursdayYear, 0, 1, 12, 0, 0);
-    const dayOfTheYear = Math.round((thursdayMs - firstOfJanMs) / oneDay);
-    const weekNumber = Math.floor(dayOfTheYear / 7) + 1;
-    return { weekNumber, year: thursdayYear };
-  }
-  /**
-   * 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;
-function isValidYear(num) {
-  return num >= 0 && num <= 9999;
-}
-function isValidMonth(num) {
-  return num >= 1 && num <= 12;
-}
-function isValidDayOfMonth(num) {
-  return num >= 1 && num <= 31;
-}
-function isValidHour(num) {
-  return num >= 0 && num <= 23;
-}
-function isValidMinute(num) {
-  return num >= 0 && num <= 59;
-}
-function isValidSecond(num) {
-  return num >= 0 && num <= 59;
-}
-function isValidMillisecond(num) {
-  return num >= 0 && num <= 999;
-}
-var monthNamesCache = /* @__PURE__ */ new Map();
-function getMonthNames(locale = "en") {
-  const cached = monthNamesCache.get(locale);
-  if (cached) {
-    return cached;
-  }
-  const shortFormatter = new Intl.DateTimeFormat(locale, { month: "short" });
-  const longFormatter = new Intl.DateTimeFormat(locale, { month: "long" });
-  const short = [];
-  const long = [];
-  for (let month = 0; month < 12; month++) {
-    const date = new Date(2e3, month, 1);
-    short.push(normalizeMonthName(shortFormatter.format(date)));
-    long.push(normalizeMonthName(longFormatter.format(date)));
-  }
-  const result = { short, long };
-  monthNamesCache.set(locale, result);
-  return result;
-}
-function normalizeMonthName(name) {
-  return name.replace(/[.,;:!?]/g, "").normalize("NFD").replace(/[\u0300-\u036f]/g, "").trim();
-}
-var PATTERN_REGEX = /(M|y|d|D|h|H|m|s|S|G|Z|P|a)+/g;
-var ESCAPE_REGEX = /\\"|"((?:\\"|[^"])*)"/g;
-var formatterConfigs = {
-  // Year
-  "y": { options: { year: "numeric" } },
-  "yy": { options: { year: "2-digit" } },
-  "yyyy": { options: { year: "numeric" } },
-  // Month
-  "M": { options: { month: "numeric" } },
-  "MM": { options: { month: "2-digit" } },
-  "MMM": { options: { month: "short" } },
-  "MMMM": { options: { month: "long" } },
-  // Day
-  "d": { options: { day: "numeric" } },
-  "dd": { options: { day: "2-digit" } },
-  // Hours (24-hour) - extract and pad manually due to Intl quirk
-  "H": { options: { hour: "numeric", hour12: false }, extract: { partType: "hour" } },
-  "HH": { options: { hour: "2-digit", hour12: false }, extract: { partType: "hour", transform: (v) => v.padStart(2, "0") } },
-  // Hours (12-hour) - extract and pad manually due to Intl quirk
-  "h": { options: { hour: "numeric", hour12: true }, extract: { partType: "hour" } },
-  "hh": { options: { hour: "2-digit", hour12: true }, extract: { partType: "hour", transform: (v) => v.padStart(2, "0") } },
-  // Minutes - extract and pad manually due to Intl quirk
-  "m": { options: { minute: "numeric" }, extract: { partType: "minute" } },
-  "mm": { options: { minute: "2-digit" }, extract: { partType: "minute", transform: (v) => v.padStart(2, "0") } },
-  // Seconds - extract and pad manually due to Intl quirk
-  "s": { options: { second: "numeric" }, extract: { partType: "second" } },
-  "ss": { options: { second: "2-digit" }, extract: { partType: "second", transform: (v) => v.padStart(2, "0") } },
-  // Milliseconds - extract manually
-  "S": { options: { fractionalSecondDigits: 1 }, extract: { partType: "fractionalSecond" } },
-  "SS": { options: { fractionalSecondDigits: 2 }, extract: { partType: "fractionalSecond" } },
-  "SSS": { options: { fractionalSecondDigits: 3 }, extract: { partType: "fractionalSecond" } },
-  // Weekday
-  "D": { options: { weekday: "narrow" } },
-  "DD": { options: { weekday: "short" } },
-  "DDD": { options: { weekday: "long" } },
-  // Era
-  "G": { options: { era: "narrow" } },
-  "GG": { options: { era: "short" } },
-  "GGG": { options: { era: "long" } },
-  // Timezone
-  "Z": { options: { timeZoneName: "short" } },
-  "ZZ": { options: { timeZoneName: "long" } },
-  // Day period
-  "P": { options: { dayPeriod: "narrow" } },
-  "PP": { options: { dayPeriod: "short" } },
-  "PPP": { options: { dayPeriod: "long" } },
-  // Meridiem - extract dayPeriod and lowercase it
-  "a": { options: { hour: "numeric", hour12: true }, extract: { partType: "dayPeriod", transform: (v) => v.toLowerCase() } }
-};
-function formatType(type, length, date, locale = "en", timeZone = "UTC") {
-  const tokenKey = type.repeat(length);
-  const config = formatterConfigs[tokenKey];
-  if (!config) {
-    return void 0;
-  }
-  const formatter = new Intl.DateTimeFormat(locale, { ...config.options, timeZone });
-  if (config.extract) {
-    const part = formatter.formatToParts(date).find((p) => p.type === config.extract.partType);
-    const value = part?.value;
-    if (!value) {
-      return void 0;
-    }
-    return config.extract.transform ? config.extract.transform(value) : value;
-  }
-  return formatter.format(date);
-}
-function formatTimeInstant(instant, pattern, config = {}) {
-  const date = instant.toDate();
-  const locale = config.locale || "en";
-  const timeZone = config.timeZone || "UTC";
-  return pattern.split(ESCAPE_REGEX).filter((sub) => sub !== void 0).map((sub, index) => {
-    if (index % 2 !== 0) {
-      return sub;
-    }
-    return sub.replace(PATTERN_REGEX, (match) => {
-      const type = match.charAt(0);
-      const length = match.length;
-      return formatType(type, length, date, locale, timeZone) || match;
-    });
-  }).join("");
-}
-function parseTimeInstant(dateString, pattern, base, config = {}) {
-  const parsed = parseTimeInstantComponents(dateString, pattern, config);
-  const params = {
-    ...base.toParameters(),
-    ...parsed
-  };
-  return TimeInstant.fromParameters(params);
-}
-function parseTimeInstantComponents(dateString, pattern, config = {}) {
-  let regexPattern = pattern;
-  const tokens = [];
-  let position = 0;
-  const parts = pattern.split(ESCAPE_REGEX).filter((sub) => sub !== void 0);
-  regexPattern = parts.map((sub, index) => {
-    if (index % 2 !== 0) {
-      return sub.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    }
-    return sub.replace(PATTERN_REGEX, (match) => {
-      const type = match.charAt(0);
-      tokens.push({ type, length: match.length, position: position++ });
-      switch (type) {
-        case "y":
-          return match.length === 2 ? "(\\d{2})" : "(\\d{4})";
-        case "M":
-          if (match.length === 1) return "(\\d{1,2})";
-          if (match.length === 2) return "(\\d{2})";
-          if (match.length === 3) return "([A-Za-z.]{1,7})";
-          return "([A-Za-z]+)";
-        case "d":
-          return match.length === 1 ? "(\\d{1,2})" : "(\\d{2})";
-        case "H":
-        case "h":
-          return match.length === 1 ? "(\\d{1,2})" : "(\\d{2})";
-        case "m":
-        case "s":
-          return match.length === 1 ? "(\\d{1,2})" : "(\\d{2})";
-        case "S":
-          return `(\\d{${match.length}})`;
-        case "a":
-          return "([aApP][mM])";
-        case "D":
-          if (match.length === 1) return "([A-Za-z])";
-          if (match.length === 2) return "([A-Za-z]{3})";
-          return "([A-Za-z]+)";
-        case "G":
-          if (match.length === 1) return "([A-Za-z])";
-          if (match.length === 2) return "([A-Za-z]{2})";
-          return "([A-Za-z\\s]+)";
-        case "Z":
-          return match.length === 1 ? "([A-Za-z0-9+\\-:]+)" : "([A-Za-z\\s]+)";
-        case "P":
-          return "([A-Za-z\\s]+)";
-        default:
-          return match;
-      }
-    });
-  }).join("");
-  const regex = new RegExp("^" + regexPattern + "$");
-  const matches = dateString.match(regex);
-  if (!matches) {
-    throw new Error(`Date string "${dateString}" does not match pattern "${pattern}"`);
-  }
-  const result = {};
-  const locale = config.locale || "en";
-  let isPM = false;
-  let is12Hour = false;
-  let hourValue;
-  tokens.forEach((token, index) => {
-    const value = matches[index + 1];
-    switch (token.type) {
-      case "y":
-        if (token.length === 2) {
-          const shortYear = parseInt(value, 10);
-          result.year = shortYear < 50 ? 2e3 + shortYear : 1900 + shortYear;
-        } else {
-          result.year = parseInt(value, 10);
-        }
-        break;
-      case "M":
-        switch (token.length) {
-          case 1:
-          case 2:
-            result.month = parseInt(value, 10);
-            break;
-          case 3: {
-            const normalizedValue = normalizeMonthName(value);
-            const monthIndex = getMonthNames(locale).short.findIndex(
-              (name) => name.toLowerCase() === normalizedValue.toLowerCase()
-            );
-            if (monthIndex === -1)
-              throw new Error(`Invalid short month name in date string: ${dateString}`);
-            result.month = monthIndex + 1;
-            break;
-          }
-          case 4: {
-            const normalizedValue = normalizeMonthName(value);
-            const monthIndex = getMonthNames(locale).long.findIndex(
-              (name) => name.toLowerCase() === normalizedValue.toLowerCase()
-            );
-            if (monthIndex === -1)
-              throw new Error(`Invalid full month name in date string: ${dateString}`);
-            result.month = monthIndex + 1;
-            break;
-          }
-          default:
-            throw new Error(`Invalid month pattern: ${token}`);
-        }
-        break;
-      case "d":
-        result.date = parseInt(value, 10);
-        break;
-      case "H":
-        result.hours = parseInt(value, 10);
-        break;
-      case "h":
-        hourValue = parseInt(value, 10);
-        is12Hour = true;
-        break;
-      case "m":
-        result.minutes = parseInt(value, 10);
-        break;
-      case "s":
-        result.seconds = parseInt(value, 10);
-        break;
-      case "S":
-        let ms = parseInt(value, 10);
-        if (token.length === 1) ms *= 100;
-        else if (token.length === 2) ms *= 10;
-        result.milliseconds = ms;
-        break;
-      case "a":
-        isPM = value.toLowerCase().includes("p");
-        break;
-    }
-  });
-  if (is12Hour && hourValue !== void 0) {
-    if (isPM && hourValue < 12) {
-      result.hours = hourValue + 12;
-    } else if (!isPM && hourValue === 12) {
-      result.hours = 0;
-    } else {
-      result.hours = hourValue;
-    }
-  }
-  if (typeof result.year === "number" && !isValidYear(result.year)) {
-    throw new Error(`Invalid year in date string: ${dateString}`);
-  }
-  if (typeof result.month === "number" && !isValidMonth(result.month)) {
-    throw new Error(`Invalid month in date string: ${dateString}`);
-  }
-  if (typeof result.date === "number" && !isValidDayOfMonth(result.date)) {
-    throw new Error(`Invalid day in date string: ${dateString}`);
-  }
-  if (typeof result.hours === "number" && !isValidHour(result.hours)) {
-    throw new Error(`Invalid hour in date string: ${dateString}`);
-  }
-  if (typeof result.minutes === "number" && !isValidMinute(result.minutes)) {
-    throw new Error(`Invalid minute in date string: ${dateString}`);
-  }
-  if (typeof result.seconds === "number" && !isValidSecond(result.seconds)) {
-    throw new Error(`Invalid second in date string: ${dateString}`);
-  }
-  if (typeof result.milliseconds === "number" && !isValidMillisecond(result.milliseconds)) {
-    throw new Error(`Invalid millisecond in date string: ${dateString}`);
-  }
-  return result;
-}
-
-// src/Logger.ts
-var LEVELS = ["trace", "log", "debug", "info", "warn", "error"];
-var timestamp = () => TimeInstant_default.now().format("HH:mm:ss");
-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 trace() {
-    return this.logWrap("trace");
-  }
-  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.enabled || !this.console || LEVELS.indexOf(methodName) < this.minLevel)
-      return noop;
-    return this.console[methodName].bind(this.console, timestamp(), padRight(methodName.toUpperCase(), 5, " "), this.name);
-  }
-};
-
-// src/sorting/Sorter.ts
-var defaultCompareValuesOptions = {
-  nullsFirst: false
-};
-var defaultCompareFunctionOptions = {
-  ...defaultCompareValuesOptions,
-  direction: "ASC"
-};
-var naturalOrderComparison = (a, b) => a < b ? -1 : 1;
-function compareValues(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 compareFunction(fn, cmp, { nullsFirst, direction }) {
-  return (a, b) => applyDirection(compareValues(fn(a), fn(b), cmp, { nullsFirst }), direction);
-}
-function applyDirection(res, direction) {
-  return res * (direction === "ASC" ? 1 : -1);
-}
-function combine(f, g) {
-  return (t) => g(f(t));
-}
-function reverse2(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 compareStrings = (fns, transform, options = {}) => {
-  const { nullsFirst, direction, ignoreCase } = { ...defaultStringComparisonOptions, ...options };
-  if (ignoreCase)
-    transform = combine(transform, (t) => t.toLowerCase());
-  return chain(fns, compareFunction(transform, naturalOrderComparison, { nullsFirst, direction }));
-};
-var compareNumbers = (fns, transform, options = {}) => {
-  const { nullsFirst, direction } = { ...defaultNumberComparisonOptions, ...options };
-  return chain(fns, compareFunction(transform, naturalOrderComparison, { nullsFirst, direction }));
-};
-var compareDates = (fns, transform, options = {}) => {
-  const { nullsFirst, direction } = { ...defaultDateComparisonOptions, ...options };
-  return chain(fns, compareFunction(transform, naturalOrderComparison, { nullsFirst, direction }));
-};
-var compareTimeInstants = (fns, transform, options = {}) => {
-  const { nullsFirst, direction } = { ...defaultTimeInstantComparisonOptions, ...options };
-  return chain(fns, compareFunction(transform, (a, b) => a.isBefore(b) ? -1 : 1, { nullsFirst, direction }));
-};
-var compareTimeDurations = (fns, transform, options = {}) => {
-  const { nullsFirst, direction } = { ...defaultTimeDurationComparisonOptions, ...options };
-  return chain(fns, compareFunction(transform, (a, b) => a.isLessThan(b) ? -1 : 1, { nullsFirst, direction }));
-};
-var compareBooleans = (fns, transform, options) => {
-  const { nullsFirst, truesFirst } = { ...defaultBooleanComparisonOptions, ...options };
-  return chain(fns, compareFunction(transform, naturalOrderComparison, { nullsFirst, direction: truesFirst ? "DESC" : "ASC" }));
-};
-var prioritizeSet = (fns, transform, set, reversed = false) => {
-  return compareBooleans(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);
-    },
-    chainFunction(fn) {
-      return transformAndChain(fns, transform, fn);
-    }
-  };
-  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]),
-    usingTimeInstant: (field) => using((t) => t[field]),
-    usingTimeDuration: (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 retForStringsV1 = {
-    ...retAsUsing,
-    inLexographicalOrder(opts = {}) {
-      return compareStrings(fns, transform, { direction: "ASC", ignoreCase: false, ...opts });
-    },
-    inLexographicalOrderIgnoringCase(opts = {}) {
-      return compareStrings(fns, transform, { direction: "ASC", ignoreCase: true, ...opts });
-    },
-    inReverseLexographicalOrder(opts = {}) {
-      return compareStrings(fns, transform, { direction: "DESC", ignoreCase: false, ...opts });
-    },
-    inReverseLexographicalOrderIgnoringCase(opts = {}) {
-      return compareStrings(fns, transform, { direction: "DESC", ignoreCase: true, ...opts });
-    }
-  };
-  const retForStrings = {
-    ...retAsUsing,
-    ...retForStringsV1,
-    inLexicographicalOrder(opts = {}) {
-      return compareStrings(fns, transform, { direction: "ASC", ignoreCase: false, ...opts });
-    },
-    inLexicographicalOrderIgnoringCase(opts = {}) {
-      return compareStrings(fns, transform, { direction: "ASC", ignoreCase: true, ...opts });
-    },
-    inReverseLexicographicalOrder(opts = {}) {
-      return compareStrings(fns, transform, { direction: "DESC", ignoreCase: false, ...opts });
-    },
-    inReverseLexicographicalOrderIgnoringCase(opts = {}) {
-      return compareStrings(fns, transform, { direction: "DESC", ignoreCase: true, ...opts });
-    }
-  };
-  const retForBooleans = {
-    ...retAsUsing,
-    truesFirst(opts = {}) {
-      return compareBooleans(fns, transform, { truesFirst: true, ...opts });
-    },
-    falsesFirst(opts = {}) {
-      return compareBooleans(fns, transform, { truesFirst: false, ...opts });
-    }
-  };
-  const retForDates = {
-    ...retAsUsing,
-    oldestDateFirst(opts = {}) {
-      return compareDates(fns, transform, { direction: "ASC", ...opts });
-    },
-    newestDateFirst(opts = {}) {
-      return compareDates(fns, transform, { direction: "DESC", ...opts });
-    }
-  };
-  const retForInstants = {
-    ...retAsUsing,
-    oldestFirst(opts = {}) {
-      return compareTimeInstants(fns, transform, { direction: "ASC", ...opts });
-    },
-    newestFirst(opts = {}) {
-      return compareTimeInstants(fns, transform, { direction: "DESC", ...opts });
-    }
-  };
-  const retForDurations = {
-    ...retAsUsing,
-    longestFirst(opts = {}) {
-      return compareTimeDurations(fns, transform, { direction: "DESC", ...opts });
-    },
-    shortestFirst(opts = {}) {
-      return compareTimeDurations(fns, transform, { direction: "ASC", ...opts });
-    }
-  };
-  return {
-    ...retAsPrioritizable,
-    ...retAsChainable,
-    ...retForRecords,
-    ...retForNumbers,
-    ...retForStrings,
-    ...retForBooleans,
-    ...retForDates,
-    ...retForInstants,
-    ...retForDurations
-  };
-};
-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() {
-  const base = next([], (x) => x);
-  const ret = {
-    ...base,
-    usingFunction(fn) {
-      return doCreateWithFunctions([fn]);
-    }
-  };
-  return ret;
-}
-function doCreateWithFunctions(fns) {
-  return {
-    get then() {
-      return next(fns, identity);
-    },
-    reversed() {
-      return doCreateWithFunctions([...fns.map(reverse2)]);
-    },
-    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 defaultTimeInstantComparisonOptions = { ...defaultCompareFunctionOptions };
-var defaultTimeDurationComparisonOptions = { ...defaultCompareFunctionOptions };
-var defaultBooleanComparisonOptions = { ...defaultCompareValuesOptions };
-var Sorter = {
-  createFor: (_template) => 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)
-};
-
-// src/time/RandomTimeDuration.ts
-function randomize(unit) {
-  return (a, b) => {
-    return TimeDuration_default.fromMs(randomNumberInInterval(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 = {
-  DataUpgrader,
-  Deferred,
-  DeferredCanceledError,
-  ErrorCannotInstantiatePresentOptionalWithEmptyValue,
-  ErrorGetEmptyOptional,
-  ErrorSetEmptyOptional,
-  Lazy,
-  LazyAsync,
-  LazyDictionary,
-  Logger,
-  NEVER,
-  NonExhaustiveSwitchError,
-  Operation,
-  Optional,
-  PredicateBuilder,
-  RandomTimeDuration,
-  RateThrottler,
-  Semaphore,
-  Sorter,
-  StringParts,
-  TimeDuration,
-  TimeFrequency,
-  TimeInstant,
-  TimeRange,
-  TimeUnit,
-  TimeoutError,
-  alwaysFalse,
-  alwaysTrue,
-  and,
-  arrayGet,
-  asError,
-  asPromise,
-  average,
-  awaitAtMost,
-  capitalizeWord,
-  clamp,
-  clampInt0_100,
-  constant,
-  constantFalse,
-  constantNull,
-  constantOne,
-  constantTrue,
-  constantUndefined,
-  constantZero,
-  cssDeclarationRulesDictionaryToCss,
-  decrement,
-  decrementBy,
-  delayPromise,
-  dictToEntries,
-  dictToList,
-  divideBy,
-  ellipsis,
-  ensureArray,
-  ensureDefined,
-  ensureNegativeNumber,
-  ensureNonNegativeNumber,
-  ensureNonPositiveNumber,
-  ensurePositiveNumber,
-  ensureReadableArray,
-  entriesToDict,
-  entriesToEntries,
-  entriesToList,
-  extendArray,
-  extendArrayWith,
-  fill,
-  filterMap,
-  filterMapReduce,
-  filterWithTypePredicate,
-  findInArray,
-  findIndexInArray,
-  first,
-  flatMapTruthys,
-  getCauseMessageFromError,
-  getCauseStackFromError,
-  getMessageFromError,
-  getStackFromError,
-  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,
-  isEmpty,
-  isError,
-  isFalse,
-  isFunction,
-  isNegativeNumber,
-  isNullOrUndefined,
-  isNullOrUndefinedOrEmpty,
-  isNumber,
-  isPositiveNumber,
-  isString,
-  isTimeInstant,
-  isTrue,
-  isUpgradable,
-  isZero,
-  jsonCloneDeep,
-  last,
-  listToDict,
-  mapDefined,
-  mapEntries,
-  mapFirstTruthy,
-  mapTruthys,
-  max,
-  maxBy,
-  min,
-  minBy,
-  multiplyBy,
-  noop,
-  not,
-  omitFromJsonObject,
-  or,
-  pad,
-  padLeft,
-  padRight,
-  parseJson,
-  partition,
-  pick,
-  pipedInvoke,
-  pipedInvokeFromArray,
-  pluralize,
-  promiseSequence,
-  randomId,
-  randomNumberInInterval,
-  range,
-  repeat,
-  reverse,
-  round,
-  roundAwayFromZero,
-  roundToLower,
-  roundToNearest,
-  roundToUpper,
-  roundTowardsZero,
-  shallowArrayEquals,
-  shallowRecordEquals,
-  sortedArray,
-  splitWords,
-  stringToNumber,
-  stringifyJson,
-  sum,
-  sumBy,
-  tail,
-  throttle,
-  throwIfNullOrUndefined,
-  transformCssDictionary,
-  tryToParseJson,
-  tryToParseNumber,
-  uniq,
-  uniqBy,
-  uniqByKey,
-  unzip,
-  upsert,
-  withTryCatch,
-  withTryCatchAsync,
-  wrapWithString,
-  xor,
-  zip
-});
-//# sourceMappingURL=index.cjs.map