@develia/commons 0.3.16 → 0.3.19

package/dist/develia-commons.js

@@ -0,0 +1,1092 @@
+(function (exports) {
+    'use strict';
+
+    var Type;
+    (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 || (Type = {}));
+    var Type$1 = Type;
+
+    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 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 isDefined(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';
+    }
+    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),
+        });
+    }
+    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 (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 = null, onFailure = null) {
+        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);
+            }
+        });
+    }
+    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);
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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));
+    }
+    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;
+        }
+    }
+
+    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;
+        }
+    }
+
+    class ArrayManipulator {
+        constructor(array) {
+            this._array = array;
+        }
+        [Symbol.iterator]() {
+            return this._array[Symbol.iterator]();
+        }
+        at(n, item = undefined) {
+            if (item === undefined)
+                return this._array[n];
+            else
+                this._array[n] = item;
+        }
+        remove(item) {
+            const index = this._array.indexOf(item);
+            if (index !== -1) {
+                this._array.splice(index, 1);
+            }
+            return this;
+        }
+        map(mapFn) {
+            for (let i = 0; i < this._array.length; i++) {
+                this._array[i] = mapFn(this._array[i]);
+            }
+            return this;
+        }
+        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;
+        }
+        append(...items) {
+            this._array.push(...items);
+            return this;
+        }
+        prepend(...items) {
+            this._array.unshift(...items);
+            return this;
+        }
+        get array() {
+            return this._array;
+        }
+    }
+    function array(array) {
+        return new ArrayManipulator(array);
+    }
+
+    exports.ArrayManipulator = ArrayManipulator;
+    exports.CacheDictionary = CacheDictionary;
+    exports.From = From;
+    exports.Lazy = Lazy;
+    exports.Pair = Pair;
+    exports.TimeSpan = TimeSpan;
+    exports.Timer = Timer;
+    exports.Type = Type$1;
+    exports.ajaxSubmission = ajaxSubmission;
+    exports.ajaxSubmit = ajaxSubmit;
+    exports.array = array;
+    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.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.toPairs = toPairs;
+
+})(this.window = this.window || {});