@develia/commons 0.3.3 → 0.3.5

package/dist/index.umd.js

@@ -1,998 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.develia = {}));
-})(this, (function (exports) { 'use strict';
-
-    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;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
-//# sourceMappingURL=index.umd.js.map