@develia/commons 0.3.44 → 0.4.0

package/dist/develia-commons.js

@@ -1,1690 +0,0 @@
-(function (exports) {
-    'use strict';
-
-    /**
-     * Represents different types in JavaScript.
-     * @enum {string}
-     */
-    exports.Type = void 0;
-    (function (Type) {
-        Type["Undefined"] = "undefined";
-        Type["Number"] = "number";
-        Type["String"] = "string";
-        Type["Boolean"] = "boolean";
-        Type["Object"] = "object";
-        Type["Function"] = "function";
-        Type["Symbol"] = "symbol";
-        Type["BigInt"] = "bigint";
-        Type["Null"] = "null";
-    })(exports.Type || (exports.Type = {}));
-
-    /**
-     * Represents a pair of key and value.
-     *
-     * @template TKey The type of the key.
-     * @template TValue The type of the value.
-     */
-    class KeyValuePair {
-        get value() {
-            return this._value;
-        }
-        get key() {
-            return this._key;
-        }
-        constructor(key, value) {
-            this._key = key;
-            this._value = value;
-        }
-    }
-
-    // noinspection JSUnusedGlobalSymbols
-    /**
-     * Checks if an object is iterable.
-     *
-     * @param {any} obj - The object to check.
-     * @return {boolean} - Returns true if the object is iterable, otherwise false.
-     */
-    function isIterable(obj) {
-        return obj[Symbol.iterator] === 'function';
-    }
-    /**
-     * Checks if a given value is a string.
-     *
-     * @param {*} value - The value to check.
-     * @return {boolean} - Returns true if the value is a string, otherwise returns false.
-     */
-    function isString(value) {
-        return typeof value === 'string';
-    }
-    /**
-     * Checks if a value is a number.
-     *
-     * @param {any} value - The value to check.
-     * @return {boolean} - Returns true if the value is a number, otherwise false.
-     */
-    function isNumber(value) {
-        return typeof value === 'number';
-    }
-    /**
-     * Checks if a given value is a boolean.
-     *
-     * @param {any} value - The value to be checked.
-     *
-     * @return {boolean} - Returns true if the value is a boolean, otherwise false.
-     */
-    function isBoolean(value) {
-        return typeof value === 'boolean';
-    }
-    /**
-     * Checks if a value is an object.
-     * @param {any} value - The value to be checked.
-     * @returns {boolean} - Returns true if the value is an object, otherwise returns false.
-     */
-    function isObject(value) {
-        return value != null && typeof value === 'object' && !Array.isArray(value);
-    }
-    /**
-     * Determines if a value is an array.
-     *
-     * @param value - The value to be checked.
-     *
-     * @return Whether the value is an array.
-     */
-    function isArray(value) {
-        return Array.isArray(value);
-    }
-    /**
-     * Checks if a value is a function.
-     *
-     * @param {any} value - The value to be checked.
-     * @return {boolean} - Returns true if the value is a function, otherwise returns false.
-     */
-    function isFunction(value) {
-        return typeof value === 'function';
-    }
-    /**
-     * Compares two objects or arrays to check if they have the same fields and values,
-     * or the same elements if they are arrays (deep equality check).
-     *
-     * @param {any} a - The first object or array.
-     * @param {any} b - The second object or array.
-     * @return {boolean} - Returns true if the objects/arrays are deeply equal, otherwise false.
-     */
-    function deepEqual(a, b) {
-        if (a === b) {
-            return true;
-        }
-        if (a === null || b === null || typeof a !== typeof b) {
-            return false;
-        }
-        if (Array.isArray(a) && Array.isArray(b)) {
-            if (a.length !== b.length) {
-                return false;
-            }
-            for (let i = 0; i < a.length; i++) {
-                if (!deepEqual(a[i], b[i])) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        if (typeof a === "object" && typeof b === "object") {
-            const keysA = Object.keys(a);
-            const keysB = Object.keys(b);
-            if (keysA.length !== keysB.length) {
-                return false;
-            }
-            for (const key of keysA) {
-                if (!keysB.includes(key) || !deepEqual(a[key], b[key])) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Submits an HTML form programmatically using the specified HTTP method (default is POST),
-     * without using AJAX. Supports nested objects and arrays using bracket notation (e.g., `user[name]`, `tags[]`).
-     *
-     * @param url - The destination URL where the form will be submitted.
-     * @param data - An object containing key-value pairs. Supports nested structures and arrays.
-     * @param method - HTTP method to use: 'POST' or 'GET' (default: 'POST').
-     * @param target - Optional parameter specifying the target for the form submission (e.g., '_blank', '_self', '_parent', '_top').
-     */
-    function submitForm(url, data, method = 'POST', target) {
-        const form = document.createElement('form');
-        form.method = method.toUpperCase();
-        form.action = url;
-        form.style.display = 'none';
-        if (target) {
-            form.target = target;
-        }
-        /**
-         * Recursively appends inputs to the form, supporting nested keys and arrays.
-         * @param keyPrefix - Key path, e.g., 'user[name]' or 'tags[]'
-         * @param value - The value to append (can be nested)
-         */
-        const appendInputs = (keyPrefix, value) => {
-            if (Array.isArray(value)) {
-                value.forEach(val => {
-                    appendInputs(`${keyPrefix}[]`, val);
-                });
-            }
-            else if (typeof value === 'object' && value !== null) {
-                for (const subKey in value) {
-                    if (value.hasOwnProperty(subKey)) {
-                        appendInputs(`${keyPrefix}[${subKey}]`, value[subKey]);
-                    }
-                }
-            }
-            else {
-                const input = document.createElement('input');
-                input.type = 'hidden';
-                input.name = keyPrefix;
-                input.value = String(value);
-                form.appendChild(input);
-            }
-        };
-        for (const key in data) {
-            if (data.hasOwnProperty(key)) {
-                appendInputs(key, data[key]);
-            }
-        }
-        document.body.appendChild(form);
-        form.submit();
-    }
-    /**
-     * Compares two objects or arrays to check if they have the same immediate fields and values,
-     * or the same immediate elements if they are arrays (shallow equality check).
-     *
-     * @param {any} a - The first object or array.
-     * @param {any} b - The second object or array.
-     * @return {boolean} - Returns true if the objects/arrays are shallowly equal, otherwise false.
-     */
-    function shallowEqual(a, b) {
-        if (a === b) {
-            return true;
-        }
-        if (a === null || b === null || typeof a !== typeof b) {
-            return false;
-        }
-        if (Array.isArray(a) && Array.isArray(b)) {
-            if (a.length !== b.length) {
-                return false;
-            }
-            return a.every((value, index) => value === b[index]);
-        }
-        if (typeof a === "object" && typeof b === "object") {
-            const keysA = Object.keys(a);
-            const keysB = Object.keys(b);
-            if (keysA.length !== keysB.length) {
-                return false;
-            }
-            return keysA.every(key => b.hasOwnProperty(key) && a[key] === b[key]);
-        }
-        return false;
-    }
-    /**
-     * Pauses the execution of an asynchronous function for a specified duration.
-     *
-     * @param {number} ms - The delay duration in milliseconds.
-     * @return {Promise<void>} A promise that resolves after the specified delay.
-     */
-    async function delay(ms) {
-        await new Promise(resolve => setTimeout(resolve, ms));
-    }
-    /**
-     * Checks if a value is undefined.
-     *
-     * @param {any} value - The value to check.
-     * @returns {boolean} - True if the value is undefined, false otherwise.
-     */
-    function isUndefined(value) {
-        return typeof value === 'undefined';
-    }
-    /**
-     * Checks if a value is defined or not.
-     *
-     * @param {any} value - The value to be checked.
-     *
-     * @return {boolean} - True if the value is defined, false otherwise.
-     */
-    function isDefined(value) {
-        return typeof value !== 'undefined';
-    }
-    /**
-     * Checks if a given value is null.
-     *
-     * @param {any} value - The value to check for null.
-     * @return {boolean} - Returns true if the value is null, otherwise returns false.
-     */
-    function isNull(value) {
-        return value === null;
-    }
-    /**
-     * Determines whether the given value is of type bigint.
-     * @param {any} value - The value to be checked.
-     * @return {boolean} - Returns true if the value is of type bigint, false otherwise.
-     */
-    function isBigInt(value) {
-        return typeof value === 'bigint';
-    }
-    /**
-     * Checks if a given value is a symbol.
-     *
-     * @param {any} value - The value to be checked.
-     * @return {boolean} - Returns true if the value is a symbol, false otherwise.
-     */
-    function isSymbol(value) {
-        return typeof value === 'symbol';
-    }
-    /**
-     * Checks if a value is null or undefined.
-     *
-     * @param {any} value - The value to check.
-     * @return {boolean} - Returns true if the value is null or undefined, false otherwise.
-     */
-    function isNullOrUndefined(value) {
-        return value === null || typeof value === 'undefined';
-    }
-    /**
-     * Checks if a given value is empty.
-     *
-     * @param {any} value - The value to check.
-     * @return {boolean} - Returns true if the value is empty, otherwise returns false.
-     */
-    function isEmpty(value) {
-        return (Array.isArray(value) && value.length === 0) ||
-            (typeof value === 'string' && value === '') ||
-            value === null || typeof value === 'undefined';
-    }
-    /**
-     * Check if a value is empty or contains only whitespace characters.
-     *
-     * @param {any} value - The value to check.
-     * @return {boolean} Returns true if the value is empty or contains only whitespace characters, otherwise returns false.
-     */
-    function isEmptyOrWhitespace(value) {
-        return (Array.isArray(value) && value.length === 0) ||
-            (typeof value === 'string' && value.trim() === '') ||
-            value === null || typeof value === 'undefined';
-    }
-    /**
-     * Submits a form via AJAX and returns a Promise that resolves to the Response object.
-     *
-     * @param {HTMLFormElement | string} selectorOrElement - The form element or selector.
-     * @return {Promise<Response>} A Promise that resolves to the Response object.
-     * @throws {Error} If the element is invalid.
-     */
-    async function ajaxSubmit(selectorOrElement) {
-        const form = typeof selectorOrElement === 'string'
-            ? document.querySelector(selectorOrElement)
-            : selectorOrElement;
-        if (!(form instanceof HTMLFormElement)) {
-            throw new Error("Invalid element.");
-        }
-        // Crear un objeto FormData a partir del formulario
-        return await fetch(form.action, {
-            method: form.method,
-            body: new FormData(form),
-        });
-    }
-    /**
-     * Converts an object into an array of key-value pairs.
-     *
-     * @param {Record<string, any>} obj - The object to convert.
-     * @return {KeyValuePair<string, any>[]} - The array of key-value pairs.
-     */
-    function toPairs(obj) {
-        let output = [];
-        for (const key in obj) {
-            output.push(new KeyValuePair(key, obj[key]));
-        }
-        return output;
-    }
-    /**
-     * Converts a given thing into a Promise.
-     * @template T
-     * @param {any} thing - The thing to be converted into a Promise.
-     * @returns {Promise<T>} - A Promise representing the given thing.
-     */
-    function promisify(thing) {
-        if (thing instanceof Promise)
-            return thing;
-        if (isFunction(thing)) {
-            return new Promise((resolve, reject) => {
-                try {
-                    const result = thing();
-                    resolve(result);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        }
-        return Promise.resolve(thing);
-    }
-    function ajaxSubmission(selectorOrElement, onSuccess = undefined, onFailure = undefined) {
-        const form = typeof selectorOrElement === 'string'
-            ? document.querySelector(selectorOrElement)
-            : selectorOrElement;
-        if (!(form instanceof HTMLFormElement)) {
-            return;
-        }
-        form.addEventListener('submit', async (event) => {
-            event.preventDefault();
-            let promise = ajaxSubmit(form);
-            if (promise) {
-                if (onSuccess)
-                    promise = promise.then(onSuccess);
-                if (onFailure)
-                    promise.catch(onFailure);
-            }
-        });
-    }
-    /**
-     * Creates a deep clone of the given object.
-     * @template T
-     * @param {T} obj - The object to clone.
-     * @return {T} - The deep clone of the given object.
-     */
-    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;
-    }
-    /**
-     * Returns the type of the given value.
-     *
-     * @param {any} value - The value to determine the type of.
-     * @return {Type} - The type of the given value.
-     */
-    function getType(value) {
-        return value === null ? exports.Type.Null : exports.Type[typeof value];
-    }
-    function formToObject(form) {
-        const fd = new FormData(form);
-        const out = {};
-        for (const [key, value] of fd.entries()) {
-            if (key in out) {
-                const current = out[key];
-                if (Array.isArray(current)) {
-                    current.push(value);
-                }
-                else {
-                    out[key] = [current, value];
-                }
-            }
-            else {
-                out[key] = value;
-            }
-        }
-        return out;
-    }
-    /**
-     * Converts an object to `FormData` format recursively.
-     *
-     * @param {Record<string, any>} data - The object data to convert.
-     * @param {FormData} formData - The `FormData` instance to append data to.
-     * @param {string} parentKey - The parent key to append to child keys in the `FormData`.
-     * @returns {FormData} - The `FormData` instance with the converted data.
-     */
-    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;
-    }
-    /**
-     * Converts an object into FormData.
-     *
-     * @param {Record<string, any>} data - The object to be converted into FormData.
-     * @return {FormData} - The FormData object representing the converted data.
-     */
-    function objectToFormData(data) {
-        let formData = new FormData();
-        return _objectToFormData(data, formData);
-    }
-
-    /**
-     * Ensures that a given string has a specific prefix.
-     *
-     * @param {string} str - The string to ensure the prefix on.
-     * @param {string} prefix - The prefix to ensure on the string.
-     * @return {string} - The resulting string with the ensured prefix.
-     */
-    function ensurePrefix(str, prefix) {
-        if (!str.startsWith(prefix))
-            return prefix + str;
-        return str;
-    }
-    /**
-     * Ensures that a string ends with a specified suffix.
-     *
-     * @param {string} str - The original string.
-     * @param {string} suffix - The suffix to ensure.
-     * @return {string} - The modified string with the suffix added if it was not already present.
-     */
-    function ensureSuffix(str, suffix) {
-        if (!str.endsWith(suffix))
-            return str + suffix;
-        return str;
-    }
-    /**
-     * Formats a string using a template and provided arguments.
-     *
-     * @param {string} template - The template string containing placeholders.
-     * @param {any[]} args - Optional arguments to replace the placeholders in the template.
-     * @return {string} The formatted string.
-     */
-    function format(template, ...args) {
-        let regex;
-        if (args.length === 1 && typeof args[0] === 'object') {
-            args = args[0];
-            regex = /{(.+?)}/g;
-        }
-        else {
-            regex = /{(\d+?)}/g;
-        }
-        return template.replace(regex, (match, key) => {
-            return typeof args[key] !== 'undefined' ? args[key] : "";
-        });
-    }
-
-    /**
-     * Linearly interpolates a number between two ranges.
-     *
-     * @param {number} n - The number to interpolate.
-     * @param {number} inMin - The minimum value of the input range.
-     * @param {number} inMax - The maximum value of the input range.
-     * @param {number} outMin - The minimum value of the output range.
-     * @param {number} outMax - The maximum value of the output range.
-     *
-     * @return {number} - The interpolated value.
-     */
-    function lerp(n, inMin, inMax, outMin, outMax) {
-        return outMin + (outMax - outMin) * ((n - inMin) / (inMax - inMin));
-    }
-    /**
-     * Clamps a number between a minimum and maximum value.
-     *
-     * @param {number} n - The value to be clamped.
-     * @param {number} min - The minimum value.
-     * @param {number} max - The maximum value.
-     * @return {number} The clamped value.
-     */
-    function clamp(n, min, max) {
-        if (n <= min)
-            return min;
-        if (n >= max)
-            return max;
-        return n;
-    }
-
-    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;
-        }
-    }
-
-    var Order;
-    (function (Order) {
-        Order["Ascending"] = "asc";
-        Order["Descending"] = "desc";
-    })(Order || (Order = {}));
-    var Order$1 = Order;
-
-    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);
-            });
-        }
-        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 = undefined) {
-            for (let item of this) {
-                if (predicate == null || predicate(item)) {
-                    return true;
-                }
-            }
-            return false;
-        }
-        get length() {
-            return this.count();
-        }
-        count(predicate = undefined) {
-            let output = 0;
-            for (let item of this) {
-                if (predicate == null || predicate(item)) {
-                    output++;
-                }
-            }
-            return output;
-        }
-        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(item)) {
-                        return item;
-                    }
-                }
-            }
-            else {
-                // noinspection LoopStatementThatDoesntLoopJS
-                for (let item of this) {
-                    return item;
-                }
-            }
-            return undefined;
-        }
-        // noinspection LoopStatementThatDoesntLoopJS
-        single(predicate) {
-            let found = false;
-            let output = null;
-            if (predicate) {
-                for (let item of this) {
-                    if (predicate(item)) {
-                        if (found) {
-                            throw new Error("Sequence contains more than one element.");
-                        }
-                        found = true;
-                        output = item;
-                    }
-                }
-            }
-            else {
-                // noinspection LoopStatementThatDoesntLoopJS
-                for (let item of this) {
-                    if (found) {
-                        throw new Error("Sequence contains more than one element.");
-                    }
-                    found = true;
-                    output = item;
-                }
-            }
-            return output;
-        }
-        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, order = Order$1.Ascending) {
-            const array = Array.from(this._fn());
-            if (order == Order$1.Ascending) {
-                array.sort((a, b) => {
-                    const aValue = mapper(a);
-                    const bValue = mapper(b);
-                    return aValue > bValue ? 1 : bValue > aValue ? -1 : 0;
-                });
-            }
-            else if (order == Order$1.Descending) {
-                array.sort((a, b) => {
-                    const aValue = mapper(a);
-                    const bValue = mapper(b);
-                    return aValue > bValue ? 1 : bValue < aValue ? -1 : 0;
-                });
-            }
-            else {
-                throw new Error("invalid order argument");
-            }
-            return From.iterable(array);
-        }
-        groupBy(keySelector, equalityComparer) {
-            equalityComparer = (equalityComparer == null ? 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);
-        }
-        toRecord(keySelector, valueSelector) {
-            const output = {};
-            for (let item of this) {
-                output[keySelector(item)] = valueSelector(item);
-            }
-            return output;
-        }
-        toMap(keySelector, valueSelector) {
-            const map = new Map();
-            for (let item of this) {
-                const key = keySelector(item);
-                const value = valueSelector(item);
-                map.set(key, value);
-            }
-            return map;
-        }
-        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 = 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;
-        }
-    }
-
-    /**
-     * A class representing a timer that executes a callback function at a specified interval.
-     */
-    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();
-        }
-    }
-
-    /**
-     * Represents a duration of time in milliseconds.
-     */
-    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);
-
-    /**
-     * Represents a lazy value that is created only when it is accessed for the first time.
-     * @template T The type of the lazy value.
-     */
-    class Lazy {
-        constructor(getter) {
-            this._valueCreated = false;
-            this._value = null;
-            this._factoryMethod = getter;
-        }
-        get valueCreated() {
-            return this._valueCreated;
-        }
-        get value() {
-            if (!this._valueCreated) {
-                this._value = this._factoryMethod();
-                this._valueCreated = true;
-            }
-            return this._value;
-        }
-        reset() {
-            this._valueCreated = false;
-            this._value = null;
-        }
-    }
-
-    /**
-     * Represents a class for manipulating an array of items.
-     *
-     * @template T - The type of items in the array.
-     * @deprecated
-     */
-    class ArrayManipulator {
-        constructor(array) {
-            this._array = array;
-        }
-        [Symbol.iterator]() {
-            return this._array[Symbol.iterator]();
-        }
-        /**
-         * Retrieves or sets the value at the specified index in the array.
-         * If `item` is not provided, returns the value at index `n`.
-         * If `item` is provided, sets the value at index `n` to the provided value.
-         *
-         * @param {number} n - The index at which to retrieve or set the value.
-         * @param {T | undefined} [item] - The value to set at index `n`, if provided.
-         *
-         * @return {T | void} - If `item` is not provided, returns the value at index `n`.
-         *                    - If `item` is provided, does not return anything.
-         */
-        at(n, item = undefined) {
-            if (item === undefined)
-                return this._array[n];
-            else
-                this._array[n] = item;
-        }
-        /**
-         * Removes the specified item from the array.
-         *
-         * @param {T} item - The item to be removed.
-         * @returns {ArrayManipulator<T>} - The updated ArrayManipulator instance.
-         */
-        remove(item) {
-            const index = this._array.indexOf(item);
-            if (index !== -1) {
-                this._array.splice(index, 1);
-            }
-            return this;
-        }
-        /**
-         * Applies a mapping function to each element in the array, transforming it into a new array.
-         * @template R
-         * @param {UnaryFunction<T, R>} mapFn - The function to be applied to each element.
-         * @return {ArrayManipulator<R>} - The new ArrayManipulator instance with the mapped elements.
-         */
-        map(mapFn) {
-            for (let i = 0; i < this._array.length; i++) {
-                this._array[i] = mapFn(this._array[i]);
-            }
-            return this;
-        }
-        /**
-         * Filters the elements of the array based on a given filter function.
-         * The filter function should return a boolean value, indicating whether the element should be included in the filtered array or not.
-         *
-         * @param {Predicate<T>} filterFn - The function that will be used to filter the elements. It should accept an element of type T and return a boolean value.
-         * @returns {ArrayManipulator<T>} - The filtered ArrayManipulator instance with the elements that passed the filter.
-         */
-        filter(filterFn) {
-            for (let i = 0; i < this._array.length; i++) {
-                if (!filterFn(this._array[i])) {
-                    this._array.splice(i, 1);
-                    i--;
-                }
-            }
-            return this;
-        }
-        head(n) {
-            this._array.splice(n);
-            return this;
-        }
-        slice(start, count = undefined) {
-            this._array.splice(0, start); // Eliminar los primeros elementos hasta `start`
-            if (count !== undefined) {
-                this._array.splice(count); // Mantener solo `count` elementos restantes
-            }
-            return this;
-        }
-        mapMany(mapper) {
-            let i = 0;
-            while (i < this._array.length) {
-                let mappedItems = mapper(this._array[i]);
-                if (!Array.isArray(mappedItems))
-                    mappedItems = Array.from(mappedItems);
-                this._array.splice(i, 1, ...mappedItems);
-                i += mappedItems.length;
-            }
-            return this;
-        }
-        tail(n) {
-            const start = this._array.length - n;
-            this._array.splice(0, start);
-            return this;
-        }
-        /**
-         * Appends one or more items to the array.
-         *
-         * @param {...T} items - The items to be appended to the array.
-         * @return {ArrayManipulator<T>} - The ArrayManipulator instance.
-         */
-        append(...items) {
-            this._array.push(...items);
-            return this;
-        }
-        /**
-         * Prepend items to the beginning of the array.
-         *
-         * @param {...T} items - The items to be prepended.
-         * @return {ArrayManipulator<T>} The ArrayManipulator instance.
-         */
-        prepend(...items) {
-            this._array.unshift(...items);
-            return this;
-        }
-        get array() {
-            return this._array;
-        }
-    }
-    /**
-     * Creates an instance of ArrayManipulator with the given array.
-     * @template T
-     * @param {T[]} array - The input array.
-     * @return {ArrayManipulator<T>} - An instance of the ArrayManipulator class.
-     */
-    function array(array) {
-        return new ArrayManipulator(array);
-    }
-
-    class AsyncPoolExecutor {
-        get maxConcurrency() {
-            return this._maxConcurrency;
-        }
-        set maxConcurrency(value) {
-            this._maxConcurrency = value;
-        }
-        /**
-         * @param {number} maxConcurrency - The maximum number of concurrent tasks allowed.
-         * @param {number} [checkInterval=50] - The interval, in milliseconds, to check for capacity to run new tasks. Defaults to 50 ms.
-         */
-        constructor(maxConcurrency, checkInterval = 50) {
-            this._taskQueue = [];
-            this._maxConcurrency = maxConcurrency;
-            this._checkIntervalMs = checkInterval;
-            this._activeTasks = 0;
-        }
-        /**
-         * Submits a deferred task to a queue for asynchronous execution and returns a Promise resolving to its result.
-         * @template T
-         * @param {Supplier<T>} task - The deferred task to be executed asynchronously.
-         */
-        submit(task) {
-            this._taskQueue.push(task);
-            if (this._proccess != null)
-                return;
-            this._proccess = setTimeout(async () => {
-                while (this._taskQueue.length > 0) {
-                    while (this._activeTasks >= this._maxConcurrency) {
-                        await delay(this._checkIntervalMs);
-                    }
-                    const task = this._taskQueue.shift();
-                    if (task) {
-                        this._activeTasks++;
-                        setTimeout(async () => {
-                            try {
-                                await task();
-                            }
-                            finally {
-                                this._activeTasks--;
-                            }
-                        });
-                    }
-                }
-                this._proccess = null;
-            }, 0);
-        }
-        /**
-         * Waits until all tasks (both queued and active) are completed.
-         * This method resolves only when there are no pending tasks.
-         *
-         * @return {Promise<void>} A promise that resolves when all tasks are complete.
-         */
-        async shutdown() {
-            while (this._taskQueue.length > 0 || this._activeTasks > 0) {
-                await delay(this._checkIntervalMs);
-            }
-        }
-    }
-
-    class CleanURLSearchParams extends URLSearchParams {
-        constructor(params) {
-            // Filtrar `null` y `undefined` antes de pasarlos al constructor de URLSearchParams
-            const cleanParams = Object.fromEntries(Object.entries(params || {}).filter(([_, value]) => value !== null && value !== undefined));
-            super(cleanParams);
-        }
-    }
-
-    class Stopwatch {
-        constructor() {
-            this.startTime = null;
-            this.elapsedTime = null;
-        }
-        /*static measure<T>(callback: () => T, measure: { value: TimeSpan | null }): T {
-            const stopwatch = new Stopwatch();
-            stopwatch.start();
-            try {
-                return callback();
-            } finally {
-                stopwatch.stop();
-                measure.value = stopwatch.getElapsedTime();
-            }
-        }*/
-        start() {
-            this.startTime = performance.now();
-            this.elapsedTime = null;
-        }
-        stop() {
-            if (this.startTime !== null) {
-                this.elapsedTime = performance.now() - this.startTime;
-                this.startTime = null;
-            }
-        }
-        resume() {
-            if (this.elapsedTime !== null) {
-                this.startTime = performance.now() - this.elapsedTime;
-                this.elapsedTime = null;
-            }
-        }
-        getElapsedTime() {
-            var _a;
-            if (this.startTime !== null) {
-                return TimeSpan.fromMilliseconds(performance.now() - this.startTime);
-            }
-            return TimeSpan.fromMilliseconds((_a = this.elapsedTime) !== null && _a !== void 0 ? _a : 0.0);
-        }
-    }
-
-    /**
-     * Removes all given values from the provided array and returns the number of removed elements.
-     * The operation mutates the original array.
-     * @template T
-     * @param {Array<T>} array - The array to modify by removing specified items.
-     * @param {...T} items - The values to remove from the array.
-     * @return {number} The number of elements removed from the array.
-     */
-    function pull(array, ...items) {
-        let output = 0;
-        for (const item of items) {
-            const index = array.indexOf(item);
-            if (index !== -1) {
-                array.splice(index, 1);
-                output++;
-            }
-        }
-        return output;
-    }
-
-    exports.ArrayManipulator = ArrayManipulator;
-    exports.AsyncPoolExecutor = AsyncPoolExecutor;
-    exports.CacheDictionary = CacheDictionary;
-    exports.CleanURLSearchParams = CleanURLSearchParams;
-    exports.From = From;
-    exports.KeyValuePair = KeyValuePair;
-    exports.Lazy = Lazy;
-    exports.Order = Order$1;
-    exports.Stopwatch = Stopwatch;
-    exports.TimeSpan = TimeSpan;
-    exports.Timer = Timer;
-    exports.ajaxSubmission = ajaxSubmission;
-    exports.ajaxSubmit = ajaxSubmit;
-    exports.array = array;
-    exports.clamp = clamp;
-    exports.deepClone = deepClone;
-    exports.deepEqual = deepEqual;
-    exports.delay = delay;
-    exports.ensurePrefix = ensurePrefix;
-    exports.ensureSuffix = ensureSuffix;
-    exports.formToObject = formToObject;
-    exports.format = format;
-    exports.from = from;
-    exports.getType = getType;
-    exports.isArray = isArray;
-    exports.isBigInt = isBigInt;
-    exports.isBoolean = isBoolean;
-    exports.isDefined = isDefined;
-    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.pull = pull;
-    exports.shallowEqual = shallowEqual;
-    exports.submitForm = submitForm;
-    exports.toPairs = toPairs;
-
-})(this.window = this.window || {});