@zelgadis87/utils-core 5.2.12 → 5.3.1

package/.rollup/index.mjs

@@ -0,0 +1,3268 @@
+class DeferredCanceledError extends Error {
+    constructor() {
+        super("Execution canceled");
+    }
+}
+class Deferred {
+    _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]';
+    }
+}
+
+class RateThrottler {
+    _frequency;
+    _availableSlots;
+    _waitingRequests;
+    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 = [];
+    }
+    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 {
+            // Semaphore implementation using promises.
+            const waitingRequest = new Deferred();
+            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));
+    };
+}
+
+class Semaphore {
+    _availableSlots;
+    _queuedRequests;
+    _inProgress = 0;
+    constructor(_availableSlots = 1) {
+        this._availableSlots = _availableSlots;
+        this._queuedRequests = [];
+    }
+    async _awaitSlot() {
+        if (this._availableSlots > 0) {
+            this._availableSlots -= 1;
+            this._inProgress += 1;
+            return void 0;
+        }
+        else {
+            // Semaphore implementation using promises.
+            const deferred = new Deferred();
+            this._queuedRequests.push(deferred);
+            return deferred.asPromise();
+        }
+    }
+    _releaseSlot() {
+        const waitingSlotToResolve = this._queuedRequests.shift();
+        if (waitingSlotToResolve) {
+            // Let the next request start.
+            waitingSlotToResolve.resolve();
+        }
+        else {
+            // Free a slot.
+            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;
+    }
+}
+
+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 !== undefined;
+}
+function isNullOrUndefined(x) {
+    return x === null || x === undefined;
+}
+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(); });
+}
+
+class Optional {
+    _present;
+    _value;
+    constructor(t) {
+        const defined = isDefined(t);
+        this._value = defined ? t : undefined;
+        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 = undefined;
+        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(undefined);
+    }
+    static of(t) {
+        if (isNullOrUndefined(t))
+            throw new ErrorCannotInstantiatePresentOptionalWithEmptyValue();
+        return new Optional(t);
+    }
+    static ofNullable(t) {
+        return new Optional(t);
+    }
+}
+class ErrorGetEmptyOptional extends Error {
+    constructor() {
+        super("Cannot retrieve a value from an empty Optional.");
+    }
+}
+class ErrorSetEmptyOptional extends Error {
+    constructor() {
+        super("Cannot set a null or undefined value.");
+    }
+}
+class ErrorCannotInstantiatePresentOptionalWithEmptyValue extends Error {
+    constructor() {
+        super("Cannot initialize a PresentOptional with a null or undefined value.");
+    }
+}
+
+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 !== undefined) {
+            const arr = dict[key] ?? [];
+            arr.push(cur);
+            dict[key] = arr;
+        }
+        return dict;
+    }, {});
+}
+
+function indexByString(arr, field, valueMapper = v => v) {
+    return indexByStringWith(arr, t => t[field], valueMapper);
+}
+function indexByNumber(arr, field, valueMapper = v => v) {
+    return indexByNumberWith(arr, t => t[field], valueMapper);
+}
+function indexBySymbol(arr, field, valueMapper = v => v) {
+    return indexBySymbolWith(arr, t => t[field], valueMapper);
+}
+function indexByStringWith(arr, keyGetter, valueMapper = v => v) {
+    return doIndexByWith(arr, keyGetter, valueMapper);
+}
+function indexByNumberWith(arr, keyGetter, valueMapper = v => v) {
+    return doIndexByWith(arr, keyGetter, valueMapper);
+}
+function indexBySymbolWith(arr, keyGetter, valueMapper = v => v) {
+    return doIndexByWith(arr, keyGetter, valueMapper);
+}
+function doIndexByWith(arr, keyGetter, valueMapper = v => v) {
+    return arr.reduce((dict, cur) => {
+        const key = keyGetter(cur);
+        if (key !== null && key !== undefined) {
+            if (dict[key]) {
+                throw new Error(`Multiple values indexed by same key "${String(key)}".`);
+            }
+            dict[key] = valueMapper(cur);
+        }
+        return dict;
+    }, {});
+}
+
+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((min, cur) => cur < min ? cur : min);
+}
+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((max, cur) => cur > max ? cur : max);
+}
+function maxBy(arr, getter) {
+    return max(arr.map(getter));
+}
+
+function constant(v) { return () => v; }
+function identity(t) { return t; }
+const constantNull = constant(null);
+const constantTrue = constant(true);
+const constantFalse = constant(false);
+const constantUndefined = constant(void 0);
+const alwaysTrue = constantTrue;
+const alwaysFalse = constantFalse;
+const constantZero = constant(0);
+const constantOne = constant(1);
+
+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;
+    }
+}
+
+class PredicateBuilder {
+    _currentPredicate = constantTrue;
+    and(predicate) {
+        const curPredicate = this._currentPredicate.bind(undefined);
+        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;
+    }
+}
+
+function isFunction(t) {
+    return typeof t === 'function';
+}
+function noop() { } // eslint-disable-line @typescript-eslint/no-empty-function
+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);
+    };
+}
+
+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]);
+}
+
+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;
+}
+/**
+ * Generate a new copy of an array with:
+ * - the first instance of an item matching the predicate being replaced with the given argument
+ * - the given argument added as last item of the array if the predicate did not produce a match
+ * @param arr - the original array of items
+ * @param item - the item to insert or update
+ * @param predicate - a function that returns true iff an item is equal to the given argument
+ * @returns a new copy of the array with the item updated or added in last place
+ */
+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$1(arr) {
+    return [...arr].reverse();
+}
+function first$1(arr, defaultValue = null) {
+    return (arr.length ? arr[0] : defaultValue);
+}
+function last$1(arr, defaultValue = null) {
+    return (arr.length ? arr[arr.length - 1] : defaultValue);
+}
+const head = first$1;
+function tail(arr) {
+    return (arr.length ? arr.slice(1) : []);
+}
+function sortedArray(arr, sortFn) {
+    return [...arr].sort(sortFn);
+}
+/**
+ * Custom implementation of includes which allows checking for arbitrary items inside the array.
+ */
+function arrayIncludes(arr, item, fromIndex) {
+    return arr.includes(item, fromIndex);
+}
+/** @deprecated[2025.11.08]: Use {@link arrayIncludes} instead. */
+const includes = arrayIncludes;
+function mapTruthys(arr, mapper) {
+    return arr.map(mapper).filter(value => value !== undefined);
+}
+function flatMapTruthys(arr, mapper) {
+    return arr.flatMap(mapper).filter(value => value !== undefined);
+}
+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);
+}
+/**
+ * Partitions the given array in two groups, in the first one there will be any and only values of the array that match the given predicate, in the second one there will be any and only values that don't.
+ * @param arr the array of items
+ * @param predicate the predicate to use to partition the array
+ * @returns a tuple, where the first array contains items matching the predicate, and the second array contains items not matching the predicate.
+ */
+function partition(arr, predicate) {
+    return arr.reduce((partition, item) => {
+        partition[(predicate(item) ? 0 : 1)].push(item);
+        return partition;
+    }, [[], []]);
+}
+/**
+ * Maps the first truthy value in the array using the provided mapping function.
+ * @param arr - The array of items.
+ * @param mapFn - The mapping function.
+ * @returns The first truthy value returned by the mapping function, or null if no truthy value is found.
+ */
+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.ofNullable(arr.find(predicate));
+}
+function findIndexInArray(arr, predicate) {
+    const idx = arr.findIndex(predicate);
+    return idx === -1 ? Optional.empty() : Optional.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]];
+    }, [[], []]);
+}
+/**
+ * Gets the element at the specified index in the array, wrapped in an Optional.
+ * Returns an empty Optional if the index is out of bounds (negative or >= array length).
+ * @param arr - The array to get the element from
+ * @param index - The index of the element to retrieve
+ * @returns An Optional containing the element at the index, or empty if index is out of bounds
+ */
+function arrayGet(arr, index) {
+    if (index < 0 || index >= arr.length)
+        return Optional.empty();
+    return Optional.of(arr[index]);
+}
+
+function isTrue(x) {
+    return x === true;
+}
+function isFalse(x) {
+    return x === false;
+}
+
+const newLine = '\n', tabulation = '\t', colon = ':', semiColon = ';', space = ' ', openBracket = '{', 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);
+}
+/* exported for test purposes only */
+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 = (dict) => {
+        const newDict = {};
+        for (const [key, value] of Object.entries(dict)) {
+            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;
+}
+
+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))];
+    }
+}
+
+function asError(e) {
+    if (e === undefined || 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 `\ncaused by: ${getMessageFromError(asError(error.cause))}`;
+}
+function getCauseStackFromError(error) {
+    if (isNullOrUndefined(error.cause))
+        return '';
+    return `\ncaused by: ${getStackFromError(asError(error.cause))}`;
+}
+/**
+ * Throws an error if a switch discriminated union type does not cover all the expected cases.
+ * Expected usage: `
+ * switch ( x.type ) {
+ *   case "x": return doX();
+ *   case "y": return doY();
+ *   ...
+ *   default: throw new NonExhaustiveSwitchError( x satisfies never );
+ * }`
+ */
+class NonExhaustiveSwitchError extends Error {
+    constructor(value) {
+        super("Expected switch to be exhaustive, got: " + value);
+    }
+}
+
+function tryToParseJson(jsonContent) {
+    return withTryCatch(() => parseJson(jsonContent));
+}
+function parseJson(jsonContent) {
+    return JSON.parse(jsonContent);
+}
+function stringifyJson(jsonSerializable, minify = false) {
+    return JSON.stringify(jsonSerializable, undefined, minify ? undefined : 2);
+}
+function jsonCloneDeep(a) {
+    // Handle the 3 simple types, and null or undefined
+    if (null === a || "object" !== typeof a)
+        return a;
+    if (a instanceof Date) {
+        // Handle Date
+        return new Date(a.getTime());
+    }
+    else if (a instanceof Array) {
+        // Handle 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) {
+        // Handle Object
+        const copy = {};
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        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 });
+}
+
+const 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;
+}
+const roundToNearest = (n, precision = 0) => round(n, precision, 'toNearest');
+const roundToLower = (n, precision = 0) => round(n, precision, 'toLower');
+const roundToUpper = (n, precision = 0) => round(n, precision, 'toUpper');
+const roundTowardsZero = (n, precision = 0) => round(n, precision, 'towardsZero');
+const roundAwayFromZero = (n, precision = 0) => round(n, precision, 'awayFromZero');
+
+function ensurePositiveNumber(v, name = 'value') {
+    if (v !== undefined && v !== null && v > 0)
+        return v;
+    throw new Error(`Expected ${name} to be positive, got: ${v}`);
+}
+function ensureNonNegativeNumber(v, name = 'value') {
+    if (v !== undefined && v !== null && v >= 0)
+        return v;
+    throw new Error(`Expected ${name} to be non-negative, got: ${v}`);
+}
+function ensureNonPositiveNumber(v, name = 'value') {
+    if (v !== undefined && v !== null && v <= 0)
+        return v;
+    throw new Error(`Expected ${name} to be non-positive, got: ${v}`);
+}
+function ensureNegativeNumber(v, name = 'value') {
+    if (v !== undefined && 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;
+}
+const increment = incrementBy(1);
+const decrement = incrementBy(-1);
+const 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, min, max) {
+    if (min === null || max === null || n === null || isNaN(min) || isNaN(max) || isNaN(n) || min > max)
+        throw new Error();
+    if (n > max) {
+        return max;
+    }
+    else if (n < min) {
+        return min;
+    }
+    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;
+    });
+}
+
+const Operation = {
+    ok: (data) => {
+        return { success: true, data };
+    },
+    ko: (error) => {
+        return { success: false, error };
+    },
+};
+
+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);
+}
+class TimeoutError 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.");
+    });
+}
+const NEVER = new Promise(_resolve => { });
+
+function randomNumberInInterval(min, max) {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+}
+const randomId = (length) => {
+    return Math.random().toString(36).substring(2, length + 2);
+};
+
+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)));
+}
+/** @deprecated[2025.08.01]: Compatibility layer. */
+const mapEntries = entriesToEntries;
+function entriesToList(dict, mapper) {
+    return dictToEntries(dict).map((entry) => mapper(entry));
+}
+
+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;
+}
+
+class StringParts {
+    _parts;
+    constructor(...parts) {
+        this._parts = parts;
+    }
+    toUpperCase() {
+        return new StringParts(...this.parts.map(part => part.toUpperCase()));
+    }
+    toLowerCase() {
+        return new StringParts(...this.parts.map(part => part.toLowerCase()));
+    }
+    capitalizeFirst() {
+        if (!this.length)
+            return this;
+        return new StringParts(capitalizeWord(this.first), ...this.tail.map(part => part.toLowerCase()));
+    }
+    capitalizeEach() {
+        return new StringParts(...this.parts.map(part => capitalizeWord(part)));
+    }
+    get parts() {
+        return this._parts;
+    }
+    get tail() {
+        const [_first, ...tail] = this.parts;
+        return tail;
+    }
+    get first() {
+        return this._parts[0] ?? null;
+    }
+    get last() {
+        return this._parts[this.length - 1] ?? null;
+    }
+    get length() {
+        return this._parts.length;
+    }
+    trim() {
+        return new StringParts(...this.parts.map(part => part.trim()));
+    }
+    toSnakeCase() {
+        return this.toLowerCase().join('_');
+    }
+    toCamelCase() {
+        if (!this.length)
+            return '';
+        return [this.first.toLowerCase(), ...this.tail.map(capitalizeWord)].join('');
+    }
+    toKebabCase() {
+        return this.toLowerCase().join('-');
+    }
+    toPascalCase() {
+        return this.capitalizeEach().join('');
+    }
+    toHumanCase() {
+        return this.capitalizeFirst().join(' ');
+    }
+    join(separator) {
+        return this.parts.join(separator);
+    }
+    mergeWith({ parts: otherParts }) {
+        return new StringParts(...this.parts, ...otherParts);
+    }
+    slice(start, end) {
+        return new StringParts(...this.parts.slice(start, end));
+    }
+    splice(start, deleteCount, ...items) {
+        return new StringParts(...this.parts.splice(start, deleteCount, ...items));
+    }
+    push(part) {
+        return new StringParts(...this.parts, part);
+    }
+    shift(part) {
+        return new StringParts(part, ...this.parts);
+    }
+    reverse() {
+        return new StringParts(...this.parts.reverse());
+    }
+    static fromString = (s, separator = /\s+/g) => {
+        if (s === null || separator === null)
+            throw new Error('Invalid arguments');
+        return new StringParts(...s.split(separator));
+    };
+    static fromParts = (...parts) => {
+        return new StringParts(...parts);
+    };
+    /**
+     * 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()));
+    }
+}
+
+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;
+}
+
+/**
+ * Class that stores a value that is computationally/memory intensive to initialize.
+ * The initialization of the value is done once and only if required (lazy initialization).
+ * @author gtomberli
+ */
+class Lazy {
+    _value = undefined;
+    _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();
+        }
+    }
+    empty() {
+        this._initialized = false;
+    }
+    static of(generator) {
+        return new Lazy(generator);
+    }
+}
+
+class LazyAsync {
+    _promise = undefined;
+    _pending = false;
+    _resolvedValue = undefined;
+    _error = undefined;
+    _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 !== undefined;
+    }
+    isEmpty() {
+        return this._promise === undefined;
+    }
+    isPending() {
+        return this.isPresent() && this._pending === true;
+    }
+    isReady() {
+        return this.isPresent() && this._pending === false;
+    }
+    isResolved() {
+        return this.isReady() && this._error === undefined;
+    }
+    isError() {
+        return this.isReady() && this._error !== undefined;
+    }
+    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;
+    }
+    empty() {
+        this._promise = undefined;
+    }
+    static of(generator) {
+        return new LazyAsync(generator);
+    }
+}
+
+class LazyDictionary {
+    _generator;
+    _dictionary = {};
+    constructor(_generator) {
+        this._generator = _generator;
+    }
+    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);
+    }
+}
+
+class TimeUnit {
+    multiplier;
+    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(1000 * 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);
+}
+
+class TimeBase {
+    _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;
+    }
+}
+
+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)); // Avoid going negative.
+        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;
+        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;
+        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; // Do nothing on cancelation
+            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();
+        // data.hours += data.days * 24; // roll over days as hours.
+        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 < 1000)
+            return (this.ms / 1000).toFixed(1);
+        return Math.floor(this.seconds).toString();
+    }
+    fromNow() {
+        return TimeInstant.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.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;
+}
+
+const 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,
+};
+
+const isRelativeNumber = (x) => x !== undefined && x.length > 0 && (x[0] === '+' || x[0] === '-');
+const 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' },
+};
+const timeInstantCreationRelativeAliases = {
+    current: 0,
+    last: -1,
+    next: 1,
+};
+const timeInstantResolveValue = (getFromDate, referenceDate, x) => {
+    if (x === undefined) {
+        return getFromDate(referenceDate);
+    }
+    else if (typeof x === 'number') {
+        return x;
+    }
+    else if (typeof x === 'string') {
+        if (isRelativeNumber(x)) {
+            return getFromDate(referenceDate) + parseInt(x);
+        }
+        else if (x in timeInstantCreationRelativeAliases) {
+            return getFromDate(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 === undefined || relativeTo === 'now') {
+            return getFromDate(referenceDate) + relative;
+        }
+        else {
+            return getFromDate(relativeTo.toDate()) + relative;
+        }
+    }
+    else if ("absolute" in x) {
+        return x.absolute;
+    }
+    else {
+        throw new Error('Uparseable value detected: ' + x);
+    }
+};
+const 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(),
+};
+const 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 timestamp = 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(timestamp))
+        throw new Error(`Unparseable date: ${JSON.stringify(aParameters)} }`);
+    return TimeInstant.fromUnixTimestamp(timestamp);
+}
+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;
+}
+
+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.fromMs(Math.abs(this.ms - instant.ms));
+    }
+    distanceFromNow() {
+        return TimeDuration.fromMs(Math.abs(this.ms - Date.now()));
+    }
+    distanceFromUnixTimestamp(timestamp) {
+        return TimeDuration.ms(this.ms - timestamp);
+    }
+    timeLeftFrom(instant) {
+        const distance = this.ms - instant.ms;
+        return TimeDuration.fromMs(Math.max(distance, 0));
+    }
+    timeLeftFromNow() {
+        const distance = this.ms - Date.now();
+        return TimeDuration.fromMs(Math.max(distance, 0));
+    }
+    distanceFromStartOfDay() {
+        // Calculate milliseconds since start of day directly without creating intermediate TimeInstant
+        const params = this.toParameters();
+        const msInDay = params.hours * 3600000 + params.minutes * 60000 + params.seconds * 1000 + params.milliseconds;
+        return TimeDuration.fromMs(msInDay);
+    }
+    atStartOfDay() {
+        return this.atTime({ hours: 0, minutes: 0, seconds: 0, milliseconds: 0 });
+    }
+    distanceFromEndOfDay() {
+        // Calculate milliseconds until end of day directly
+        const params = this.toParameters();
+        const msInDay = params.hours * 3600000 + params.minutes * 60000 + params.seconds * 1000 + params.milliseconds;
+        const msUntilEndOfDay = 86399999 - msInDay; // 23:59:59.999 in ms
+        return TimeDuration.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() {
+        // Calculate days directly from timestamps without creating TimeInstant object
+        return Math.floor(this.ms / 86400000) === Math.floor(Date.now() / 86400000);
+    }
+    /**
+     * 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() {
+        // Syntactic sugar for this.ms;
+        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) {
+        // Regex to capture: YYYY-MM-DDTHH:mm:ss.sssZ or YYYY-MM-DDTHH:mm:ss.sss±HH:mm
+        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;
+        // Parse strings to numbers
+        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);
+        // Validate each component using standalone validation functions
+        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 timestamp = Math.ceil(this.ms / unitMs) * unitMs;
+        return TimeInstant.fromUnixTimestamp(timestamp);
+    }
+    roundedToPrevious(unit, factor = 1) {
+        const unitMs = unit.toMs(factor);
+        const timestamp = Math.floor(this.ms / unitMs) * unitMs;
+        return TimeInstant.fromUnixTimestamp(timestamp);
+    }
+    roundedTo(unit, factor = 1) {
+        const unitMs = unit.toMs(factor);
+        const timestamp = Math.round(this.ms / unitMs) * unitMs;
+        return TimeInstant.fromUnixTimestamp(timestamp);
+    }
+    /**
+     * 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() {
+        /**
+         * According to the ISO 8601 Standard, week number 1 is defined as the week containing the 4th of january (or, equivalently, the week that contains the first Thursday of the year).
+         * As such, we basically have to count how many Thursdays there has been in this year.
+         * Please note that the thursdayOfThisWeek could be in the previous year.
+         */
+        const date = this.toDate();
+        const oneDay = 1000 * 60 * 60 * 24;
+        // Get thursday of this week
+        const dayOfWeek = date.getUTCDay() || 7; // Sunday = 7 in ISO
+        const thursdayMs = this.ms + (4 - dayOfWeek) * oneDay;
+        const thursdayDate = new Date(thursdayMs);
+        const thursdayYear = thursdayDate.getUTCFullYear();
+        // First of January at noon UTC
+        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: 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 !== undefined && x instanceof TimeInstant;
+}
+// Utility functions for date formatting and parsing
+// Standalone validation functions
+function isValidYear(num) {
+    return num >= 0 && num <= 9999;
+}
+function isValidMonth(num) {
+    return num >= 1 && num <= 12;
+}
+// TODO: Add calendar-aware validation to check month-specific day limits
+// (e.g., reject February 30th, April 31st, February 29th in non-leap years)
+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;
+}
+// Month names cache by locale to avoid regenerating on every call
+const monthNamesCache = new Map();
+function getMonthNames(locale = 'en') {
+    // Check cache first
+    const cached = monthNamesCache.get(locale);
+    if (cached) {
+        return cached;
+    }
+    // Use Intl.DateTimeFormat to generate month names for any locale
+    const shortFormatter = new Intl.DateTimeFormat(locale, { month: 'short' });
+    const longFormatter = new Intl.DateTimeFormat(locale, { month: 'long' });
+    const short = [];
+    const long = [];
+    // Generate names for all 12 months (0-11 in Date constructor)
+    for (let month = 0; month < 12; month++) {
+        // Use January 1st of year 2000 as a reference date (arbitrary non-leap year)
+        const date = new Date(2000, month, 1);
+        short.push(normalizeMonthName(shortFormatter.format(date)));
+        long.push(normalizeMonthName(longFormatter.format(date)));
+    }
+    const result = { short, long };
+    monthNamesCache.set(locale, result);
+    return result;
+}
+// Normalize month names by removing accents, periods, and other special characters
+function normalizeMonthName(name) {
+    return name
+        // Remove periods and other punctuation
+        .replace(/[.,;:!?]/g, '')
+        // Normalize Unicode (decompose accented characters)
+        .normalize('NFD')
+        // Remove diacritical marks (accents)
+        .replace(/[\u0300-\u036f]/g, '')
+        // Trim whitespace
+        .trim();
+}
+const PATTERN_REGEX = /(M|y|d|D|h|H|m|s|S|G|Z|P|a)+/g;
+const ESCAPE_REGEX = /\\"|"((?:\\"|[^"])*)"/g;
+// Formatter configuration mapping: token pattern -> configuration with optional extraction rules
+const 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() } },
+};
+// Format a token using Intl.DateTimeFormat
+function formatType(type, length, date, locale = 'en', timeZone = 'UTC') {
+    const tokenKey = type.repeat(length);
+    const config = formatterConfigs[tokenKey];
+    if (!config) {
+        return undefined;
+    }
+    const formatter = new Intl.DateTimeFormat(locale, { ...config.options, timeZone });
+    // If extraction metadata is specified, use it
+    if (config.extract) {
+        const part = formatter.formatToParts(date).find(p => p.type === config.extract.partType);
+        const value = part?.value;
+        if (!value) {
+            return undefined;
+        }
+        // Apply transformation if specified
+        return config.extract.transform ? config.extract.transform(value) : value;
+    }
+    // Otherwise, format directly
+    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 !== undefined)
+        .map((sub, index) => {
+        // keep escaped strings as is
+        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 = {}) {
+    // Parse the components from the date string
+    const parsed = parseTimeInstantComponents(dateString, pattern, config);
+    // Fill in missing values from the base instant
+    const params = {
+        ...base.toParameters(),
+        ...parsed
+    };
+    // Create and return the TimeInstant with complete parameters
+    return TimeInstant.fromParameters(params);
+}
+function parseTimeInstantComponents(dateString, pattern, config = {}) {
+    // Create a regex pattern from the format pattern
+    let regexPattern = pattern;
+    const tokens = [];
+    let position = 0;
+    // Split by escape regex first, like the original implementation
+    const parts = pattern.split(ESCAPE_REGEX).filter((sub) => sub !== undefined);
+    // Rebuild pattern and track tokens
+    regexPattern = parts.map((sub, index) => {
+        // Skip escaped strings (odd indices after split)
+        if (index % 2 !== 0) {
+            return sub.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // Escape special regex chars
+        }
+        return sub.replace(PATTERN_REGEX, (match) => {
+            const type = match.charAt(0);
+            tokens.push({ type, length: match.length, position: position++ });
+            // Create appropriate regex for each token type
+            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}"`);
+    }
+    // Extract only the values that were actually parsed (no defaults)
+    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 ? 2000 + 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);
+                // Normalize to milliseconds based on length
+                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;
+        }
+    });
+    // Handle 12-hour format conversion
+    if (is12Hour && hourValue !== undefined) {
+        if (isPM && hourValue < 12) {
+            result.hours = (hourValue + 12);
+        }
+        else if (!isPM && hourValue === 12) {
+            result.hours = 0;
+        }
+        else {
+            result.hours = hourValue;
+        }
+    }
+    // Validate each extracted component (only validate primitives)
+    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;
+}
+
+const LEVELS = ["trace", "log", "debug", "info", "warn", "error"];
+const timestamp = () => TimeInstant.now().format('HH:mm:ss');
+class Logger {
+    name;
+    enabled = true;
+    console;
+    minLevel;
+    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());
+    }
+    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);
+    }
+}
+
+const logger = new Logger('Cached');
+/**
+ * A cached value with stale-while-revalidate pattern.
+ * On initialization, the class starts calculating the async result (isPending() === true).
+ * When complete, the class will store the generated value (isReady() === true).
+ * After maxStale duration, the value becomes stale and will refresh in background on next access (isStale() === true).
+ * After maxAge has passed, the cached value is no longer used (isExpired() === true).
+ */
+class Cached {
+    /** Current promise for the value generation. */
+    _promise = undefined;
+    /** Flag indicating if a generation is currently in progress. */
+    _pending = false;
+    /** The last successfully generated value. */
+    _resolvedValue = undefined;
+    /** Function that generates the cached value. */
+    _generator;
+    /** Timestamp of the last successful value generation. */
+    _generatedAt = TimeInstant.ZERO;
+    /** The duration for which value should be kept cached. After maxAge from the last generated value, this object is considered empty. */
+    _maxAge;
+    /** The duration for which the value should be served from cache, even if stale. Has no effect if greater or equal to maxAge. */
+    _maxStale;
+    /** Callback invoked when new data becomes available. */
+    _onNewDataAvailable = noop;
+    /** Callback invoked when generation fails. */
+    _onError = err => logger.error('Cache generation failed:', err);
+    constructor(generator, maxAge, maxStale) {
+        this._generator = ensureDefined(generator);
+        this._maxAge = ensureDefined(maxAge);
+        this._maxStale = ensureDefined(TimeDuration.lowest(maxAge, maxStale));
+    }
+    /**
+     * Gets the cached value.
+     * Returns fresh data if available, stale data while revalidating, or triggers generation if empty/expired.
+     * @returns Promise resolving to the cached value.
+     */
+    async get() {
+        if (this.isPending()) {
+            return this._promise;
+        }
+        else if (this.isEmpty() || this.isExpired()) {
+            this._promise = this.generate();
+            return this._promise;
+        }
+        else {
+            if (this.isStale()) {
+                // Start re-generating the contents, while serving stale data.
+                void this.generate();
+            }
+            return this._resolvedValue;
+        }
+    }
+    /**
+     * Generates a new value using the generator function.
+     * Sets up promise handlers for success and error cases.
+     * @returns The generation promise.
+     */
+    generate() {
+        if (this._pending)
+            return this._promise;
+        this._pending = true;
+        const deferred = new Deferred();
+        this._generator().then(value => {
+            this._pending = false;
+            this._resolvedValue = value;
+            this._generatedAt = TimeInstant.now();
+            deferred.resolve(value);
+            withTryCatch(() => this._onNewDataAvailable(value));
+        }, error => {
+            const err = asError(error);
+            this._pending = false;
+            deferred.reject(err);
+            withTryCatch(() => this._onError(err));
+        });
+        return deferred.asPromise();
+    }
+    /**
+     * Checks if value has been requested at least once.
+     * @returns True if a promise exists.
+     */
+    isPresent() {
+        return this._promise !== undefined;
+    }
+    /**
+     * Checks value has never been requested.
+     * @returns True if empty.
+     */
+    isEmpty() {
+        return this._promise === undefined;
+    }
+    /**
+     * Checks if value generation is currently in progress.
+     * @returns True if generation is pending.
+     */
+    isPending() {
+        return this.isPresent() && this._pending === true;
+    }
+    /**
+     * Checks if value is stored and fresh.
+     * @returns True if stored and fresh.
+     */
+    isReady() {
+        return this.isPresent() && this.getAge().isLessThan(this._maxAge);
+    }
+    // protected isResolved() {
+    // 	return this.isReady() && this._error === undefined;
+    // }
+    // protected isError() {
+    // 	return this.isReady() && this._error !== undefined;
+    // }
+    /**
+     * Checks if cached value is stale (older than maxStale duration).
+     * @returns True if value is stale.
+     */
+    isStale() {
+        return this.isPresent() && this.getAge().isGreaterThan(this._maxStale);
+    }
+    /**
+     * Checks if cached value is expired (older than maxAge duration).
+     * @returns True if value is expired.
+     */
+    isExpired() {
+        return this.isPresent() && this.getAge().isGreaterThan(this._maxAge);
+    }
+    /**
+     * Gets the timestamp when the value was last successfully generated.
+     * @returns The last update timestamp.
+     */
+    getLastUpdated() {
+        return this._generatedAt;
+    }
+    /**
+     * Gets the age of the cached value.
+     * @returns The duration since the value was last generated.
+     */
+    getAge() {
+        return this._generatedAt.distanceFromNow();
+    }
+    /**
+     * Invalidates the cache by resetting the generation timestamp.
+     * Next access will trigger fresh generation.
+     */
+    invalidate() {
+        this._generatedAt = TimeInstant.ZERO;
+    }
+    /**
+     * Sets a callback to be invoked when new data becomes available.
+     * @param callback Function to call with the new value.
+     */
+    onNewDataAvailable(callback) {
+        this._onNewDataAvailable = ensureDefined(callback);
+    }
+    /**
+     * Sets a callback to be invoked when generation fails.
+     * @param callback Function to call with the error.
+     */
+    onError(callback) {
+        this._onError = ensureDefined(callback);
+    }
+    /**
+     * Creates a new Cached instance.
+     * @param generator Function that generates the value to cache.
+     * @param maxAge Maximum duration for which cached value is considered valid.
+     * @param maxStale Maximum duration for which stale value is served while revalidating. Defaults to maxAge.
+     * @returns A new Cached instance.
+     */
+    static of(generator, maxAge, maxStale = maxAge) {
+        const cached = new Cached(generator, maxAge, maxStale);
+        void cached.get();
+        return cached;
+    }
+}
+
+const defaultCompareValuesOptions = {
+    nullsFirst: false,
+};
+const defaultCompareFunctionOptions = {
+    ...defaultCompareValuesOptions,
+    direction: 'ASC',
+};
+const 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;
+    // A & B are defined and are different.
+    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 reverse(fn) {
+    return (a, b) => fn(a, b) * -1;
+}
+const chain = (fns, cmpFn) => {
+    return doCreateWithFunctions([...fns, cmpFn]);
+};
+const transformAndChain = (fns, transform, cmpFn) => {
+    const fn = (a, b) => cmpFn(transform(a), transform(b));
+    return chain(fns, fn);
+};
+const 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 }));
+};
+const compareNumbers = (fns, transform, options = {}) => {
+    const { nullsFirst, direction } = { ...defaultNumberComparisonOptions, ...options };
+    return chain(fns, compareFunction(transform, naturalOrderComparison, { nullsFirst, direction }));
+};
+const compareDates = (fns, transform, options = {}) => {
+    const { nullsFirst, direction } = { ...defaultDateComparisonOptions, ...options };
+    return chain(fns, compareFunction(transform, naturalOrderComparison, { nullsFirst, direction }));
+};
+const compareTimeInstants = (fns, transform, options = {}) => {
+    const { nullsFirst, direction } = { ...defaultTimeInstantComparisonOptions, ...options };
+    return chain(fns, compareFunction(transform, (a, b) => a.isBefore(b) ? -1 : 1, { nullsFirst, direction }));
+};
+const compareTimeDurations = (fns, transform, options = {}) => {
+    const { nullsFirst, direction } = { ...defaultTimeDurationComparisonOptions, ...options };
+    return chain(fns, compareFunction(transform, (a, b) => a.isLessThan(b) ? -1 : 1, { nullsFirst, direction }));
+};
+const compareBooleans = (fns, transform, options) => {
+    const { nullsFirst, truesFirst } = { ...defaultBooleanComparisonOptions, ...options };
+    return chain(fns, compareFunction(transform, naturalOrderComparison, { nullsFirst, direction: truesFirst ? 'DESC' : 'ASC' }));
+};
+const prioritizeSet = (fns, transform, set, reversed = false) => {
+    return compareBooleans(fns, (t) => {
+        const r = transform(t);
+        return isDefined(r) && set.includes(r);
+    }, { truesFirst: !reversed, nullsFirst: false });
+};
+const 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 });
+};
+const next = (fns, transform) => {
+    const using = (transformToX) => {
+        return next(fns, combine(transform, transformToX));
+    };
+    const retAsChainable = {
+        chain(chain) {
+            return transformAndChain(fns, transform, chain.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,
+    };
+};
+const createComparisonFunction = (fns) => {
+    return (a, b) => {
+        let cmp = 0, i = 0;
+        while (i < fns.length && cmp === 0) {
+            cmp = fns[i++](a, b);
+        }
+        return cmp;
+    };
+};
+const compare = (fns, a, b) => {
+    return createComparisonFunction(fns)(a, b);
+};
+const sort = (fns, arr) => {
+    const comparisonFn = createComparisonFunction(fns);
+    return [...arr].sort(comparisonFn);
+};
+const top = (fns, arr, n) => {
+    return sort(fns, arr).slice(0, Math.max(0, n));
+};
+const bottom = (fns, arr, n) => {
+    return sort(fns, arr).slice(-Math.max(0, n)).reverse();
+};
+const first = (fns, arr) => {
+    return arr.length ? top(fns, arr, 1)[0] : null;
+};
+const last = (fns, arr) => {
+    return arr.length ? bottom(fns, arr, 1)[0] : null;
+};
+function doCreateEmpty() {
+    // If we have no comparison functions, return an object that only has chain methods.
+    const base = next([], x => x);
+    const ret = {
+        ...base,
+        usingFunction(fn) {
+            return doCreateWithFunctions([fn]);
+        }
+    };
+    return ret;
+}
+function doCreateWithFunctions(fns) {
+    // If we have some comparison functions, return an object that has chain methods and ending methods.
+    return {
+        get then() {
+            return next(fns, identity);
+        },
+        reversed() {
+            return doCreateWithFunctions([...fns.map(reverse)]);
+        },
+        compare: (a, b) => {
+            return compare(fns, a, b);
+        },
+        sort: (arr) => {
+            return sort(fns, arr);
+        },
+        top: (arr, n) => {
+            return top(fns, arr, n);
+        },
+        bottom: (arr, n) => {
+            return bottom(fns, arr, n);
+        },
+        first: (arr) => {
+            return first(fns, arr);
+        },
+        last: (arr) => {
+            return last(fns, arr);
+        },
+    };
+}
+const defaultStringComparisonOptions = { ...defaultCompareFunctionOptions, ignoreCase: false };
+const defaultNumberComparisonOptions = { ...defaultCompareFunctionOptions };
+const defaultDateComparisonOptions = { ...defaultCompareFunctionOptions };
+const defaultTimeInstantComparisonOptions = { ...defaultCompareFunctionOptions };
+const defaultTimeDurationComparisonOptions = { ...defaultCompareFunctionOptions };
+const defaultBooleanComparisonOptions = { ...defaultCompareValuesOptions };
+const 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),
+};
+
+function randomize(unit) {
+    return (a, b) => {
+        return TimeDuration.fromMs(randomNumberInInterval(unit.toMs(a), unit.toMs(b)));
+    };
+}
+class RandomTimeDuration {
+    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);
+}
+
+class TimeFrequency {
+    times;
+    period;
+    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);
+    }
+}
+
+class TimeRange {
+    start;
+    duration;
+    end;
+    constructor(start, duration) {
+        this.start = start;
+        this.duration = duration;
+        this.end = start.addDuration(duration);
+    }
+    static fromInstants(a, b) {
+        const lowest = TimeInstant.lowest(a, b);
+        const highest = TimeInstant.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.now(), d);
+    }
+}
+
+class UnavailableUpgradeError extends Error {
+    data;
+    from;
+    to;
+    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;
+    }
+}
+class EmptyUpgradeError extends Error {
+    data;
+    from;
+    to;
+    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;
+    }
+}
+
+const DEBUG_ENABLED = false;
+function getTransitionsPath(matrix, from, to) {
+    return internalGetTransitionsPath(matrix, from, to, 0, DEBUG_ENABLED);
+}
+function internalGetTransitionsPath(matrix, from, to, depth, debug) {
+    const transitionsTo = matrix[to];
+    if (!transitionsTo) {
+        return null;
+    }
+    // Check if there is a transition that goes directly from from to to.
+    const exactTransition = transitionsTo[from];
+    if (exactTransition) {
+        return [exactTransition];
+    }
+    // Otherwise, recursively search for the min path.
+    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);
+            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) {
+    return;
+}
+function printTransitions(transitions) {
+    return transitions.reduce((ret, cur) => {
+        return ret + " -> " + cur.to;
+    }, "" + transitions[0].from);
+}
+
+const VERSION_FIELD = "$version";
+class DataUpgrader {
+    latestVersion;
+    transitions = {};
+    constructor(latestVersion) {
+        this.latestVersion = latestVersion;
+    }
+    addTransition(from, to, apply) {
+        if (from === undefined || from < 0)
+            throw new Error(`Invalid argument from, non-negative number expected, got: ${from}`);
+        if (to === undefined || 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 === undefined || 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 next = await transition.apply(current);
+            if (next === null || next === undefined)
+                throw new EmptyUpgradeError(current, from, to);
+            current = next;
+        }
+        return current;
+    }
+    isLatestVersion(data) {
+        return data.$version === this.latestVersion;
+    }
+    static create(latest) {
+        return new DataUpgrader(latest);
+    }
+    static Errors = {
+        EmptyUpgrade: EmptyUpgradeError,
+        UnavailableUpgrade: UnavailableUpgradeError
+    };
+}
+function isUpgradable(obj) {
+    return isDefined(obj) && typeof obj === "object" && VERSION_FIELD in obj && isNumber(obj.$version) && isPositiveNumber(obj.$version);
+}
+
+export { Cached, 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, arrayIncludes, 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$1 as 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$1 as 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$1 as 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.mjs.map