@zelgadis87/utils-core 4.1.0 → 4.2.0

package/esbuild/index.mjs

@@ -1,3 +1,167 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/small-date@2.0.1/node_modules/small-date/lib/format.js
+var require_format = __commonJS({
+  "../../node_modules/.pnpm/small-date@2.0.1/node_modules/small-date/lib/format.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = format2;
+    function ownKeys(object, enumerableOnly) {
+      var keys = Object.keys(object);
+      if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+          symbols = symbols.filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+          });
+        }
+        keys.push.apply(keys, symbols);
+      }
+      return keys;
+    }
+    function _objectSpread(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i] != null ? arguments[i] : {};
+        if (i % 2) {
+          ownKeys(Object(source), true).forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+          });
+        } else if (Object.getOwnPropertyDescriptors) {
+          Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+        } else {
+          ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+          });
+        }
+      }
+      return target;
+    }
+    function _defineProperty(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    var PATTERN_REGEX = /(M|y|d|D|h|H|m|s|S|G|Z|P|a)+/g;
+    var ESCAPE_REGEX = /\\"|"((?:\\"|[^"])*)"|(\+)/g;
+    var optionNames = {
+      y: "year",
+      M: "month",
+      d: "day",
+      D: "weekday",
+      S: "fractionalSecondDigits",
+      G: "era",
+      Z: "timeZoneName",
+      P: "dayPeriod",
+      a: "hour12",
+      h: "hour",
+      H: "hour",
+      m: "minute",
+      s: "second"
+    };
+    var values = {
+      y: ["numeric", "2-digit", void 0, "numeric"],
+      M: ["narrow", "2-digit", "short", "long"],
+      d: ["numeric", "2-digit"],
+      D: ["narrow", "short", "long"],
+      S: [1, 2, 3],
+      G: ["narrow", "short", "long"],
+      Z: ["short", "long"],
+      P: ["narrow", "short", "long"],
+      a: [true],
+      h: ["numeric", "2-digit"],
+      H: ["numeric", "2-digit"],
+      m: ["numeric", "2-digit"],
+      s: ["numeric", "2-digit"]
+    };
+    function padIf(condition, value, length) {
+      return condition && length === 2 && value / 10 < 1 ? "0" + value : value;
+    }
+    function formatType(date, type, length) {
+      var _options;
+      var _ref = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {}, locale = _ref.locale, timeZone = _ref.timeZone;
+      var option = optionNames[type];
+      var value = values[type][length - 1];
+      if (!value) {
+        return;
+      }
+      var options = (_options = {}, _defineProperty(_options, option, value), _defineProperty(_options, "timeZone", timeZone), _options);
+      if (type === "a") {
+        return Intl.DateTimeFormat(locale, _objectSpread(_objectSpread({}, options), {}, {
+          hour: "numeric"
+        })).formatToParts(date).pop().value;
+      }
+      if (type === "G" || type === "Z") {
+        return Intl.DateTimeFormat(locale, options).formatToParts(date).pop().value;
+      }
+      if (type === "H" || type === "h") {
+        return Intl.DateTimeFormat("en-GB", _objectSpread(_objectSpread({}, options), {}, {
+          hourCycle: type === "H" ? "h23" : "h11"
+        })).format(date).toLocaleLowerCase().replace(" am", "").replace(" pm", "");
+      }
+      return padIf(["m", "s"].includes(type) && value === "2-digit", Intl.DateTimeFormat(locale, options).format(date), 2);
+    }
+    function format2(date, pattern, config) {
+      return pattern.split(ESCAPE_REGEX).filter(function(sub) {
+        return sub !== void 0;
+      }).map(function(sub, index) {
+        if (index % 2 !== 0) {
+          return sub;
+        }
+        return sub.replace(PATTERN_REGEX, function(match) {
+          var type = match.charAt(0);
+          return formatType(date, type, match.length, config) || match;
+        });
+      }).join("");
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/small-date@2.0.1/node_modules/small-date/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/.pnpm/small-date@2.0.1/node_modules/small-date/lib/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.format = void 0;
+    var _format = require_format();
+    var _format2 = _interopRequireDefault(_format);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    exports.format = _format2["default"];
+  }
+});
+
 // src/types/arrays.ts
 function ensureArray(t) {
   return t instanceof Array ? t : [t];
@@ -85,6 +249,16 @@ function isFunction(t) {
   return typeof t === "function";
 }
 
+// src/types/json.ts
+function tryToParseJson(jsonContent) {
+  try {
+    const data = JSON.parse(jsonContent);
+    return [data, null];
+  } catch (err) {
+    return [null, asError(err)];
+  }
+}
+
 // src/types/nulls.ts
 function ensureDefined(v, name = "value") {
   if (isDefined(v))
@@ -431,8 +605,132 @@ var LazyAsync = class _LazyAsync {
   }
 };
 
+// src/time/TimeInstant.ts
+var import_small_date = __toESM(require_lib());
+
+// src/time/TimeUnit.ts
+var TimeUnit = class _TimeUnit {
+  constructor(multiplier) {
+    this.multiplier = multiplier;
+  }
+  toUnit(value, unit) {
+    return value * (this.multiplier / unit.multiplier);
+  }
+  toMs(value) {
+    return this.toUnit(value, _TimeUnit.MILLISECONDS);
+  }
+  toSeconds(value) {
+    return this.toUnit(value, _TimeUnit.SECONDS);
+  }
+  toMinutes(value) {
+    return this.toUnit(value, _TimeUnit.MINUTES);
+  }
+  toHours(value) {
+    return this.toUnit(value, _TimeUnit.HOURS);
+  }
+  toDays(value) {
+    return this.toUnit(value, _TimeUnit.DAYS);
+  }
+  toWeeks(value) {
+    return this.toUnit(value, _TimeUnit.WEEKS);
+  }
+  static MILLISECONDS = new _TimeUnit(1);
+  static SECONDS = new _TimeUnit(1e3 * _TimeUnit.MILLISECONDS.multiplier);
+  static MINUTES = new _TimeUnit(60 * _TimeUnit.SECONDS.multiplier);
+  static HOURS = new _TimeUnit(60 * _TimeUnit.MINUTES.multiplier);
+  static DAYS = new _TimeUnit(24 * _TimeUnit.HOURS.multiplier);
+  static WEEKS = new _TimeUnit(7 * _TimeUnit.DAYS.multiplier);
+};
+
+// src/time/TimeBase.ts
+var TimeBase = class {
+  _ms;
+  constructor(value, unit) {
+    this._ms = unit.toMs(value);
+  }
+  get ms() {
+    return Math.floor(this._ms / TimeUnit.MILLISECONDS.multiplier);
+  }
+  get seconds() {
+    return Math.floor(this._ms / TimeUnit.SECONDS.multiplier);
+  }
+  get minutes() {
+    return Math.floor(this._ms / TimeUnit.MINUTES.multiplier);
+  }
+  get hours() {
+    return Math.floor(this._ms / TimeUnit.HOURS.multiplier);
+  }
+  get days() {
+    return Math.floor(this._ms / TimeUnit.DAYS.multiplier);
+  }
+  addMs(milliseconds) {
+    return this.addUnits(milliseconds, TimeUnit.MILLISECONDS);
+  }
+  addSeconds(seconds) {
+    return this.addUnits(seconds, TimeUnit.SECONDS);
+  }
+  addMinutes(minutes) {
+    return this.addUnits(minutes, TimeUnit.MINUTES);
+  }
+  addHours(hours) {
+    return this.addUnits(hours, TimeUnit.HOURS);
+  }
+  addDays(days) {
+    return this.addUnits(days, TimeUnit.DAYS);
+  }
+  removeDays(days) {
+    return this.removeUnits(days, TimeUnit.DAYS);
+  }
+  addUnits(n, unit) {
+    return this.create(this._ms + unit.toMs(n), TimeUnit.MILLISECONDS);
+  }
+  removeMs(milliseconds) {
+    return this.addUnits(-milliseconds, TimeUnit.MILLISECONDS);
+  }
+  removeSeconds(seconds) {
+    return this.addUnits(-seconds, TimeUnit.SECONDS);
+  }
+  removeMinutes(minutes) {
+    return this.addUnits(-minutes, TimeUnit.MINUTES);
+  }
+  removeHours(hours) {
+    return this.addUnits(-hours, TimeUnit.HOURS);
+  }
+  removeUnits(n, unit) {
+    return this.addUnits(-n, unit);
+  }
+  getUnit(unit) {
+    return this._ms / unit.multiplier;
+  }
+  toUnits() {
+    return {
+      days: Math.floor(this._ms / TimeUnit.DAYS.multiplier),
+      hours: Math.floor(this._ms / TimeUnit.HOURS.multiplier % 24),
+      minutes: Math.floor(this._ms / TimeUnit.MINUTES.multiplier % 60),
+      seconds: Math.floor(this._ms / TimeUnit.SECONDS.multiplier % 60)
+    };
+  }
+  static toMs(units) {
+    if (!units)
+      throw new Error("Invalid units given");
+    let ms = 0;
+    ms += units.ms ?? 0 * TimeUnit.MILLISECONDS.multiplier;
+    ms += (units.seconds ?? 0) * TimeUnit.SECONDS.multiplier;
+    ms += (units.minutes ?? 0) * TimeUnit.MINUTES.multiplier;
+    ms += (units.hours ?? 0) * TimeUnit.HOURS.multiplier;
+    ms += (units.days ?? 0) * TimeUnit.DAYS.multiplier;
+    return ms;
+  }
+  toJSON() {
+    return this._ms;
+  }
+};
+
 // src/async/Deferred.ts
 var DeferredCanceledError = class extends Error {
+  constructor() {
+    super("Execution canceled");
+  }
 };
 var Deferred = class {
   _pending;
@@ -449,15 +747,37 @@ var Deferred = class {
     this._internals = this.createInternals();
   }
   resolve(val) {
-    if (!this._pending) throw new Error("Illegal state exception");
+    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);
   }
-  reject(reason) {
-    if (!this._pending) throw new Error("Illegal state exception");
+  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);
   }
@@ -467,10 +787,6 @@ var Deferred = class {
   finally(onfinally) {
     return this._internals.promise.finally(onfinally);
   }
-  cancel() {
-    if (!this._pending) throw new Error("Illegal state exception");
-    this._internals.reject(new DeferredCanceledError("Execution aborted by the user"));
-  }
   get asPromise() {
     return this;
   }
@@ -495,6 +811,16 @@ var Deferred = class {
 };
 var Deferred_default = Deferred;
 
+// src/random/randomInterval.ts
+function randomInterval(min2, max2) {
+  return Math.floor(Math.random() * (max2 - min2 + 1) + min2);
+}
+
+// src/random/randomPercentage.ts
+function randomPercentage(min2, max2) {
+  return randomInterval(min2, max2) / 100;
+}
+
 // src/utils/bindThis.ts
 function bindThis(fn, _this) {
   return fn.bind(_this);
@@ -775,25 +1101,28 @@ var RateThrottler = class {
 var Semaphore = class {
   constructor(_availableSlots = 1) {
     this._availableSlots = _availableSlots;
-    this._waitingRequests = [];
+    this._queuedRequests = [];
   }
-  _waitingRequests;
+  _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._waitingRequests.push(deferred);
+      this._queuedRequests.push(deferred);
       return deferred.asPromise;
     }
   }
   _releaseSlot() {
-    const waitingSlotToResolve = this._waitingRequests.shift();
+    const waitingSlotToResolve = this._queuedRequests.shift();
     if (waitingSlotToResolve) {
       waitingSlotToResolve.resolve();
     } else {
       this._availableSlots += 1;
+      this._inProgress -= 1;
     }
   }
   async execute(fn, cooldown = TimeDuration.ZERO) {
@@ -801,6 +1130,15 @@ var Semaphore = class {
       void cooldown.promise().then(() => this._releaseSlot());
     });
   }
+  get availableSlots() {
+    return this._availableSlots;
+  }
+  get queueSize() {
+    return this._queuedRequests.length;
+  }
+  get inProgressSize() {
+    return this._inProgress;
+  }
 };
 
 // src/utils/throttle.ts
@@ -855,134 +1193,6 @@ function wrap(str, delimiter) {
   return delimiter + str + delimiter;
 }
 
-// src/time/TimeUnit.ts
-var TimeUnit = class _TimeUnit {
-  constructor(multiplier) {
-    this.multiplier = multiplier;
-  }
-  toUnit(value, unit) {
-    return value * (this.multiplier / unit.multiplier);
-  }
-  toMs(value) {
-    return this.toUnit(value, _TimeUnit.MILLISECONDS);
-  }
-  toSeconds(value) {
-    return this.toUnit(value, _TimeUnit.SECONDS);
-  }
-  toMinutes(value) {
-    return this.toUnit(value, _TimeUnit.MINUTES);
-  }
-  toHours(value) {
-    return this.toUnit(value, _TimeUnit.HOURS);
-  }
-  toDays(value) {
-    return this.toUnit(value, _TimeUnit.DAYS);
-  }
-  toWeeks(value) {
-    return this.toUnit(value, _TimeUnit.WEEKS);
-  }
-  static MILLISECONDS = new _TimeUnit(1);
-  static SECONDS = new _TimeUnit(1e3 * _TimeUnit.MILLISECONDS.multiplier);
-  static MINUTES = new _TimeUnit(60 * _TimeUnit.SECONDS.multiplier);
-  static HOURS = new _TimeUnit(60 * _TimeUnit.MINUTES.multiplier);
-  static DAYS = new _TimeUnit(24 * _TimeUnit.HOURS.multiplier);
-  static WEEKS = new _TimeUnit(7 * _TimeUnit.DAYS.multiplier);
-};
-
-// src/time/TimeBase.ts
-var TimeBase = class {
-  _ms;
-  constructor(value, unit) {
-    this._ms = unit.toMs(value);
-  }
-  get ms() {
-    return Math.floor(this._ms / TimeUnit.MILLISECONDS.multiplier);
-  }
-  get seconds() {
-    return Math.floor(this._ms / TimeUnit.SECONDS.multiplier);
-  }
-  get minutes() {
-    return Math.floor(this._ms / TimeUnit.MINUTES.multiplier);
-  }
-  get hours() {
-    return Math.floor(this._ms / TimeUnit.HOURS.multiplier);
-  }
-  get days() {
-    return Math.floor(this._ms / TimeUnit.DAYS.multiplier);
-  }
-  addMs(milliseconds) {
-    return this.addUnits(milliseconds, TimeUnit.MILLISECONDS);
-  }
-  addSeconds(seconds) {
-    return this.addUnits(seconds, TimeUnit.SECONDS);
-  }
-  addMinutes(minutes) {
-    return this.addUnits(minutes, TimeUnit.MINUTES);
-  }
-  addHours(hours) {
-    return this.addUnits(hours, TimeUnit.HOURS);
-  }
-  addDays(days) {
-    return this.addUnits(days, TimeUnit.DAYS);
-  }
-  removeDays(days) {
-    return this.removeUnits(days, TimeUnit.DAYS);
-  }
-  addUnits(n, unit) {
-    return this.create(this._ms + unit.toMs(n), TimeUnit.MILLISECONDS);
-  }
-  removeMs(milliseconds) {
-    return this.addUnits(-milliseconds, TimeUnit.MILLISECONDS);
-  }
-  removeSeconds(seconds) {
-    return this.addUnits(-seconds, TimeUnit.SECONDS);
-  }
-  removeMinutes(minutes) {
-    return this.addUnits(-minutes, TimeUnit.MINUTES);
-  }
-  removeHours(hours) {
-    return this.addUnits(-hours, TimeUnit.HOURS);
-  }
-  removeUnits(n, unit) {
-    return this.addUnits(-n, unit);
-  }
-  getUnit(unit) {
-    return this._ms / unit.multiplier;
-  }
-  toUnits() {
-    return {
-      days: Math.floor(this._ms / TimeUnit.DAYS.multiplier),
-      hours: Math.floor(this._ms / TimeUnit.HOURS.multiplier % 24),
-      minutes: Math.floor(this._ms / TimeUnit.MINUTES.multiplier % 60),
-      seconds: Math.floor(this._ms / TimeUnit.SECONDS.multiplier % 60)
-    };
-  }
-  static toMs(units) {
-    if (!units)
-      throw new Error("Invalid units given");
-    let ms = 0;
-    ms += units.ms ?? 0 * TimeUnit.MILLISECONDS.multiplier;
-    ms += (units.seconds ?? 0) * TimeUnit.SECONDS.multiplier;
-    ms += (units.minutes ?? 0) * TimeUnit.MINUTES.multiplier;
-    ms += (units.hours ?? 0) * TimeUnit.HOURS.multiplier;
-    ms += (units.days ?? 0) * TimeUnit.DAYS.multiplier;
-    return ms;
-  }
-  toJSON() {
-    return this._ms;
-  }
-};
-
-// src/random/randomInterval.ts
-function randomInterval(min2, max2) {
-  return Math.floor(Math.random() * (max2 - min2 + 1) + min2);
-}
-
-// src/random/randomPercentage.ts
-function randomPercentage(min2, max2) {
-  return randomInterval(min2, max2) / 100;
-}
-
 // src/time/TimeDuration.ts
 var TimeDuration = class _TimeDuration extends TimeBase {
   constructor(value, unit) {
@@ -1023,14 +1233,14 @@ var TimeDuration = class _TimeDuration extends TimeBase {
    * @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 format2 = (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");
+      return format2(units.days, "d", units.hours, "h");
     else if (units.hours >= 1)
-      return format(units.hours, "h", units.minutes, "m");
+      return format2(units.hours, "h", units.minutes, "m");
     else if (units.minutes >= 1)
-      return format(units.minutes, "m", units.seconds, "s");
+      return format2(units.minutes, "m", units.seconds, "s");
     else if (units.seconds >= 0)
       return units.seconds.toString() + "s";
     else if (units.seconds > -60)
@@ -1063,8 +1273,10 @@ var TimeDuration = class _TimeDuration extends TimeBase {
     const deferred = this.promise();
     void deferred.then(() => {
       cb();
-    }, (_err) => {
-      return;
+    }, (err) => {
+      if (err instanceof DeferredCanceledError)
+        return;
+      throw err;
     });
     return { cancel: () => deferred.cancel() };
   }
@@ -1263,7 +1475,7 @@ var timeInstantResolveValue = (getFromDate2, referenceDate, x) => {
     if (relativeTo === void 0 || relativeTo === "now") {
       return getFromDate2(referenceDate) + relative;
     } else {
-      return getFromDate2(relativeTo.asDateUTC()) + relative;
+      return getFromDate2(relativeTo.toDate()) + relative;
     }
   } else if ("absolute" in x) {
     return x.absolute;
@@ -1282,7 +1494,7 @@ var getFromDate = {
 };
 var toReferenceDate = (x) => {
   ensureDefined(x);
-  if (isTimeInstant(x)) return x.asDateUTC();
+  if (isTimeInstant(x)) return x.toDate();
   return x;
 };
 function createTimeInstantFromParameters(aParameters, aReferenceDate = TimeInstant.now()) {
@@ -1302,7 +1514,7 @@ function createTimeInstantFromParameters(aParameters, aReferenceDate = TimeInsta
   return TimeInstant.fromUnixTimestamp(timestamp2);
 }
 function timeInstantBuilder() {
-  let referenceDate = TimeInstant.now().asDateUTC();
+  let referenceDate = TimeInstant.now().toDate();
   const value = { ...defaultTimeInstantCreationParameters };
   const ret = {
     year: (x) => {
@@ -1378,157 +1590,103 @@ var TimeInstant = class _TimeInstant extends TimeBase {
   atEndOfDay() {
     return this.atTime({ hours: 23, minutes: 59, seconds: 59, milliseconds: 999 });
   }
-  /** @deprecated[2024-10-24]: Use #promise() instead. */
-  timeout(cb) {
-    if (!this.isInTheFuture) {
-      throw new Error("Instant is in the past");
-    } else {
-      return this.distanceFromNow().timeout(() => cb());
-    }
-  }
   promise() {
-    const deferred = new Deferred_default();
-    if (!this.isInTheFuture) {
-      deferred.resolve();
-    } else {
-      this.distanceFromNow().timeout(() => deferred.resolve());
-    }
-    return deferred.asCancelablePromise;
+    this.ensureInTheFuture();
+    return this.distanceFromNow().promise();
   }
   delay(cb) {
-    const deferred = this.promise();
-    void deferred.then(() => {
-      cb();
-    }, (_err) => {
-      return;
-    });
-    return { cancel: () => deferred.cancel() };
+    this.ensureInTheFuture();
+    return this.distanceFromNow().delay(cb);
+  }
+  ensureInTheFuture() {
+    if (!this.isInTheFuture)
+      throw new Error("Instant is in the past");
+  }
+  ensureInThePast() {
+    if (!this.isInThePast)
+      throw new Error("Instant is in the future");
   }
   isToday() {
     return Math.floor(this.days) === Math.floor(_TimeInstant.now().days);
   }
+  /**
+   * @returns the time as HH:mm:ss
+   * @deprecated [2024-12-11] this method is too ambigous and should be removed.
+   */
   asTimeString() {
-    const date = this.asDate();
-    return `${this.doGetTwoDigitsHours(date)}:${this.doGetTwoDigitsMinutes(date)}:${this.doGetTwoDigitsSeconds(date)}`;
+    return this.format("HH:mm:ss");
   }
+  /**
+   * @returns the date as dd/MM/yyyy
+   * @deprecated [2024-12-11] this method is too ambigous and should be removed.
+   */
   asDateString() {
-    const date = this.asDate();
-    return `${this.doGetTwoDigitsDays(date)}/${this.doGetTwoDigitsMonths(date)}/${this.doGetFourDigitsYears(date)}`;
+    return this.format("dd/MM/yyyy");
   }
   /**
-  * @returns this instant, in ISO 8601 format (eg, 2024-11-01T15:49:22.024+0200). The format is meant to always be realiable.
-  */
-  asIso8601() {
-    const dash = "-", colon = ".", doublecolon = ":", T = "T", date = this.asDate();
-    return this.doGetFourDigitsYears(date) + dash + this.doGetTwoDigitsMonths(date) + dash + this.doGetTwoDigitsDays(date) + T + this.doGetTwoDigitsHours(date) + doublecolon + this.doGetTwoDigitsMinutes(date) + doublecolon + this.doGetTwoDigitsSeconds(date) + colon + this.doGetThreeDigitsMilliseconds(date) + this.doGetFourDigitsTimezoneOffset(date);
+   * Formats this instant using the given pattern. The pattern can contain the following tokens:
+   * 
+   * | Token | Description                     | Example                       |
+   * |:------|:--------------------------------|:------------------------------|
+   * | D     | Weekday, 1 letter               | W                             |
+   * | DD    | Weekday, 3 letters              | Wed                           |
+   * | DDD   | Weekday, long                   | Wednesday                     |
+   * | d     | Day of the month, no padding    | 3                             |
+   * | dd    | Day of the month, padded to 2   | 03                            |
+   * | M     | Month, numeric                  | 3                             |
+   * | MM    | Month, 2 digits                 | 03                            |
+   * | MMM   | Month, 3 letters                | Mar                           |
+   * | MMMM  | Month, long                     | March                         |
+   * | y     | Year, numeric                   | 2021                          |
+   * | yy    | Year, 2 digits                  | 21                            |
+   * | yyyy  | Year, numeric                   | 2021                          |
+   * | h     | Hours, no padding               | 6                             |
+   * | hh    | Hours, padded to 2              | 06                            |
+   * | H     | Hours in 24-format, no padding  | 18                            |
+   * | HH    | Hours in 24-format, padded to 2 | 18                            |
+   * | m     | Minutes, no padding             | 7                             |
+   * | m     | Minutes, padded to 2            | 07                            |
+   * | s     | Seconds, no padding             | 8                             |
+   * | ss    | Seconds, padded to 2            | 08                            |
+   * | S     | Milliseconds, no padding        | 9                             |
+   * | SS    | Milliseconds, padded to 2       | 09                            |
+   * | SSS   | Milliseconds, padded to 3       | 009                           |
+   * | G     | Era, narrow                     | A                             |
+   * | GG    | Era, short                      | AD                            |
+   * | GGG   | Era, long                       | Anno Domino                   |
+   * | Z     | Time zone, short                | GMT+1                         |
+   * | ZZ    | Time short, long	C              | entral European Standard Time |
+   * | P     | Period of the day, narrow       | in the morning                |
+   * | PP    | Period of the day, short        | in the morning                |
+   * | PPP   | Period of the day, long         | in the morning                |
+   * | a     | Meridiem                        | pm                            |
+   * @param pattern The pattern to use. Refer to the token table above for details.
+   * @param config An optional locale and timeZone definition to use during the format.
+   * @returns a string, formatted using the given pattern, at the given timeZone with the given locale.
+   */
+  format(pattern, config = {}) {
+    return (0, import_small_date.format)(this.toDate(), pattern, config);
   }
   /**
-   * @returns this instant, in ISO 8601 format and UTC time zone (eg, 2024-11-01T15:49:22.024Z). The format is meant to always be realiable.
-   */
-  asIso8601UTC() {
-    const dash = "-", colon = ".", doublecolon = ":", T = "T", utcDate = this.asDateUTC();
-    return this.doGetFourDigitsYears(utcDate) + dash + this.doGetTwoDigitsMonths(utcDate) + dash + this.doGetTwoDigitsDays(utcDate) + T + this.doGetTwoDigitsHours(utcDate) + doublecolon + this.doGetTwoDigitsMinutes(utcDate) + doublecolon + this.doGetTwoDigitsSeconds(utcDate) + colon + this.doGetThreeDigitsMilliseconds(utcDate) + "Z";
+  * @returns this instant, in ISO 8601 format (eg, 2024-11-01T15:49:22.024Z). The format is meant to always be realiable.
+  */
+  asIso8601() {
+    return this.format('yyyy-MM-dd"T"HH:mm:ss.SSS"Z"', { timeZone: "UTC" });
   }
   /**
    * @returns this instant, in a human readable format. The format COULD change in the future, do NOT use this method for consistent outputs.
+   * @deprecated [2024-12-11] this method is too broad and ambigous and should be removed.
    */
   asHumanTimestamp() {
-    const dash = "-", doublecolon = ":", space = " ", T = "T", date = this.asDate();
-    return this.doGetFourDigitsYears(date) + dash + this.doGetTwoDigitsMonths(date) + dash + this.doGetTwoDigitsDays(date) + space + this.doGetTwoDigitsHours(date) + doublecolon + this.doGetTwoDigitsMinutes(date) + doublecolon + this.doGetTwoDigitsSeconds(date);
-  }
-  // Please do not use this method internally, as it is not optimized for continued usage.
-  get twoDigitsDays() {
-    return this.doGetTwoDigitsDays(this.asDate());
-  }
-  // Please do not use this method internally, as it is not optimized for continued usage.
-  get twoDigitsMonths() {
-    return this.doGetTwoDigitsMonths(this.asDate());
-  }
-  // Please do not use this method internally, as it is not optimized for continued usage.
-  get fourDigitsYears() {
-    return this.doGetFourDigitsYears(this.asDate());
-  }
-  // Please do not use this method internally, as it is not optimized for continued usage.
-  get twoDigitsHours() {
-    return this.doGetTwoDigitsHours(this.asDate());
-  }
-  // Please do not use this method internally, as it is not optimized for continued usage.
-  get twoDigitsMinutes() {
-    return this.doGetTwoDigitsMinutes(this.asDate());
-  }
-  // Please do not use this method internally, as it is not optimized for continued usage.
-  get twoDigitsSeconds() {
-    return this.doGetTwoDigitsSeconds(this.asDate());
-  }
-  // Please do not use this method internally, as it is not optimized for continued usage.
-  get threeDigitsMilliseconds() {
-    return this.doGetThreeDigitsMilliseconds(this.asDate());
-  }
-  // Please do not use this method internally, as it is not optimized for continued usage.
-  get twoDigitsDaysUTC() {
-    return this.doGetTwoDigitsDays(this.asDateUTC());
-  }
-  // Please do not use this method internally, as it is not optimized for continued usage.
-  get twoDigitsMonthsUTC() {
-    return this.doGetTwoDigitsMonths(this.asDateUTC());
-  }
-  // Please do not use this method internally, as it is not optimized for continued usage.
-  get fourDigitsYearsUTC() {
-    return this.doGetFourDigitsYears(this.asDateUTC());
-  }
-  // Please do not use this method internally, as it is not optimized for continued usage.
-  get twoDigitsHoursUTC() {
-    return this.doGetTwoDigitsHours(this.asDateUTC());
-  }
-  // Please do not use this method internally, as it is not optimized for continued usage.
-  get twoDigitsMinutesUTC() {
-    return this.doGetTwoDigitsMinutes(this.asDateUTC());
-  }
-  // Please do not use this method internally, as it is not optimized for continued usage.
-  get twoDigitsSecondsUTC() {
-    return this.doGetTwoDigitsSeconds(this.asDateUTC());
-  }
-  // Please do not use this method internally, as it is not optimized for continued usage.
-  get threeDigitsMillisecondsUTC() {
-    return this.doGetThreeDigitsMilliseconds(this.asDateUTC());
-  }
-  // Please do not use this method internally, as it is not optimized for continued usage.
-  get fourDigitsTimezoneOffset() {
-    const offset = this.asDate().getTimezoneOffset();
-    return (offset >= 0 ? "+" : "-") + pad(Math.floor(Math.abs(offset) / 60).toString(), 2, "0") + pad((Math.abs(offset) % 60).toString(), 2, "0");
-  }
-  doGetTwoDigitsDays(date) {
-    return pad(date.getDate().toString(), 2, "0");
-  }
-  doGetTwoDigitsMonths(date) {
-    return pad((date.getMonth() + 1).toString(), 2, "0");
-  }
-  doGetFourDigitsYears(date) {
-    return pad(date.getFullYear().toString(), 4, "0");
-  }
-  doGetTwoDigitsHours(date) {
-    return pad(date.getHours().toString(), 2, "0");
-  }
-  doGetTwoDigitsMinutes(date) {
-    return pad(date.getMinutes().toString(), 2, "0");
-  }
-  doGetTwoDigitsSeconds(date) {
-    return pad(date.getSeconds().toString(), 2, "0");
-  }
-  doGetThreeDigitsMilliseconds(date) {
-    return pad(date.getMilliseconds().toString(), 3, "0");
-  }
-  doGetFourDigitsTimezoneOffset(date) {
-    const offset = date.getTimezoneOffset();
-    return (offset >= 0 ? "+" : "-") + pad(Math.floor(Math.abs(offset) / 60).toString(), 2, "0") + pad((Math.abs(offset) % 60).toString(), 2, "0");
+    return this.format("yyyy-MM-dd HH:mm:ss");
   }
-  asUnixTimestamp() {
+  toUnixTimestamp() {
     return this.ms;
   }
-  asDate() {
+  toDate() {
     return new Date(this.ms);
   }
-  asDateUTC() {
+  toDateUTC() {
     return new Date(this.ms + (/* @__PURE__ */ new Date()).getTimezoneOffset() * 60 * 1e3);
   }
   get isInThePast() {
@@ -1649,23 +1807,23 @@ var TimeInstant = class _TimeInstant extends TimeBase {
     return _TimeInstant.fromUnixTimestamp(timestamp2);
   }
   get dayOfMonth() {
-    return this.asDate().getDate();
+    return this.toDate().getDate();
   }
   get dayOfWeek() {
-    return this.asDate().getDay() + 1;
+    return this.toDate().getDay() + 1;
   }
   get month() {
-    return this.asDate().getMonth() + 1;
+    return this.toDate().getMonth() + 1;
   }
   get year() {
-    return this.asDate().getFullYear();
+    return this.toDate().getFullYear();
   }
   /**
   	* Returns the week number represented by this instant, according to the ISO 8601 standard.
   	* Please note that the instant and the week number could be of two different years, eg the friday 1st january is actually part of week 52 of the previous year.
   	*/
   get weekNumber() {
-    const date = this.asDate();
+    const date = this.toDate();
     const oneDay = 1e3 * 60 * 60 * 24;
     const thursdayOfThisWeek = new Date(date.getFullYear(), date.getMonth(), date.getDate() + 4 - (date.getDay() || 7), 14, 0, 0);
     const firstOfJanuary = new Date(thursdayOfThisWeek.getFullYear(), 0, 1, 14, 0, 0);
@@ -2517,6 +2675,7 @@ export {
   sum,
   sumBy,
   throttle,
+  tryToParseJson,
   uniq,
   uniqBy,
   uniqByKey,