@develia/commons 0.2.25 → 0.3.0

package/dist/index.cjs.js

@@ -0,0 +1,992 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class Pair {
+    get value() {
+        return this._value;
+    }
+    get key() {
+        return this._key;
+    }
+    constructor(key, value) {
+        this._key = key;
+        this._value = value;
+    }
+}
+
+// noinspection JSUnusedGlobalSymbols
+function isIterable(obj) {
+    return obj[Symbol.iterator] === 'function';
+}
+function clamp(n, min, max) {
+    if (n < min)
+        return min;
+    if (n > max)
+        return max;
+    return n;
+}
+/**
+ * Linearly remaps a value from its source range [`inMin`, `inMax`] to the destination range [`outMin`, `outMax`]
+ *
+ * @category Math
+ * @example
+ * ```
+ * const value = remap(0.5, 0, 1, 200, 400) // value will be 300
+ * ```
+ */
+function lerp(n, inMin, inMax, outMin, outMax) {
+    return outMin + (outMax - outMin) * ((n - inMin) / (inMax - inMin));
+}
+/**
+ * Ensure prefix of a string
+ *
+ * @category String
+ */
+function ensurePrefix(prefix, str) {
+    if (!str.startsWith(prefix))
+        return prefix + str;
+    return str;
+}
+/**
+ * Ensure suffix of a string
+ *
+ * @category String
+ */
+function ensureSuffix(suffix, str) {
+    if (!str.endsWith(suffix))
+        return str + suffix;
+    return str;
+}
+function isString(value) {
+    return typeof value === 'string';
+}
+function isNumber(value) {
+    return typeof value === 'number';
+}
+function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isArray(value) {
+    return Array.isArray(value);
+}
+function isFunction(value) {
+    return typeof value === 'function';
+}
+function isUndefined(value) {
+    return typeof value === 'undefined';
+}
+function isNull(value) {
+    return value === null;
+}
+function isBigInt(value) {
+    return typeof value === 'bigint';
+}
+function isSymbol(value) {
+    return typeof value === 'symbol';
+}
+function isNullOrUndefined(value) {
+    return value === null || typeof value === 'undefined';
+}
+function isEmpty(value) {
+    return (Array.isArray(value) && value.length === 0) ||
+        (typeof value === 'string' && value === '') ||
+        value === null || typeof value === 'undefined';
+}
+function isEmptyOrWhitespace(value) {
+    return (Array.isArray(value) && value.length === 0) ||
+        (typeof value === 'string' && value.trim() === '') ||
+        value === null || typeof value === 'undefined';
+}
+function ajaxSubmit(selectorOrElement) {
+    const form = typeof selectorOrElement === 'string'
+        ? document.querySelector(selectorOrElement)
+        : selectorOrElement;
+    if (!(form instanceof HTMLFormElement)) {
+        return;
+    }
+    // Crear un objeto FormData a partir del formulario
+    return fetch(form.action, {
+        method: form.method,
+        body: new FormData(form),
+    });
+}
+function toPairs(obj) {
+    let output = [];
+    for (const key in obj) {
+        output.push(new Pair(key, obj[key]));
+    }
+    return output;
+}
+function promisify(thing) {
+    if (thing instanceof Promise)
+        return thing;
+    if (thing instanceof Function) {
+        return new Promise((resolve, reject) => {
+            try {
+                const result = thing();
+                resolve(result);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    if (typeof thing.done === 'function' && typeof thing.fail === 'function') {
+        return new Promise((resolve, reject) => {
+            thing.done(resolve).fail(reject);
+        });
+    }
+    return Promise.resolve(thing);
+}
+function ajaxSubmission(selectorOrElement, onSuccess = null, onFailure = null) {
+    const form = typeof selectorOrElement === 'string'
+        ? document.querySelector(selectorOrElement)
+        : selectorOrElement;
+    if (!(form instanceof HTMLFormElement)) {
+        return;
+    }
+    form.addEventListener('submit', async (event) => {
+        var _a;
+        event.preventDefault();
+        (_a = ajaxSubmit(form)) === null || _a === void 0 ? void 0 : _a.then(onSuccess).catch(onFailure);
+    });
+}
+function deepClone(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        const copy = [];
+        for (const element of obj) {
+            copy.push(deepClone(element));
+        }
+        return copy;
+    }
+    const copy = {};
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            copy[key] = deepClone(obj[key]);
+        }
+    }
+    return copy;
+}
+function _objectToFormData(data, formData, parentKey = '') {
+    for (const key in data) {
+        if (data.hasOwnProperty(key)) {
+            const value = data[key];
+            if (value instanceof Date) {
+                formData.append(parentKey ? `${parentKey}[${key}]` : key, value.toISOString());
+            }
+            else if (value instanceof File) {
+                formData.append(parentKey ? `${parentKey}[${key}]` : key, value);
+            }
+            else if (typeof value === 'object' && !Array.isArray(value)) {
+                _objectToFormData(value, formData, parentKey ? `${parentKey}[${key}]` : key);
+            }
+            else if (Array.isArray(value)) {
+                value.forEach((item, index) => {
+                    const arrayKey = `${parentKey ? `${parentKey}[${key}]` : key}[${index}]`;
+                    if (typeof item === 'object' && !Array.isArray(item)) {
+                        _objectToFormData(item, formData, arrayKey);
+                    }
+                    else {
+                        formData.append(arrayKey, item);
+                    }
+                });
+            }
+            else {
+                formData.append(parentKey ? `${parentKey}[${key}]` : key, value);
+            }
+        }
+    }
+    return formData;
+}
+function objectToFormData(data) {
+    let formData = new FormData();
+    return _objectToFormData(data, formData);
+}
+
+class CacheDictionary {
+    constructor(fallback = null, defaultDuration = null) {
+        this.fallback = fallback;
+        this.cache = {};
+        this.defaultDuration = defaultDuration;
+        this.expiration = {};
+    }
+    getExpiration(key) {
+        return this.expiration[key];
+    }
+    setExpiration(key, expiration) {
+        this.expiration[key] = expiration;
+    }
+    setDuration(key, duration) {
+        if (duration === null) {
+            delete this.expiration[key];
+        }
+        else {
+            const expiration = new Date();
+            expiration.setSeconds(expiration.getSeconds() + duration);
+            this.expiration[key] = expiration;
+        }
+    }
+    get(key) {
+        if (!this.cache.hasOwnProperty(key)) {
+            if (this.fallback) {
+                this.cache[key] = this.fallback(key);
+                this.expiration[key] = this.calculateExpiration(this.defaultDuration);
+            }
+            else {
+                return null;
+            }
+        }
+        if (this.isExpired(key)) {
+            this.remove(key);
+            return null;
+        }
+        return this.cache[key];
+    }
+    set(key, value, duration = null) {
+        this.cache[key] = value;
+        this.expiration[key] = this.calculateExpiration(duration);
+    }
+    remove(key) {
+        delete this.cache[key];
+        delete this.expiration[key];
+    }
+    isExpired(key) {
+        const expiration = this.expiration[key];
+        if (expiration instanceof Date) {
+            return expiration < new Date();
+        }
+        return false;
+    }
+    calculateExpiration(duration) {
+        if (duration === null) {
+            return undefined;
+        }
+        const expiration = new Date();
+        expiration.setSeconds(expiration.getSeconds() + duration);
+        return expiration;
+    }
+}
+
+function from(source) {
+    if (source == null)
+        throw "Source is null.";
+    if (typeof source === 'function')
+        return From.fn(source);
+    if (typeof source[Symbol.iterator] === 'function') {
+        return From.iterable(source);
+    }
+    else if (typeof source === 'object') {
+        return From.object(source);
+    }
+    throw "Invalid source.";
+}
+class From {
+    static object(obj) {
+        return new From(function () {
+            return toPairs(obj);
+        });
+    }
+    static _shallowEqual(obj1, obj2) {
+        const keys1 = Object.keys(obj1);
+        const keys2 = Object.keys(obj2);
+        if (keys1.length !== keys2.length) {
+            return false;
+        }
+        for (let key of keys1) {
+            if (obj1[key] !== obj2[key]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    constructor(fn) {
+        this._fn = fn;
+    }
+    static fn(callable) {
+        return new From(callable);
+    }
+    ;
+    collect() {
+        const cache = Array.from(this);
+        return From.iterable(cache);
+    }
+    static iterable(iterable) {
+        return From.fn(function* () {
+            for (const item of iterable) {
+                yield item;
+            }
+        });
+    }
+    ;
+    map(mapper) {
+        const self = this;
+        return From.fn(function* () {
+            for (let item of self) {
+                yield mapper(item);
+            }
+        });
+    }
+    *[Symbol.iterator]() {
+        yield* this._fn();
+    }
+    all(predicate) {
+        for (let item of this._fn()) {
+            if (!predicate(item)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    any(predicate) {
+        for (let item of this) {
+            if (predicate(item)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    filter(predicate) {
+        const self = this;
+        return From.fn(function* () {
+            for (let item of self) {
+                if (predicate(item)) {
+                    yield item;
+                }
+            }
+        });
+    }
+    contains(value) {
+        for (let item of this) {
+            if (item === value) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // noinspection LoopStatementThatDoesntLoopJS
+    first(predicate) {
+        if (predicate) {
+            for (let item of this) {
+                if (!predicate || predicate(item)) {
+                    return item;
+                }
+            }
+        }
+        else {
+            // noinspection LoopStatementThatDoesntLoopJS
+            for (let item of this) {
+                return item;
+            }
+        }
+        return undefined;
+    }
+    append(item) {
+        const self = this;
+        return From.fn(function* () {
+            for (let element of self) {
+                yield element;
+            }
+            yield item;
+        });
+    }
+    prepend(item) {
+        const self = this;
+        return From.fn(function* () {
+            yield item;
+            for (let element of self) {
+                yield element;
+            }
+        });
+    }
+    at(index) {
+        let idx = 0;
+        for (let item of this) {
+            if (idx++ === index) {
+                return item;
+            }
+        }
+        return undefined;
+    }
+    last(predicate) {
+        let last = undefined;
+        if (predicate)
+            for (let item of this) {
+                if (!predicate || predicate(item)) {
+                    last = item;
+                }
+            }
+        else {
+            for (let item of this) {
+                last = item;
+            }
+        }
+        return last;
+    }
+    mapMany(mapper) {
+        const self = this;
+        return From.fn(function* () {
+            for (const item of self) {
+                const subitems = mapper(item);
+                for (const subitem of subitems) {
+                    yield subitem;
+                }
+            }
+        });
+    }
+    flatten() {
+        const self = this;
+        return From.fn(function* () {
+            for (let item of self) {
+                let temp = item;
+                for (let subitem of temp) {
+                    yield subitem;
+                }
+            }
+        });
+    }
+    sum(mapper) {
+        let total = 0;
+        if (mapper)
+            for (let item of this) {
+                total += mapper(item);
+            }
+        else
+            for (let item of this) {
+                total += item;
+            }
+        return total;
+    }
+    avg(mapper) {
+        let total = 0;
+        let count = 0;
+        if (mapper)
+            for (let item of this) {
+                total += mapper(item);
+                count++;
+            }
+        else
+            for (let item of this) {
+                total += item;
+                count++;
+            }
+        return count > 0 ? total / count : 0;
+    }
+    max(mapper) {
+        let max = -Infinity;
+        for (let item of this) {
+            let value = mapper(item);
+            max = value > max ? value : max;
+        }
+        return max;
+    }
+    min(mapper) {
+        let min = Infinity;
+        for (let item of this) {
+            let value = mapper(item);
+            min = value < min ? value : min;
+        }
+        return min;
+    }
+    maxBy(mapper) {
+        let max = -Infinity;
+        let maxItem;
+        for (let item of this) {
+            let value = mapper(item);
+            if (value > max) {
+                max = value;
+                maxItem = item;
+            }
+        }
+        return maxItem;
+    }
+    minBy(mapper) {
+        let min = Infinity;
+        let minItem;
+        for (let item of this) {
+            let value = mapper(item);
+            if (value < min) {
+                min = value;
+                minItem = item;
+            }
+        }
+        return minItem;
+    }
+    orderBy(mapper) {
+        const array = Array.from(this._fn());
+        array.sort((a, b) => {
+            const aValue = mapper(a);
+            const bValue = mapper(b);
+            return aValue > bValue ? 1 : aValue < bValue ? -1 : 0;
+        });
+        return From.iterable(array);
+    }
+    groupBy(keySelector, equalityComparer) {
+        equalityComparer = (equalityComparer == null ? From._shallowEqual : equalityComparer);
+        const self = this;
+        return From.fn(function* () {
+            const groups = [];
+            for (let item of self) {
+                const key = keySelector(item);
+                let found = false;
+                for (let [entryKey, group] of groups) {
+                    if (equalityComparer(key, entryKey)) {
+                        group.push(item);
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    groups.push([key, [item]]);
+                }
+            }
+            yield* groups.map(([key, values]) => new Grouping(key, values));
+        });
+    }
+    head(n) {
+        const self = this;
+        return From.fn(function* () {
+            let count = 0;
+            for (let item of self) {
+                if (count++ < n) {
+                    yield item;
+                }
+                else {
+                    return;
+                }
+            }
+        });
+    }
+    tail(n) {
+        const self = this;
+        return From.fn(function* () {
+            let buffer = [];
+            for (let item of self) {
+                buffer.push(item);
+                if (buffer.length > n) {
+                    buffer.shift();
+                }
+            }
+            yield* buffer;
+        });
+    }
+    forEach(action) {
+        for (let item of this) {
+            action(item);
+        }
+    }
+    toArray() {
+        return Array.from(this);
+    }
+    instancesOf(type) {
+        return this.filter(item => typeof item === type);
+    }
+    allInstanceOf(type) {
+        for (let item of this) {
+            if (!(item instanceof type)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    distinct(eq_comparer) {
+        if (eq_comparer == null)
+            eq_comparer = From._shallowEqual;
+        const self = this;
+        return From.fn(function* () {
+            const included = [];
+            for (let item of self) {
+                if (!From.iterable(included).any(x => eq_comparer(x, item))) {
+                    included.push(item);
+                    yield item;
+                }
+            }
+        });
+    }
+    insert(item, index) {
+        const self = this;
+        return From.fn(function* () {
+            let i = 0;
+            let inserted = false;
+            for (let existingItem of self) {
+                if (i === index) {
+                    yield item;
+                    inserted = true;
+                }
+                yield existingItem;
+                i++;
+            }
+            if (!inserted) {
+                yield item;
+            }
+        });
+    }
+    skip(n) {
+        const self = this;
+        return From.fn(function* () {
+            let i = 0;
+            for (let item of self) {
+                if (i >= n) {
+                    yield item;
+                }
+                i++;
+            }
+        });
+    }
+    union(other) {
+        const self = this;
+        return From.fn(function* () {
+            yield* self;
+            yield* other;
+        });
+    }
+    innerJoin(other, thisKeySelector, otherKeySelector, resultSelector) {
+        const self = this;
+        return From.fn(() => {
+            const otherByKey = new Map();
+            for (let item of other) {
+                otherByKey.set(otherKeySelector(item), item);
+            }
+            return Array.from(self)
+                .filter(item => otherByKey.has(thisKeySelector(item)))
+                .map(item => resultSelector(item, otherByKey.get(thisKeySelector(item))));
+        });
+    }
+    leftJoin(other, thisKeySelector, otherKeySelector, resultSelector) {
+        const self = this;
+        return From.fn(() => {
+            const otherByKey = new Map();
+            for (let item of other) {
+                otherByKey.set(otherKeySelector(item), item);
+            }
+            return Array.from(self).map(item => resultSelector(item, otherByKey.get(thisKeySelector(item))));
+        });
+    }
+    leftGroupJoin(other, thisKeySelector, otherKeySelector, resultSelector) {
+        const self = this;
+        return From.fn(() => {
+            const otherByKeys = new Map();
+            for (let item of other) {
+                const key = otherKeySelector(item);
+                if (!otherByKeys.has(key)) {
+                    otherByKeys.set(key, []);
+                }
+                otherByKeys.get(key).push(item);
+            }
+            return Array.from(self).map(item => resultSelector(item, otherByKeys.get(thisKeySelector(item)) || []));
+        });
+    }
+    rightGroupJoin(other, thisKeySelector, otherKeySelector, resultSelector) {
+        const self = this;
+        return From.fn(() => {
+            const thisByKeys = new Map();
+            for (let item of self) {
+                const key = thisKeySelector(item);
+                if (!thisByKeys.has(key)) {
+                    thisByKeys.set(key, []);
+                }
+                thisByKeys.get(key).push(item);
+            }
+            return Array.from(other).map(item => resultSelector(thisByKeys.get(otherKeySelector(item)) || [], item));
+        });
+    }
+    rightJoin(other, thisKeySelector, otherKeySelector, resultSelector) {
+        const self = this;
+        return From.fn(() => {
+            const thisByKey = new Map();
+            for (let item of self) {
+                thisByKey.set(thisKeySelector(item), item);
+            }
+            return Array.from(other).map(item => resultSelector(thisByKey.get(otherKeySelector(item)), item));
+        });
+    }
+}
+class Grouping extends From {
+    get key() {
+        return this._key;
+    }
+    constructor(key, values) {
+        super(() => values);
+        this._key = key;
+    }
+}
+
+class Timer {
+    /**
+     * @param callback Callback
+     * @param interval Seconds between calls
+     */
+    constructor(callback, interval) {
+        this._callback = callback;
+        this._interval = interval;
+        this._intervalId = null;
+    }
+    get running() {
+        return this._intervalId !== null && this._intervalId !== undefined;
+    }
+    get interval() {
+        return this._interval;
+    }
+    set interval(value) {
+        if (value != this._interval) {
+            this._interval = value;
+            if (this.running)
+                this.restart();
+        }
+    }
+    get callback() {
+        return this._callback;
+    }
+    set callback(value) {
+        if (value != this._callback) {
+            this._callback = value;
+        }
+    }
+    start() {
+        if (this._intervalId === null) {
+            this._intervalId = setInterval(() => {
+                if (this._callback != null)
+                    this._callback();
+            }, this._interval);
+        }
+    }
+    stop() {
+        if (this._intervalId !== null) {
+            clearInterval(this._intervalId);
+            this._intervalId = null;
+        }
+    }
+    restart() {
+        this.stop();
+        this.start();
+    }
+}
+
+class TimeSpan {
+    constructor(milliseconds) {
+        this.milliseconds = milliseconds;
+    }
+    // Obtener el intervalo de tiempo en segundos
+    seconds() {
+        return this.milliseconds / 1000;
+    }
+    // Obtener el intervalo de tiempo en minutos
+    minutes() {
+        return this.milliseconds / (1000 * 60);
+    }
+    // Obtener el intervalo de tiempo en horas
+    hours() {
+        return this.milliseconds / (1000 * 60 * 60);
+    }
+    // Obtener el intervalo de tiempo en días
+    days() {
+        return this.milliseconds / (1000 * 60 * 60 * 24);
+    }
+    // Obtener el intervalo de tiempo en semanas
+    weeks() {
+        return this.milliseconds / (1000 * 60 * 60 * 24 * 7);
+    }
+    // Constructor estático para crear un TimeSpan desde milisegundos
+    static fromMilliseconds(milliseconds) {
+        return new TimeSpan(milliseconds);
+    }
+    // Constructor estático para crear un TimeSpan desde segundos
+    static fromSeconds(seconds) {
+        return new TimeSpan(seconds * 1000);
+    }
+    // Constructor estático para crear un TimeSpan desde minutos
+    static fromMinutes(minutes) {
+        return new TimeSpan(minutes * 1000 * 60);
+    }
+    // Constructor estático para crear un TimeSpan desde horas
+    static fromHours(hours) {
+        return new TimeSpan(hours * 1000 * 60 * 60);
+    }
+    // Constructor estático para crear un TimeSpan desde días
+    static fromDays(days) {
+        return new TimeSpan(days * 1000 * 60 * 60 * 24);
+    }
+    // Constructor estático para crear un TimeSpan desde semanas
+    static fromWeeks(weeks) {
+        return new TimeSpan(weeks * 1000 * 60 * 60 * 24 * 7);
+    }
+    // Añadir un intervalo de tiempo
+    addMilliseconds(milliseconds) {
+        return new TimeSpan(this.milliseconds + milliseconds);
+    }
+    addSeconds(seconds) {
+        return this.addMilliseconds(seconds * 1000);
+    }
+    addMinutes(minutes) {
+        return this.addMilliseconds(minutes * 1000 * 60);
+    }
+    addHours(hours) {
+        return this.addMilliseconds(hours * 1000 * 60 * 60);
+    }
+    addDays(days) {
+        return this.addMilliseconds(days * 1000 * 60 * 60 * 24);
+    }
+    addWeeks(weeks) {
+        return this.addMilliseconds(weeks * 1000 * 60 * 60 * 24 * 7);
+    }
+    // Restar un intervalo de tiempo
+    subtractMilliseconds(milliseconds) {
+        return new TimeSpan(this.milliseconds - milliseconds);
+    }
+    subtractSeconds(seconds) {
+        return this.subtractMilliseconds(seconds * 1000);
+    }
+    subtractMinutes(minutes) {
+        return this.subtractMilliseconds(minutes * 1000 * 60);
+    }
+    subtractHours(hours) {
+        return this.subtractMilliseconds(hours * 1000 * 60 * 60);
+    }
+    subtractDays(days) {
+        return this.subtractMilliseconds(days * 1000 * 60 * 60 * 24);
+    }
+    subtractWeeks(weeks) {
+        return this.subtractMilliseconds(weeks * 1000 * 60 * 60 * 24 * 7);
+    }
+    // Añadir otro TimeSpan
+    add(other) {
+        return new TimeSpan(this.milliseconds + other.milliseconds);
+    }
+    // Restar otro TimeSpan
+    subtract(other) {
+        return new TimeSpan(this.milliseconds - other.milliseconds);
+    }
+    // Añadir un intervalo de tiempo a una fecha
+    addTo(date) {
+        return new Date(date.getTime() + this.milliseconds);
+    }
+    // Restar un intervalo de tiempo de una fecha
+    subtractFrom(date) {
+        return new Date(date.getTime() - this.milliseconds);
+    }
+    static fromDifference(earlierDate, laterDate) {
+        return new TimeSpan(laterDate.getTime() - earlierDate.getTime());
+    }
+    format(format = 'hh:mm:ss') {
+        const formatLower = format.toLowerCase();
+        const hasHours = formatLower.includes("h");
+        const hasMinutes = formatLower.includes("m");
+        let hours = 0, minutes = 0, seconds = Math.floor(this.milliseconds / 1000);
+        if (hasHours) {
+            hours = Math.floor(seconds / 3600);
+            seconds -= hours * 3600;
+        }
+        if (hasMinutes) {
+            minutes = Math.floor(seconds / 60);
+            seconds -= minutes * 60;
+        }
+        const hoursPadded = String(hours).padStart(2, '0');
+        const minutesPadded = String(minutes).padStart(2, '0');
+        const secondsPadded = String(seconds).padStart(2, '0');
+        return formatLower
+            .replace('hh', hoursPadded)
+            .replace('h', hours.toString())
+            .replace('mm', minutesPadded)
+            .replace('m', minutes.toString())
+            .replace('ss', secondsPadded)
+            .replace('s', seconds.toString());
+    }
+    eq(other) {
+        return this.milliseconds === other.milliseconds;
+    }
+    le(other) {
+        return this.milliseconds <= other.milliseconds;
+    }
+    lt(other) {
+        return this.milliseconds < other.milliseconds;
+    }
+    ge(other) {
+        return this.milliseconds >= other.milliseconds;
+    }
+    gt(other) {
+        return this.milliseconds > other.milliseconds;
+    }
+    multiply(number) {
+        return new TimeSpan(this.milliseconds * number);
+    }
+    divide(number) {
+        return new TimeSpan(this.milliseconds / number);
+    }
+    abs() {
+        return new TimeSpan(Math.abs(this.milliseconds));
+    }
+    isInfinite() {
+        return this.milliseconds === Number.POSITIVE_INFINITY || this.milliseconds === Number.NEGATIVE_INFINITY;
+    }
+    // Determinar si es un TimeSpan infinitamente positivo
+    isPositiveInfinite() {
+        return this.milliseconds === Number.POSITIVE_INFINITY;
+    }
+    // Determinar si es un TimeSpan infinitamente negativo
+    isNegativeInfinite() {
+        return this.milliseconds === Number.NEGATIVE_INFINITY;
+    }
+}
+TimeSpan.INFINITE = new TimeSpan(Number.POSITIVE_INFINITY);
+TimeSpan.NEGATIVE_INFINITE = new TimeSpan(Number.NEGATIVE_INFINITY);
+
+class Lazy {
+    constructor(getter) {
+        this._valueCreated = false;
+        this._value = null;
+        this._factoryMethod = getter;
+    }
+    get valueCreated() {
+        return this._valueCreated;
+    }
+    async getValue() {
+        if (!this._valueCreated) {
+            this._value = await promisify(this._factoryMethod);
+            this._valueCreated = true;
+        }
+        return this._value;
+    }
+    reset() {
+        this._valueCreated = false;
+        this._value = null;
+    }
+}
+
+exports.CacheDictionary = CacheDictionary;
+exports.From = From;
+exports.Lazy = Lazy;
+exports.Pair = Pair;
+exports.TimeSpan = TimeSpan;
+exports.Timer = Timer;
+exports.ajaxSubmission = ajaxSubmission;
+exports.ajaxSubmit = ajaxSubmit;
+exports.clamp = clamp;
+exports.deepClone = deepClone;
+exports.ensurePrefix = ensurePrefix;
+exports.ensureSuffix = ensureSuffix;
+exports.from = from;
+exports.isArray = isArray;
+exports.isBigInt = isBigInt;
+exports.isBoolean = isBoolean;
+exports.isEmpty = isEmpty;
+exports.isEmptyOrWhitespace = isEmptyOrWhitespace;
+exports.isFunction = isFunction;
+exports.isIterable = isIterable;
+exports.isNull = isNull;
+exports.isNullOrUndefined = isNullOrUndefined;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isUndefined = isUndefined;
+exports.lerp = lerp;
+exports.objectToFormData = objectToFormData;
+exports.promisify = promisify;
+exports.toPairs = toPairs;
+//# sourceMappingURL=index.cjs.js.map