@develia/commons 0.4.26 → 0.5.0

package/src/browser/native-bridge.ts

@@ -34,7 +34,7 @@ export default class NativeBridge {
         }
 
         (window as any)[callbackName] = (id: number, error: any, result: any) => {
-            this._callback(id, error, result);
+            this._settlePendingCall(id, error, result);
         };
 
         // Proxy: cualquier propiedad no existente se convierte en call()
@@ -49,7 +49,7 @@ export default class NativeBridge {
     }
 
 
-    private _callback(id: number, error: any, result: any) {
+    private _settlePendingCall(id: number, error: any, result: any) {
 
         const pending = this._pending.get(id);
         if (!pending) {

package/src/cancellable-promise.ts

@@ -36,9 +36,14 @@ export default class CancellablePromise<T> extends Promise<T> {
         }
     }
 
-    static async compete<T>(promises: CancellablePromise<T>[]): Promise<T> {
+    /**
+     * Resolves or rejects as the first of the promises to settle (Promise.race), and cancels all the others, also when
+     * the first one fails.
+     * @throws {Error} When there are no promises.
+     */
+    static async raceAndCancelOthers<T>(promises: CancellablePromise<T>[]): Promise<T> {
         if (promises.length === 0) {
-            throw new Error("No promises to compete.");
+            throw new Error("No promises to race.");
         }
 
         const result = await Promise.race(
@@ -61,7 +66,8 @@ export default class CancellablePromise<T> extends Promise<T> {
         return result.value;
     }
 
-    static async cooperate<T>(promises: CancellablePromise<T>[]): Promise<T[]> {
+    /** Resolves with all the results (Promise.all); when one fails, cancels all of them and rejects with its error. */
+    static async allOrCancelAll<T>(promises: CancellablePromise<T>[]): Promise<T[]> {
         try {
             return await Promise.all(promises);
         } catch (error) {

package/src/clean-url-search-params.ts

@@ -7,12 +7,12 @@ function isRecordParams(params: unknown): params is Record<string, any> {
         typeof (params as any)[Symbol.iterator] !== 'function';
 }
 
-function appendCleanValue(params: URLSearchParams, key: string, value: any): void {
+function appendNonNullishValues(params: URLSearchParams, key: string, value: any): void {
     if (value === null || value === undefined) return;
 
     if (Array.isArray(value)) {
         for (const item of value) {
-            appendCleanValue(params, key, item);
+            appendNonNullishValues(params, key, item);
         }
         return;
     }
@@ -31,7 +31,7 @@ export default class CleanURLSearchParams extends URLSearchParams {
 
         // Filtrar `null` y `undefined` antes de añadirlos a URLSearchParams
         for (const [key, value] of Object.entries(params)) {
-            appendCleanValue(this, key, value);
+            appendNonNullishValues(this, key, value);
         }
     }
 }

package/src/collections/from.ts

@@ -485,7 +485,7 @@ export class From<T> implements Iterable<T> {
             array.sort((a, b) => {
                 const aValue = mapper(a);
                 const bValue = mapper(b);
-                return aValue > bValue ? 1 : bValue < aValue ? -1 : 0;
+                return aValue > bValue ? -1 : aValue < bValue ? 1 : 0;
             });
         } else {
             throw new Error("invalid order argument");
@@ -713,11 +713,11 @@ export class From<T> implements Iterable<T> {
 
 
     /**
-     * Concatenates two sequences.
+     * The elements of this sequence followed by those of the other, duplicates included, as LINQ's Concat.
      * @param {Iterable<T>} other - The other sequence.
      * @returns {From<T>} A new From instance.
      */
-    public union(other: Iterable<T>): From<T> {
+    public concat(other: Iterable<T>): From<T> {
         const self = this;
         return From.fn<T>(function* () {
             yield* self;
@@ -726,7 +726,19 @@ export class From<T> implements Iterable<T> {
     }
 
     /**
-     * Correlates the elements of two sequences based on matching keys.
+     * The set union, as LINQ's Union: the elements of this sequence and then those of the other, each one once (the
+     * first time it appears), compared as distinct() does.
+     * @param {Iterable<T>} other - The other sequence.
+     * @param {EqualityComparer<T>} [equalityComparer] - Optional equality comparer; shallowEqual when not given.
+     * @returns {From<T>} A new From instance.
+     */
+    public union(other: Iterable<T>, equalityComparer?: EqualityComparer<T>): From<T> {
+        return this.concat(other).distinct(equalityComparer);
+    }
+
+    /**
+     * Correlates the elements of two sequences based on matching keys: one result per matching pair, so an element
+     * that matches several elements of the other sequence gives one result for each.
      * @template T2, R, R2
      * @param {Iterable<T2>} other - The other sequence.
      * @param {UnaryFunction<T, R>} thisKeySelector - Key selector for this sequence.
@@ -738,18 +750,20 @@ export class From<T> implements Iterable<T> {
 
         const self = this;
         return From.fn<R2>(() => {
-            const otherByKey = new Map<R, T2>();
-            for (let item of other) {
-                otherByKey.set(otherKeySelector(item), item);
+            const otherByKey = groupItemsByKey(other, otherKeySelector);
+            const results: R2[] = [];
+            for (const item of self) {
+                for (const otherItem of otherByKey.get(thisKeySelector(item)) ?? []) {
+                    results.push(resultSelector(item, otherItem));
+                }
             }
-            return Array.from(self)
-                        .filter(item => otherByKey.has(thisKeySelector(item)))
-                        .map(item => resultSelector(item, otherByKey.get(thisKeySelector(item))!));
+            return results;
         });
     }
 
     /**
-     * Performs a left join on two sequences.
+     * Performs a left join on two sequences: one result per matching pair, and one with `undefined` for each element of
+     * this sequence that matches none.
      * @template U, K, R
      * @param {Iterable<U>} other - The other sequence.
      * @param {UnaryFunction<T, K>} thisKeySelector - Key selector for this sequence.
@@ -761,11 +775,19 @@ export class From<T> implements Iterable<T> {
 
         const self = this;
         return From.fn<R>(() => {
-            const otherByKey = new Map<K, U>();
-            for (let item of other) {
-                otherByKey.set(otherKeySelector(item), item);
+            const otherByKey = groupItemsByKey(other, otherKeySelector);
+            const results: R[] = [];
+            for (const item of self) {
+                const matches = otherByKey.get(thisKeySelector(item));
+                if (matches === undefined) {
+                    results.push(resultSelector(item, undefined));
+                    continue;
+                }
+                for (const otherItem of matches) {
+                    results.push(resultSelector(item, otherItem));
+                }
             }
-            return Array.from(self).map(item => resultSelector(item, otherByKey.get(thisKeySelector(item))));
+            return results;
         });
     }
 
@@ -783,15 +805,8 @@ export class From<T> implements Iterable<T> {
 
         const self = this;
         return From.fn<R>(() => {
-            const otherByKeys = new Map<K, Array<U>>();
-            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)) || []));
+            const otherByKey = groupItemsByKey(other, otherKeySelector);
+            return Array.from(self).map(item => resultSelector(item, otherByKey.get(thisKeySelector(item)) ?? []));
         });
     }
 
@@ -808,21 +823,15 @@ export class From<T> implements Iterable<T> {
 
         const self = this;
         return From.fn<R>(() => {
-            const thisByKeys = new Map<K, Array<T>>();
-            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));
+            const thisByKey = groupItemsByKey(self, thisKeySelector);
+            return Array.from(other).map(item => resultSelector(thisByKey.get(otherKeySelector(item)) ?? [], item));
         });
     }
 
 
     /**
-     * Performs a right join on two sequences.
+     * Performs a right join on two sequences: one result per matching pair, and one with `undefined` for each element of
+     * the other sequence that matches none.
      * @template U, K, R
      * @param {Iterable<U>} other - The other sequence.
      * @param {UnaryFunction<T, K>} thisKeySelector - Key selector for this sequence.
@@ -834,16 +843,39 @@ export class From<T> implements Iterable<T> {
 
         const self = this;
         return From.fn<R>(() => {
-            const thisByKey = new Map<K, T>();
-            for (let item of self) {
-                thisByKey.set(thisKeySelector(item), item);
+            const thisByKey = groupItemsByKey(self, thisKeySelector);
+            const results: R[] = [];
+            for (const otherItem of other) {
+                const matches = thisByKey.get(otherKeySelector(otherItem));
+                if (matches === undefined) {
+                    results.push(resultSelector(undefined, otherItem));
+                    continue;
+                }
+                for (const item of matches) {
+                    results.push(resultSelector(item, otherItem));
+                }
             }
-            return Array.from(other).map(item => resultSelector(thisByKey.get(otherKeySelector(item)), item));
+            return results;
         });
     }
 
 }
 
+/** The items of a sequence in lists by their key, in their order, for the joins. */
+function groupItemsByKey<TItem, TKey>(items: Iterable<TItem>, keySelector: UnaryFunction<TItem, TKey>): Map<TKey, TItem[]> {
+    const itemsByKey = new Map<TKey, TItem[]>();
+    for (const item of items) {
+        const key = keySelector(item);
+        const group = itemsByKey.get(key);
+        if (group === undefined) {
+            itemsByKey.set(key, [item]);
+        } else {
+            group.push(item);
+        }
+    }
+    return itemsByKey;
+}
+
 /**
  * Represents a group of elements that have a common key.
  * @template TKey, T

package/src/draft.ts

@@ -39,7 +39,7 @@ type DraftMethods<T> = {
      *
      * @returns Array of modified property keys (does not recurse into children).
      */
-    modifiedProps(): (keyof T)[];
+    getModifiedProps(): (keyof T)[];
 
     /**
      * Manually mark (or unmark) a property as modified.
@@ -155,7 +155,7 @@ function deepDraft(value: any, parentLink?: ParentLink): any {
 /**
  * Create a draft proxy over `original`. The proxy exposes the same properties
  * as the original (with nested objects wrapped as child drafts) plus the
- * control methods `commit`, `rollback`, `isModified`, `modifiedProps` and
+ * control methods `commit`, `rollback`, `isModified`, `getModifiedProps` and
  * `setModified`.
  *
  * Mutations on the draft do not affect the original until `commit()` is called.
@@ -249,7 +249,7 @@ export default function draft<T extends object>(
             return key === undefined ? touched.size > 0 : touched.has(key);
         },
 
-        modifiedProps() {
+        getModifiedProps() {
             return [...touched] as (keyof T)[];
         },
 

package/src/functions.ts

@@ -17,7 +17,7 @@ export interface ThrottleOptions {
  * const refresh = throttle(loadData, 250);
  * refresh();
  *
- * if (refresh.pending()) {
+ * if (refresh.isPending()) {
  *     refresh.flush();
  * }
  * ```
@@ -31,7 +31,7 @@ export type DeferredFunction<F extends AnyFunction> = ((
     /** Execute the scheduled trailing call immediately, when one exists. */
     flush(): ReturnType<F> | undefined;
     /** Return true while a trailing call is scheduled. */
-    pending(): boolean;
+    isPending(): boolean;
 };
 
 /**
@@ -300,7 +300,7 @@ export function throttle<F extends AnyFunction>(
         return result;
     };
 
-    throttled.pending = (): boolean => timer !== undefined;
+    throttled.isPending = (): boolean => timer !== undefined;
 
     return throttled;
 }

package/src/index.ts

@@ -4,6 +4,7 @@
 export * from './types.js';
 export {default as Type} from './type.js';
 export {default as TypeCode} from './type-code.js';
+export {default as Uuid} from './uuid.js';
 
 // ─── Utilities ───────────────────────────────────────
 export * from './utilities.js';
@@ -41,7 +42,7 @@ export {default as draft} from './draft.js';
 // ─── Web ─────────────────────────────────────────────
 export {default as CleanURLSearchParams} from './clean-url-search-params.js';
 /** @deprecated  */
-export {ajaxSubmit, ajaxSubmission, submitForm, formToObject} from './browser/index.js';
+export {ajaxSubmit, submitForm, formToObject} from './browser/index.js';
 
 
 

package/src/math.ts

@@ -1,15 +1,27 @@
 /**
- * Linearly interpolates a number between two ranges.
+ * Linearly interpolates between two numbers: `a` for `t` 0, `b` for `t` 1, and beyond them outside that range.
  *
- * @param {number} n - The number to interpolate.
+ * @param {number} a - The value at `t` 0.
+ * @param {number} b - The value at `t` 1.
+ * @param {number} t - The interpolation factor.
+ * @return {number} - The interpolated value.
+ */
+export function lerp(a: number, b: number, t: number): number {
+    return a + (b - a) * t;
+}
+
+/**
+ * Maps a number from one range to another, keeping its proportion (`remap(5, 0, 10, 0, 100)` is 50).
+ *
+ * @param {number} n - The number to map.
  * @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.
+ * @return {number} - The number in the output range.
+ * @throws {Error} When the input range is empty (`inMin === inMax`).
  */
-export function lerp(n: number, inMin: number, inMax: number, outMin: number, outMax: number): number {
+export function remap(n: number, inMin: number, inMax: number, outMin: number, outMax: number): number {
     if (inMax === inMin) {
         throw new Error("Input range cannot be zero");
     }

package/src/string.ts

@@ -26,14 +26,20 @@ export function ensureSuffix(str: string, suffix: string): string {
     return str
 }
 
+/**
+ * Null for an empty string, as `Str::nullIfEmpty()` of develia/commons for PHP; any other string as it is. Compose it
+ * with `trim()` to turn a blank string into null: `nullIfEmpty(value.trim())`.
+ */
+export function nullIfEmpty(str: string | null | undefined): string | null {
+    return str === undefined || str === null || str === '' ? null : str;
+}
+
 /**
  * Normalizes Unicode whitespaces into single ASCII spaces and removes leading
  * and trailing whitespace.
  */
 export function normalizeWhitespaces(str: string): string {
-    return str.normalize('NFKC')
-              .replace(/[\s\u200B\uFEFF]+/gu, ' ')
-              .trim()
+    return str.replace(/[\s\u200B\uFEFF]+/gu, ' ').trim();
 }
 
 /**

package/src/timespan.ts

@@ -13,7 +13,7 @@ export default class TimeSpan {
      * Gets the time interval in seconds.
      * @returns {number} The duration in seconds.
      */
-    seconds(): number {
+    getTotalSeconds(): number {
         return this.milliseconds / 1000;
     }
 
@@ -21,7 +21,7 @@ export default class TimeSpan {
      * Gets the time interval in minutes.
      * @returns {number} The duration in minutes.
      */
-    minutes(): number {
+    getTotalMinutes(): number {
         return this.milliseconds / (1000 * 60);
     }
 
@@ -29,7 +29,7 @@ export default class TimeSpan {
      * Gets the time interval in hours.
      * @returns {number} The duration in hours.
      */
-    hours(): number {
+    getTotalHours(): number {
         return this.milliseconds / (1000 * 60 * 60);
     }
 
@@ -37,7 +37,7 @@ export default class TimeSpan {
      * Gets the time interval in days.
      * @returns {number} The duration in days.
      */
-    days(): number {
+    getTotalDays(): number {
         return this.milliseconds / (1000 * 60 * 60 * 24);
     }
 
@@ -45,7 +45,7 @@ export default class TimeSpan {
      * Gets the time interval in weeks.
      * @returns {number} The duration in weeks.
      */
-    weeks(): number {
+    getTotalWeeks(): number {
         return this.milliseconds / (1000 * 60 * 60 * 24 * 7);
     }
 

package/src/types.ts

@@ -12,7 +12,6 @@ export type Nullable<T> = T | null;
 
 export type Nullish = null | undefined;
 
-export type Resolvable<T> = T | Promise<T> | Supplier<T>;
 
 export type UnaryFunction<T, R> = (arg: T) => R;
 

package/src/utilities.ts

@@ -2,7 +2,7 @@
 
 
 import KeyValuePair from "./key-value-pair.js";
-import type {Resolvable, Constructor} from "./types.js";
+import type {Constructor} from "./types.js";
 import Type from "./type.js";
 
 export function lazy<T extends object>(factory: () => T): T {
@@ -185,8 +185,8 @@ function _deepEqual(
     }
 
     const objB = b as object;
-    const keysA = _deepEqualKeys(objA, includeInherited);
-    const keysB = _deepEqualKeys(objB, includeInherited);
+    const keysA = _collectComparableKeys(objA, includeInherited);
+    const keysB = _collectComparableKeys(objB, includeInherited);
     if (keysA.length !== keysB.length) return false;
 
     for (const key of keysA) {
@@ -265,7 +265,7 @@ function _deepEqualSet(
     return true;
 }
 
-function _deepEqualKeys(value: object, includeInherited: boolean): PropertyKey[] {
+function _collectComparableKeys(value: object, includeInherited: boolean): PropertyKey[] {
     const keys: PropertyKey[] = [];
     const seen = new Set<PropertyKey>();
     const addKey = (key: PropertyKey) => {
@@ -529,29 +529,26 @@ export function pick<T extends object, K extends keyof T>(obj: T, props: K[]): P
 }
 
 /**
- * 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.
+ * Turns a function that takes a Node-style callback as its last argument (`(error, result) => void`) into one that
+ * returns a promise, as Node's `util.promisify`: it resolves with the result, or rejects with the error the callback
+ * receives. The function keeps the `this` it is called with.
+ * @param fn - The function to wrap.
+ * @returns The function that returns a promise.
  */
-export function promisify<T>(thing: Resolvable<T>): Promise<T> {
-
-    if (thing instanceof Promise)
-        return thing;
-
-
-    if (isFunction(thing)) {
-        return new Promise<T>((resolve, reject) => {
-            try {
-                const result = thing();
-                resolve(result);
-            } catch (error) {
-                reject(error);
-            }
+export function promisify<TArgs extends unknown[], TResult>(
+    fn: (...args: [...TArgs, (error: unknown, result: TResult) => void]) => void,
+): (...args: TArgs) => Promise<TResult> {
+    return function (this: unknown, ...args: TArgs): Promise<TResult> {
+        return new Promise<TResult>((resolve, reject) => {
+            fn.call(this, ...args, (error: unknown, result: TResult) => {
+                if (error !== null && error !== undefined) {
+                    reject(error);
+                } else {
+                    resolve(result);
+                }
+            });
         });
-    }
-
-    return Promise.resolve(thing);
+    };
 }
 
 

package/src/uuid.ts

@@ -0,0 +1,153 @@
+import {Nullable} from './types.js';
+
+/** Versions 1 to 8 with the RFC variant, plus the Nil and Max UUIDs of RFC 9562 sections 5.9 and 5.10. */
+const PATTERN = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|0{8}-0{4}-0{4}-0{4}-0{12}|f{8}-f{4}-f{4}-f{4}-f{12})$/i;
+
+/** Largest Unix timestamp in milliseconds that fits in the 48 bits of a version 7 UUID. */
+const MAX_V7_MILLISECONDS = 0xffffffffffff;
+
+/**
+ * Immutable universally unique identifier (RFC 9562), kept in lowercase canonical form,
+ * such as `019a4f8b-4bae-7d2e-9f10-4a5b6c7d8e9f`.
+ *
+ * It serializes to its string with `JSON.stringify`, so DTOs carry it as text; read those
+ * strings back with {@link Uuid.parse} or {@link Uuid.parseOrThrow}.
+ */
+export default class Uuid {
+    private readonly value: string;
+
+    private constructor(value: string) {
+        this.value = value;
+    }
+
+    /**
+     * Generates a version 4 UUID from 122 random bits of a cryptographically secure source.
+     *
+     * Unlike `crypto.randomUUID()`, it also works in browser contexts that are not secure, such as
+     * a development site served over HTTP.
+     */
+    static generateV4(): Uuid {
+        const bytes = new Uint8Array(16);
+        globalThis.crypto.getRandomValues(bytes);
+
+        return Uuid.createWithVersion(bytes, 4);
+    }
+
+    /**
+     * Generates a version 7 UUID: a 48-bit Unix timestamp in milliseconds followed by 74 random bits
+     * from a cryptographically secure source, so identifiers sort by creation time.
+     *
+     * Identifiers generated within the same millisecond keep no particular order among themselves.
+     *
+     * @param date Moment the UUID encodes; the current time when omitted.
+     * @throws {RangeError} If the date is invalid, before the Unix epoch or beyond the 48-bit range.
+     */
+    static generateV7(date: Date = new Date()): Uuid {
+        const milliseconds = date.getTime();
+        if (!Number.isInteger(milliseconds) || milliseconds < 0 || milliseconds > MAX_V7_MILLISECONDS) {
+            throw new RangeError('A version 7 UUID can only encode a valid date from the Unix epoch on.');
+        }
+
+        const bytes = new Uint8Array(16);
+        globalThis.crypto.getRandomValues(bytes);
+        let remaining = milliseconds;
+        for (let index = 5; index >= 0; index--) {
+            bytes[index] = remaining % 256;
+            remaining = Math.floor(remaining / 256);
+        }
+
+        return Uuid.createWithVersion(bytes, 7);
+    }
+
+    /**
+     * Checks if a value is a UUID in canonical form, in any letter case: one of RFC 9562 versions 1 to 8,
+     * or its Nil UUID (all zeros) or Max UUID (all ones).
+     *
+     * It returns a plain boolean rather than a type guard: a string that is not a UUID is still a
+     * string, which a guard would narrow to `never`.
+     */
+    static isValid(value: unknown): boolean {
+        return typeof value === 'string' && PATTERN.test(value);
+    }
+
+    /**
+     * Reads a UUID in canonical form, in any letter case, as {@link Uuid.isValid} accepts it.
+     *
+     * @returns The UUID, or `null` when the value is not one.
+     */
+    static parse(value: unknown): Nullable<Uuid> {
+        if (typeof value !== 'string' || !Uuid.isValid(value)) {
+            return null;
+        }
+
+        return new Uuid(value.toLowerCase());
+    }
+
+    /**
+     * Reads a UUID in canonical form, in any letter case.
+     *
+     * @throws {SyntaxError} If the value is not a UUID.
+     */
+    static parseOrThrow(value: string): Uuid {
+        const uuid = Uuid.parse(value);
+        if (uuid === null) {
+            throw new SyntaxError(`Invalid UUID "${value}".`);
+        }
+
+        return uuid;
+    }
+
+    /**
+     * Returns the RFC 9562 version, from 1 to 8, or 0 for the Nil UUID and 15 for the Max UUID.
+     */
+    getVersion(): number {
+        return Number.parseInt(this.value.charAt(14), 16);
+    }
+
+    /**
+     * Returns the moment a version 7 UUID encodes, with millisecond precision.
+     *
+     * @returns The moment, or `null` for other versions.
+     */
+    getDate(): Nullable<Date> {
+        if (this.getVersion() !== 7) {
+            return null;
+        }
+
+        const milliseconds = Number.parseInt(this.value.slice(0, 8) + this.value.slice(9, 13), 16);
+        return new Date(milliseconds);
+    }
+
+    equals(other: Uuid): boolean {
+        return this.value === other.value;
+    }
+
+    /**
+     * Returns the UUID in lowercase canonical form.
+     */
+    toString(): string {
+        return this.value;
+    }
+
+    toJSON(): string {
+        return this.value;
+    }
+
+    /**
+     * Sets the version and the RFC 9562 variant bits of 16 bytes and wraps them as a UUID.
+     *
+     * @param bytes Exactly 16 bytes; only the version and variant bits are overwritten.
+     * @param version From 1 to 8.
+     */
+    private static createWithVersion(bytes: Uint8Array, version: number): Uuid {
+        bytes[6] = (bytes[6] & 0x0f) | (version << 4);
+        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+
+        let hex = '';
+        for (const byte of bytes) {
+            hex += byte.toString(16).padStart(2, '0');
+        }
+
+        return new Uuid(`${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`);
+    }
+}