tiny-essentials 1.28.19 → 1.29.0

package/dist/v1/basics/objFilter.mjs

@@ -1,5 +1,9 @@
 // @ts-nocheck
 import { isJsonObject } from './objChecker.mjs';
+/**
+ * A flag indicating if the current environment is a web browser.
+ * @type {boolean}
+ */
 const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
 /**
  * An object containing type validation functions and their evaluation order.
@@ -9,32 +13,76 @@ const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'u
  *
  * The `order` array defines the priority in which types should be checked,
  * which can be useful for functions that infer types in a consistent manner.
- *
  */
 const typeValidator = {
+    /**
+     * A registry where keys are type names and values are their validation and cloning logic.
+     * @type {Record<string, ObjTypeRegistry<any, any>>}
+     */
     items: {},
     /**
-     * Evaluation order of the type checkers.
+     * The sequence in which type validators are checked.
+     * The first validator to return true for a value determines the type name.
      * @type {string[]}
-     * */
+     */
     order: [],
 };
-/** @typedef {Object.<string, (val: any) => *>} ExtendObjType */
-/** @typedef {Array<[string, (val: any) => *]>} ExtendObjTypeArray */
 /**
- * Adds new type checkers to the typeValidator without overwriting existing ones.
+ * @typedef {import('../libs/utils/TinyCloner.mjs').default} TinyCloner
+ */
+/**
+ * A function type used to validate a value and return a specific result.
  *
- * Accepts either an object with named functions or an array of [key, fn] arrays.
- * If no index is provided, the type is inserted just before 'object' (if it exists), or at the end.
+ * @template {any} Value - The type of the value being validated.
+ * @template {any} Result - The type of the result returned by the function.
+ * @typedef {(val: Value) => Result} ExtendObjTypeFunc
+ */
+/**
+ * A function type used to clone a value, supporting deep cloning operations.
  *
- * @param {ExtendObjType|ExtendObjTypeArray} newItems
+ * @template {any} Value - The type of the value to be cloned.
+ * @typedef {(val: Value, isDeep: boolean, cloner: TinyCloner) => Value} ExtendObjTypeCloner
+ */
+/**
+ * A mapping of type names to their corresponding validation functions.
+ *
+ * @template {any} Value - The type of the value being mapped.
+ * @typedef {Object.<string, ExtendObjTypeFunc<Value, any>>} ExtendObjType
+ */
+/**
+ * A tuple representing a type definition, containing a key, a validator, and an optional cloner.
+ *
+ * @template {any} Value - The type of the value.
+ * @template {any} Result - The type of the result returned by the validator.
+ * @typedef {[string, ExtendObjTypeFunc<Value, Result>, ExtendObjTypeCloner<Value>]|[string, ExtendObjTypeFunc<Value, Result>]} ExtendObjTypeValue
+ */
+/**
+ * A registry object containing the validator and cloner for a specific type.
+ *
+ * @template {any} Value - The type of the value being registered.
+ * @template {any} Result - The type of the result returned by the validator.
+ * @typedef {Object} ObjTypeRegistry
+ * @property {ExtendObjTypeFunc<Value, Result>} validator - The function used to validate the type.
+ * @property {ExtendObjTypeCloner<Value>} cloner - The function used to create a clone of the value.
+ */
+/**
+ * Adds new type checkers to the `typeValidator` registry.
+ *
+ * Accepts an object of functions, an array of [key, validator] tuples, or an array of [key, validator, cloner] tuples.
+ * If an `index` is provided, the new type is inserted at that position.
+ * If no index is provided, it is inserted before the 'object' type or at the end of the registry.
+ *
+ * @template {any} Value
+ * @template {any} Result
+ * @param {ExtendObjType<Value> | ExtendObjTypeValue<Value, Result>[] | ExtendObjTypeValue<Value, Result>} ni
  * - New type validators to be added.
  * @param {number} [index] - Optional. Position at which to insert each new type. Ignored if the type already exists.
  * @returns {string[]} - A list of successfully added type names.
+ * @throws {TypeError} If `ni` is not an object/array, if `index` is not a number, if a key is not a string, or if a validator is not a function.
  *
  * @example
  * extendObjType({
- * htmlElement2: val => typeof HTMLElement !== 'undefined' && val instanceof HTMLElement
+ *   htmlElement2: val => typeof HTMLElement !== 'undefined' && val instanceof HTMLElement
  * });
  *
  * @example
@@ -42,30 +90,67 @@ const typeValidator = {
  * ['alpha', val => typeof val === 'string'],
  * ['beta', val => Array.isArray(val)]
  * ]);
+ *
+ * @example
+ * extendObjType(['gamma', val => typeof val === 'number']);
  */
-export function extendObjType(newItems, index) {
-    if (typeof newItems !== 'object' || newItems === null) {
-        throw new TypeError("Argument 'newItems' must be an object or an array.");
+export function extendObjType(ni, index) {
+    if (typeof ni !== 'object' || ni === null) {
+        throw new TypeError("Argument 'ni' must be an object or an array.");
     }
     if (typeof index !== 'undefined' && typeof index !== 'number') {
         throw new TypeError("Argument 'index' must be a number.");
     }
     const added = [];
-    const entries = Array.isArray(newItems) ? newItems : Object.entries(newItems);
+    // Normalization logic:
+    // 1. If ni is an array:
+    //    - If the first element is also an array, it is an array of tuples (ExtendObjTypeValue[]).
+    //    - If the first element is not an array, it is a single tuple (ExtendObjTypeValue).
+    //    - If the array is empty, we use an empty array.
+    // 2. If ni is an object:
+    //    - We use Object.entries to convert it to an array of [key, value] pairs.
+    /**
+     * @type {[string, ExtendObjTypeFunc<Value, Result>, ExtendObjTypeCloner<Value> | undefined][]}
+     */
+    let entries;
+    if (Array.isArray(ni)) {
+        if (ni.length > 0 && Array.isArray(ni[0])) {
+            // @ts-ignore
+            entries = ni;
+        }
+        else if (ni.length > 0) {
+            // @ts-ignore
+            entries = [ni];
+        }
+        else {
+            entries = [];
+        }
+    }
+    else {
+        // @ts-ignore
+        entries = Object.entries(ni);
+    }
     for (const entry of entries) {
         if (!Array.isArray(entry) || entry.length < 2) {
-            throw new TypeError("Each item in 'newItems' array must be a [key, function] pair.");
+            throw new TypeError('Each item in the input must be a [key, function] pair.');
+        }
+        const [key, validator, cloner] = entry;
+        if (typeof cloner !== 'undefined' && typeof cloner !== 'function') {
+            throw new TypeError(`Cloner for key '${key}' must be a function.`);
         }
-        const [key, fn] = entry;
+        /** @type {ExtendObjTypeCloner<Value>} */
+        const effectiveCloner = typeof cloner === 'function' ? cloner : (val) => val;
         if (typeof key !== 'string') {
             throw new TypeError('Validator key must be a string.');
         }
-        if (typeof fn !== 'function') {
+        if (typeof validator !== 'function') {
             throw new TypeError(`Validator for key '${key}' must be a function.`);
         }
         if (!typeValidator.items.hasOwnProperty(key)) {
-            // @ts-ignore
-            typeValidator.items[key] = fn;
+            typeValidator.items[key] = {
+                validator: validator,
+                cloner: effectiveCloner,
+            };
             let insertAt = typeof index === 'number' ? index : -1; // Default to -1 if index isn't provided
             // Default to before 'object', or to the end
             if (insertAt === -1) {
@@ -135,10 +220,9 @@ export function cloneObjTypeOrder() {
 export const objTypeName = (val) => {
     if (val === null)
         return 'null';
-    // @ts-ignore
     for (const name of typeValidator.order) {
-        // @ts-ignore
-        if (typeof typeValidator.items[name] !== 'function' || typeValidator.items[name](val))
+        if (typeof typeValidator.items[name].validator !== 'function' ||
+            typeValidator.items[name].validator(val))
             return name;
     }
     return 'unknown';
@@ -149,6 +233,7 @@ export const objTypeName = (val) => {
  * @param {*} obj - The object to check.
  * @param {string} [type] - Checks whether the object matches this type (e.g., "object", "array", "string").
  * @returns {boolean} - Returns `true` if the type matches.
+ * @throws {TypeError} If `type` is not a string.
  */
 export function isObjType(obj, type) {
     if (typeof type !== 'string')
@@ -163,6 +248,7 @@ export function isObjType(obj, type) {
  * @param {string} [type] - Optional. If provided, checks whether the object matches this type (e.g., "object", "array", "string").
  * @returns {boolean|string|null} - Returns `true` if the type matches, `false` if not,
  * the type string if no type is provided, or `null` if the object is `undefined`.
+ * @throws {TypeError} If `type` is provided but is not a string.
  *
  * @example
  * objType([], 'array'); // true
@@ -182,19 +268,22 @@ export function objType(obj, type) {
     return result;
 }
 /**
- * Checks the type of a given object and returns the validation value if a known type is detected.
+ * @typedef {Object} CheckResult
+ * @property {*} valid - The result of the validator function (often the value itself if truthy).
+ * @property {string | null} type - The name of the detected type.
+ */
+/**
+ * Evaluates an object against the registered validators and returns the first match.
  *
- * @param {*} obj - The object to check or identify.
- * @returns {{ valid:*; type: string | null }} - Returns the type result.
+ * @param {unknown} obj - The object to check.
+ * @returns {CheckResult} An object containing the validation result and the type name.
  */
 export function checkObj(obj) {
-    /** @type {{ valid:*; type: string | null }} */
+    /** @type {CheckResult} */
     const data = { valid: null, type: null };
     for (const name of typeValidator.order) {
-        // @ts-ignore
-        if (typeof typeValidator.items[name] === 'function') {
-            // @ts-ignore
-            const result = typeValidator.items[name](obj);
+        if (typeof typeValidator.items[name].validator === 'function') {
+            const result = typeValidator.items[name].validator(obj);
             if (result) {
                 data.valid = result;
                 data.type = name;
@@ -205,13 +294,19 @@ export function checkObj(obj) {
     return data;
 }
 /**
- * Creates a clone of the functions from the `typeValidator` object.
- * It returns a new object where the keys are the same and the values are the cloned functions.
+ * Returns a shallow clone of the `typeValidator.items` registry.
+ *
+ * @returns {Record<string, ObjTypeRegistry<any, any>>} A new object containing the registry data.
  */
-export function getCheckObj() {
-    return Object.fromEntries(Object.entries(typeValidator.items).map(([key, fn]) => [key, fn]));
+export function getObjTypeRegistry() {
+    return Object.fromEntries(Object.entries(typeValidator.items).map(([key, data]) => [key, { ...data }]));
 }
-// Insert obj types
+/**
+ * Returns a copy of the current order of type validators.
+ * @returns {string[]} A new array containing the type order.
+ */
+export const getObjTypeOrder = () => [...typeValidator.order];
+// --- Type Registration ---
 extendObjType([
     [
         'undefined',
@@ -233,6 +328,11 @@ extendObjType([
         /** @param {unknown} val @returns {val is number} */
         (val) => typeof val === 'number' && !Number.isNaN(val),
     ],
+    [
+        'nannumber',
+        /** @param {unknown} val @returns {val is number} */
+        (val) => typeof val === 'number' && Number.isNaN(val),
+    ],
     [
         'bigint',
         /** @param {unknown} val @returns {val is bigint} */
@@ -253,85 +353,109 @@ extendObjType([
         /** @param {unknown} val @returns {val is Function} */
         (val) => typeof val === 'function',
     ],
-    [
-        'array',
-        /**
-         * @param {unknown} val @returns {val is unknown[]}
-         */
-        (val) => Array.isArray(val),
-    ],
+]);
+extendObjType([
+    'array',
+    /**  @param {unknown} val @returns {val is unknown[]} */
+    (val) => Array.isArray(val),
+    /** @type {ExtendObjTypeCloner<unknown[]>} */
+    (item, isDeep, cloner) => item.map((element) => (isDeep ? cloner.clone(element, isDeep) : element)),
 ]);
 if (isBrowser) {
     extendObjType([
-        [
-            'file',
-            /** @param {unknown} val @returns {val is File} */
-            (val) => typeof File !== 'undefined' && val instanceof File,
-        ],
+        'file',
+        /** @param {unknown} val @returns {val is File} */
+        (val) => typeof File !== 'undefined' && val instanceof File,
+        /** @type {ExtendObjTypeCloner<File>} */
+        (item) => new File([item], item.name, { type: item.type, lastModified: item.lastModified }),
     ]);
 }
 extendObjType([
-    [
-        'date',
-        /** @param {unknown} val @returns {val is Date} */
-        (val) => val instanceof Date,
-    ],
-    [
-        'regexp',
-        /** @param {unknown} val @returns {val is RegExp} */
-        (val) => val instanceof RegExp,
-    ],
-    [
-        'map',
-        /**
-         * @param {unknown} val @returns {val is Map<unknown, unknown>}
-         */
-        (val) => val instanceof Map,
-    ],
-    [
-        'set',
-        /**
-         * @param {unknown} val @returns {val is Set<unknown>}
-         */
-        (val) => val instanceof Set,
-    ],
+    'date',
+    /** @param {unknown} val @returns {val is Date} */
+    (val) => val instanceof Date,
+    /** @type {ExtendObjTypeCloner<Date>} */
+    (item) => new Date(item.getTime()),
+]);
+extendObjType([
+    'regexp',
+    /** @param {unknown} val @returns {val is RegExp} */
+    (val) => val instanceof RegExp,
+    /** @type {ExtendObjTypeCloner<RegExp>} */
+    (item) => new RegExp(item.source, item.flags),
+]);
+extendObjType([
+    'map',
+    /** @param {unknown} val @returns {val is Map<unknown, unknown>} */
+    (val) => val instanceof Map,
+    /** @type {ExtendObjTypeCloner<Map<unknown, unknown>>} */
+    (item, isDeep, cloner) => {
+        const result = new Map();
+        for (const [key, value] of item.entries()) {
+            result.set(key, isDeep ? cloner.clone(value, isDeep) : value);
+        }
+        return result;
+    },
+]);
+extendObjType([
+    'set',
+    /** @param {unknown} val @returns {val is Set<unknown>} */
+    (val) => val instanceof Set,
+    /** @type {ExtendObjTypeCloner<Set<any>>} */
+    (item, isDeep, cloner) => {
+        const result = new Set();
+        for (const value of item) {
+            result.add(isDeep ? cloner.clone(value, isDeep) : value);
+        }
+        return result;
+    },
+]);
+extendObjType([
     [
         'weakmap',
-        /**
-         * @param {unknown} val @returns {val is WeakMap<unknown, unknown>}
-         */
+        /** @param {unknown} val @returns {val is WeakMap<unknown, unknown>} */
         (val) => val instanceof WeakMap,
     ],
     [
         'weakset',
-        /**
-         * @param {unknown} val @returns {val is WeakSet<unknown>}
-         */
+        /** @param {unknown} val @returns {val is WeakSet<unknown>} */
         (val) => val instanceof WeakSet,
     ],
     [
         'promise',
-        /**
-         * @param {unknown} val @returns {val is Promise<unknown>}
-         */
+        /** @param {unknown} val @returns {val is Promise<unknown>} */
         (val) => val instanceof Promise,
     ],
 ]);
+extendObjType([
+    'url',
+    /** @param {unknown} val @returns {val is URL} */
+    (val) => val instanceof URL,
+    /** @type {ExtendObjTypeCloner<URL>} */
+    (item) => new URL(item.href),
+]);
 if (isBrowser) {
     extendObjType([
-        [
-            'htmlelement',
-            /** @param {unknown} val @returns {val is HTMLElement} */
-            (val) => typeof HTMLElement !== 'undefined' && val instanceof HTMLElement,
-        ],
+        'htmlelement',
+        /** @param {unknown} val @returns {val is HTMLElement} */
+        (val) => typeof HTMLElement !== 'undefined' && val instanceof HTMLElement,
+        /** @type {ExtendObjTypeCloner<Node>} */
+        (item) => item.cloneNode(true),
     ]);
 }
 extendObjType([
-    [
-        'object',
-        /**
-         * @param {unknown} val @returns {val is Record<string | number | symbol, unknown>}
-         */
-        (val) => isJsonObject(val),
-    ],
+    'object',
+    /** @param {unknown} val @returns {val is Record<string | number | symbol, unknown>} */
+    (val) => isJsonObject(val),
+    /** @type {ExtendObjTypeCloner<Record<string | number | symbol, unknown>>} */
+    (item, isDeep, cloner) => {
+        /** @type {Record<string | number | symbol, unknown>} */
+        const result = {};
+        for (const key in item) {
+            if (Object.prototype.hasOwnProperty.call(item, key)) {
+                result[key] = isDeep ? cloner.clone(item[key], isDeep) : item[key];
+            }
+        }
+        return result;
+    },
 ]);

package/dist/v1/basics/promiseUtils.cjs

@@ -24,22 +24,34 @@ const waitForTrue = (getValue, checkInterval = 100) => {
   });
 };
 
+/**
+ * @template {any} T
+ * @template {any[]} A
+ * @typedef {Object} SingletonTaskResult
+ * @property {(...args: A) => Promise<T>} callback - The wrapped function that manages single execution.
+ * @property {() => Promise<T> | null} getActivePromise - Returns the promise currently being executed or null if none is active.
+ * @property {() => void} resetActivePromise - Forces a reset of the active promise, allowing an immediate new execution.
+ * @property {() => boolean} isEnded - Returns true if the last execution (success or failure) has finished.
+ * @property {() => boolean} isFailed - Returns true if the last execution resulted in an error.
+ * @property {() => boolean} isLoading - Returns true if an execution is currently in progress.
+ */
+
 /**
  * Creates a controller object that manages the execution state of an asynchronous function,
- * ensuring it only executes one instance at a time. If a task is already in progress,
- * subsequent calls to the callback will wait for the existing promise to resolve.
+ * ensuring it only executes one instance at a time.
+ *
+ * If a task is already in progress, subsequent calls to the callback will return
+ * the exact same promise as the first call, preventing redundant operations.
  *
  * @template {any} T
  * @template {any[]} A
  * @param {(...args: A) => Promise<T>} baseFunction - The asynchronous function to be wrapped.
- * @returns {{
- *   callback: (...args: A) => Promise<T>,
- *   getActivePromise: () => Promise<T> | null,
- *   resetActivePromise: () => void
- * }} An object containing the execution controller.
+ * @param {boolean} [autoReset=true] - If true, the controller clears the active promise automatically
+ * once the base function resolves or rejects. If false, the lock remains until `resetActivePromise` is called.
+ * @returns {SingletonTaskResult<T, A>} An object containing the execution controller and state monitors.
  * @throws {TypeError} If the provided baseFunction is not a function.
  */
-const createSingletonTask = (baseFunction) => {
+const createSingletonTask = (baseFunction, autoReset = true) => {
   // Validation: Ensure the input is a function before proceeding.
   if (typeof baseFunction !== 'function') {
     throw new TypeError('The argument "baseFunction" must be a function.');
@@ -51,11 +63,21 @@ const createSingletonTask = (baseFunction) => {
    */
   let activePromise = null;
 
+  /**
+   * Internal state tracking the lifecycle of the task.
+   * @type {{ended: boolean, failed: boolean, loading: boolean}}
+   */
+  const status = {
+    ended: false,
+    failed: false,
+    loading: false,
+  };
+
   /**
    * The wrapped function returned to the user.
    *
    * @param {A} args - The arguments to pass to the base function.
-   * @returns {Promise<T>} The result of the base function or the existing promise.
+   * @returns {Promise<T>} The result of the base function or the existing promise if already running.
    */
   const callback = async (...args) => {
     // If a request is already in progress, return the existing promise.
@@ -63,16 +85,23 @@ const createSingletonTask = (baseFunction) => {
       return activePromise;
     }
 
+    status.loading = true;
     // Create the execution wrapper and ASSIGN it to activePromise
     activePromise = (async () => {
       try {
         const result = await baseFunction(...args);
+        status.ended = true;
+        status.failed = false;
+        status.loading = false;
         // Reset after success so the next call can start a new execution
-        activePromise = null;
+        if (autoReset) activePromise = null;
         return result;
       } catch (error) {
+        status.ended = true;
+        status.failed = true;
+        status.loading = false;
         // Reset on error to allow subsequent retry attempts.
-        activePromise = null;
+        if (autoReset) activePromise = null;
         throw error;
       }
     })();
@@ -91,10 +120,17 @@ const createSingletonTask = (baseFunction) => {
    * @returns {void}
    */
   const resetActivePromise = () => {
+    status.ended = false;
+    status.failed = false;
+    status.loading = false;
     activePromise = null;
   };
 
-  return { callback, getActivePromise, resetActivePromise };
+  const isEnded = () => status.ended;
+  const isFailed = () => status.failed;
+  const isLoading = () => status.loading;
+
+  return { callback, getActivePromise, resetActivePromise, isEnded, isFailed, isLoading };
 };
 
 exports.createSingletonTask = createSingletonTask;

package/dist/v1/basics/promiseUtils.d.mts

@@ -8,24 +8,57 @@
  * @throws {TypeError} If arguments are invalid.
  */
 export declare const waitForTrue: (getValue: () => boolean, checkInterval?: number) => Promise<void>;
+export type SingletonTaskResult<T extends any, A extends any[]> = {
+    /**
+     * - The wrapped function that manages single execution.
+     */
+    callback: (...args: A) => Promise<T>;
+    /**
+     * - Returns the promise currently being executed or null if none is active.
+     */
+    getActivePromise: () => Promise<T> | null;
+    /**
+     * - Forces a reset of the active promise, allowing an immediate new execution.
+     */
+    resetActivePromise: () => void;
+    /**
+     * - Returns true if the last execution (success or failure) has finished.
+     */
+    isEnded: () => boolean;
+    /**
+     * - Returns true if the last execution resulted in an error.
+     */
+    isFailed: () => boolean;
+    /**
+     * - Returns true if an execution is currently in progress.
+     */
+    isLoading: () => boolean;
+};
+/**
+ * @template {any} T
+ * @template {any[]} A
+ * @typedef {Object} SingletonTaskResult
+ * @property {(...args: A) => Promise<T>} callback - The wrapped function that manages single execution.
+ * @property {() => Promise<T> | null} getActivePromise - Returns the promise currently being executed or null if none is active.
+ * @property {() => void} resetActivePromise - Forces a reset of the active promise, allowing an immediate new execution.
+ * @property {() => boolean} isEnded - Returns true if the last execution (success or failure) has finished.
+ * @property {() => boolean} isFailed - Returns true if the last execution resulted in an error.
+ * @property {() => boolean} isLoading - Returns true if an execution is currently in progress.
+ */
 /**
  * Creates a controller object that manages the execution state of an asynchronous function,
- * ensuring it only executes one instance at a time. If a task is already in progress,
- * subsequent calls to the callback will wait for the existing promise to resolve.
+ * ensuring it only executes one instance at a time.
+ *
+ * If a task is already in progress, subsequent calls to the callback will return
+ * the exact same promise as the first call, preventing redundant operations.
  *
  * @template {any} T
  * @template {any[]} A
  * @param {(...args: A) => Promise<T>} baseFunction - The asynchronous function to be wrapped.
- * @returns {{
- *   callback: (...args: A) => Promise<T>,
- *   getActivePromise: () => Promise<T> | null,
- *   resetActivePromise: () => void
- * }} An object containing the execution controller.
+ * @param {boolean} [autoReset=true] - If true, the controller clears the active promise automatically
+ * once the base function resolves or rejects. If false, the lock remains until `resetActivePromise` is called.
+ * @returns {SingletonTaskResult<T, A>} An object containing the execution controller and state monitors.
  * @throws {TypeError} If the provided baseFunction is not a function.
  */
-export declare const createSingletonTask: <T extends any, A extends any[]>(baseFunction: (...args: A) => Promise<T>) => {
-    callback: (...args: A) => Promise<T>;
-    getActivePromise: () => Promise<T> | null;
-    resetActivePromise: () => void;
-};
+export declare const createSingletonTask: <T extends any, A extends any[]>(baseFunction: (...args: A) => Promise<T>, autoReset?: boolean) => SingletonTaskResult<T, A>;
 //# sourceMappingURL=promiseUtils.d.mts.map

package/dist/v1/basics/promiseUtils.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"promiseUtils.d.mts","sourceRoot":"","sources":["../../../src/v1/basics/promiseUtils.mjs"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,aALb,MAAM,OAAO,kBACb,MAAM,KACJ,OAAO,CAAC,IAAI,CAgBxB,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,GAVb,CAAC,SAAN,GAAM,EACC,CAAC,SAAR,GAAG,EAAK,gBACX,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,KACxB;IACR,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IACrC,gBAAgB,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAC1C,kBAAkB,EAAE,MAAM,IAAI,CAAA;CA4DlC,CAAC"}
+{"version":3,"file":"promiseUtils.d.mts","sourceRoot":"","sources":["../../../src/v1/basics/promiseUtils.mjs"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,aALb,MAAM,OAAO,kBACb,MAAM,KACJ,OAAO,CAAC,IAAI,CAgBxB,CAAC;AAKC,YAAkB,mBAAmB,CAFrB,CAAC,SAAN,GAAM,EACC,CAAC,SAAR,GAAG,EAAK,IAEnB;;;;IAAuC,QAAQ,EAApC,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CACrC;;;;IAAoC,gBAAgB,EAAzC,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAClC;;;;IAAuB,kBAAkB,EAA9B,MAAM,IAAI,CACrB;;;;IAA0B,OAAO,EAAtB,MAAM,OAAO,CACxB;;;;IAA0B,QAAQ,EAAvB,MAAM,OAAO,CACxB;;;;IAA0B,SAAS,EAAxB,MAAM,OAAO,CAC1B;CAAA,CAAA;AAVD;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,GARb,CAAC,SAAN,GAAM,EACC,CAAC,SAAR,GAAG,EAAK,gBACX,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,cAC1B,OAAO,KAEL,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAmFpC,CAAC"}