@murky-web/typebuddy 0.1.0 → 1.1.0

package/src/type_helper.ts

@@ -1,23 +1,23 @@
 import type { Maybe } from "./types/maybe.js";
+import type { Failed, Success } from "./types/maybe_promise.js";
 import type { Nullable } from "./types/nullable.js";
 import type { Optional } from "./types/optional.js";
-import type { Failed, Success } from "./types/maybe_promise.js";
 
 type UnknownFunction = (...args: readonly never[]) => unknown;
 const EMPTY_LENGTH = 0;
 const uuidRegex =
-  /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/;
+    /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/;
 
 const ulidRegex = /^[0123456789ABCDEFGHJKMNPQRSTVWXYZ]{26}$/;
 
 function cloneDefaultArray(
-  defaultValue?: readonly unknown[],
+    defaultValue?: readonly unknown[],
 ): unknown[] | undefined {
-  if (!defaultValue) {
-    return defaultValue;
-  }
+    if (!defaultValue) {
+        return defaultValue;
+    }
 
-  return [...defaultValue];
+    return [...defaultValue];
 }
 
 /**
@@ -32,15 +32,44 @@ function cloneDefaultArray(
  * @example
  * ```typescript
  * const result = await someAsyncFunction();
-* if (isSuccess(result)) {
-*   return result.value; // TypeScript knows `value` is of type `T`
-* }
+ * if (isSuccess(result)) {
+ *   return result.value; // TypeScript knows `value` is of type `T`
+ * }
  * ```
  */
 function isSuccess<T>(
-  result: Readonly<Success<T> | Failed>,
+    result: Readonly<Success<T> | Failed>,
 ): result is Success<T> {
-  return !result.isError;
+    return !result.isError;
+}
+
+/**
+ * Creates a successful result object for MaybePromise-style flows.
+ */
+function ok(): Success<void>;
+function ok<T>(value: T): Success<T>;
+// oxlint-disable-next-line typescript-eslint/prefer-readonly-parameter-types -- ok() intentionally accepts arbitrary payload values, including mutable ones.
+function ok<T>(...args: readonly [T] | []): Success<T | void> {
+    const [value] = args;
+    return {
+        isError: false,
+        value,
+    };
+}
+
+/**
+ * Creates the default failed result object for MaybePromise-style flows.
+ */
+function err(): Failed;
+function err<T extends null>(value: T): Failed<T>;
+// oxlint-disable-next-line typescript-eslint/prefer-readonly-parameter-types -- err() mirrors ok() and accepts the caller's payload shape without forcing readonly wrappers.
+function err<T extends null>(...args: readonly [T] | []): Failed {
+    const [value] = args;
+    return {
+        isError: true,
+        // oxlint-disable-next-line unicorn/no-null -- TypeBuddy models failed states with null by design.
+        value: value ?? null,
+    };
 }
 
 /**
@@ -51,7 +80,7 @@ function isSuccess<T>(
 function isString<T extends string>(value: Nullable<T>): value is T;
 function isString(value: unknown): value is string;
 function isString(value: unknown): value is string {
-  return typeof value === "string";
+    return typeof value === "string";
 }
 
 /**
@@ -60,8 +89,10 @@ function isString(value: unknown): value is string {
  * @returns {boolean} True if the value is a string.
  */
 function isEmptyString(value: unknown): boolean {
-  if (!isString(value)) {return false;}
-  return value.trim() === "";
+    if (!isString(value)) {
+        return false;
+    }
+    return value.trim() === "";
 }
 
 /**
@@ -70,7 +101,7 @@ function isEmptyString(value: unknown): boolean {
  * @returns {boolean} True if the value is null.
  */
 function isNull(value: unknown): value is null {
-  return value === null;
+    return value === null;
 }
 
 /**
@@ -79,7 +110,7 @@ function isNull(value: unknown): value is null {
  * @returns {boolean} True if the value is undefined.
  */
 function isUndefined(value: unknown): value is undefined {
-  return typeof value === "undefined";
+    return typeof value === "undefined";
 }
 
 /**
@@ -88,7 +119,7 @@ function isUndefined(value: unknown): value is undefined {
  * @returns {boolean} True when the value is undefined.
  */
 function isOptional<T>(value: Optional<T>): value is undefined {
-  return isUndefined(value);
+    return isUndefined(value);
 }
 
 /**
@@ -97,7 +128,7 @@ function isOptional<T>(value: Optional<T>): value is undefined {
  * @returns {boolean} True when the value is null.
  */
 function isMaybe<T>(value: Maybe<T>): value is null {
-  return isNull(value);
+    return isNull(value);
 }
 
 /**
@@ -106,7 +137,7 @@ function isMaybe<T>(value: Maybe<T>): value is null {
  * @returns {boolean} True when the value is null or undefined.
  */
 function isNullable<T>(value: Nullable<T>): value is null | undefined {
-  return isNull(value) || isUndefined(value);
+    return isNull(value) || isUndefined(value);
 }
 
 /**
@@ -117,7 +148,7 @@ function isNullable<T>(value: Nullable<T>): value is null | undefined {
 function isArray<T>(value: Nullable<readonly T[]>): value is readonly T[];
 function isArray(value: unknown): value is readonly unknown[];
 function isArray(value: unknown): value is readonly unknown[] {
-  return Array.isArray(value);
+    return Array.isArray(value);
 }
 
 /**
@@ -128,7 +159,7 @@ function isArray(value: unknown): value is readonly unknown[] {
 function isEmptyArray<T>(value: Nullable<readonly T[]>): value is readonly T[];
 function isEmptyArray(value: unknown): value is readonly unknown[];
 function isEmptyArray(value: unknown): value is readonly unknown[] {
-  return Array.isArray(value) && value.length === EMPTY_LENGTH;
+    return Array.isArray(value) && value.length === EMPTY_LENGTH;
 }
 
 /**
@@ -139,7 +170,7 @@ function isEmptyArray(value: unknown): value is readonly unknown[] {
 function fastIsArray<T>(value: Nullable<readonly T[]>): value is readonly T[];
 function fastIsArray(value: unknown): value is readonly unknown[];
 function fastIsArray(value: unknown): value is readonly unknown[] {
-  return Object.prototype.toString.call(value) === "[object Array]";
+    return Object.prototype.toString.call(value) === "[object Array]";
 }
 
 /**
@@ -150,10 +181,14 @@ function fastIsArray(value: unknown): value is readonly unknown[] {
 function isNumber<T extends number>(value: Nullable<T>): value is T;
 function isNumber(value: unknown): value is number;
 function isNumber(value: unknown): value is number {
-  if (typeof value === "string" && value.trim() === "") {
-    return false;
-  }
-  return typeof value === "number" && !Number.isNaN(value) && Number.isFinite(value);
+    if (typeof value === "string" && value.trim() === "") {
+        return false;
+    }
+    return (
+        typeof value === "number" &&
+        !Number.isNaN(value) &&
+        Number.isFinite(value)
+    );
 }
 
 /**
@@ -162,21 +197,21 @@ function isNumber(value: unknown): value is number {
  * @returns {boolean} True if the value is an object.
  */
 function isObject<T extends Record<string, unknown>>(
-  value: Nullable<T>,
+    value: Nullable<T>,
 ): value is T;
 function isObject(value: unknown): value is Record<string, unknown>;
 function isObject(value: unknown): value is Record<string, unknown> {
-  if (
-    typeof value !== "object" ||
-    value === null ||
-    isArray(value) ||
-    Object.prototype.toString.call(value) !== "[object Object]"
-  ) {
-    return false;
-  }
+    if (
+        typeof value !== "object" ||
+        value === null ||
+        isArray(value) ||
+        Object.prototype.toString.call(value) !== "[object Object]"
+    ) {
+        return false;
+    }
 
-  const objectValue: object = value;
-  return Object.getPrototypeOf(objectValue) === Object.prototype;
+    const objectValue: object = value;
+    return Object.getPrototypeOf(objectValue) === Object.prototype;
 }
 
 /**
@@ -187,7 +222,7 @@ function isObject(value: unknown): value is Record<string, unknown> {
 function isBoolean<T extends boolean>(value: Nullable<T>): value is T;
 function isBoolean(value: unknown): value is boolean;
 function isBoolean(value: unknown): value is boolean {
-  return typeof value === "boolean";
+    return typeof value === "boolean";
 }
 
 /**
@@ -195,12 +230,10 @@ function isBoolean(value: unknown): value is boolean {
  * @param {unknown} value - The value to check.
  * @returns {boolean} True if the value is a function.
  */
-function isFunction<T extends UnknownFunction>(
-  value: Nullable<T>,
-): value is T;
+function isFunction<T extends UnknownFunction>(value: Nullable<T>): value is T;
 function isFunction(value: unknown): value is UnknownFunction;
 function isFunction(value: unknown): value is UnknownFunction {
-  return typeof value === "function";
+    return typeof value === "function";
 }
 
 /**
@@ -209,15 +242,15 @@ function isFunction(value: unknown): value is UnknownFunction {
  * @returns {boolean} True if the value is a promise.
  */
 function isPromise<T>(
-  value: Nullable<Readonly<PromiseLike<T>>>,
+    value: Nullable<Readonly<PromiseLike<T>>>,
 ): value is PromiseLike<T>;
 function isPromise(value: unknown): value is PromiseLike<unknown>;
 function isPromise(value: unknown): value is PromiseLike<unknown> {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
 
-  return typeof Reflect.get(value, "then") === "function";
+    return typeof Reflect.get(value, "then") === "function";
 }
 
 /**
@@ -228,7 +261,7 @@ function isPromise(value: unknown): value is PromiseLike<unknown> {
 function isError<T extends Error>(value: Nullable<T>): value is T;
 function isError(value: unknown): value is Error;
 function isError(value: unknown): value is Error {
-  return value instanceof Error;
+    return value instanceof Error;
 }
 
 /**
@@ -239,7 +272,7 @@ function isError(value: unknown): value is Error {
 function isDate<T extends Date>(value: Nullable<T>): value is T;
 function isDate(value: unknown): value is Date;
 function isDate(value: unknown): value is Date {
-  return value instanceof Date;
+    return value instanceof Date;
 }
 
 /**
@@ -250,7 +283,7 @@ function isDate(value: unknown): value is Date {
 function isRegExp<T extends RegExp>(value: Nullable<T>): value is T;
 function isRegExp(value: unknown): value is RegExp;
 function isRegExp(value: unknown): value is RegExp {
-  return value instanceof RegExp;
+    return value instanceof RegExp;
 }
 
 /**
@@ -261,7 +294,7 @@ function isRegExp(value: unknown): value is RegExp {
 function isSymbol<T extends symbol>(value: Nullable<T>): value is T;
 function isSymbol(value: unknown): value is symbol;
 function isSymbol(value: unknown): value is symbol {
-  return typeof value === "symbol";
+    return typeof value === "symbol";
 }
 
 /**
@@ -270,22 +303,18 @@ function isSymbol(value: unknown): value is symbol {
  * @returns {boolean} True if the value is a plain object.
  */
 function isEmptyObject<T extends Record<string, unknown>>(
-  value: Nullable<T>,
+    value: Nullable<T>,
 ): value is T;
-function isEmptyObject(
-  value: unknown,
-): value is Record<string, unknown>;
-function isEmptyObject(
-  value: unknown,
-): value is Record<string, unknown> {
-  return (
-    typeof value === "object" &&
-    !isNull(value) &&
-    !isUndefined(value) &&
-    !isEmptyArray(value) &&
-    Object.getPrototypeOf(value) === Object.prototype &&
-    Object.keys(value).length === EMPTY_LENGTH
-  );
+function isEmptyObject(value: unknown): value is Record<string, unknown>;
+function isEmptyObject(value: unknown): value is Record<string, unknown> {
+    return (
+        typeof value === "object" &&
+        !isNull(value) &&
+        !isUndefined(value) &&
+        !isEmptyArray(value) &&
+        Object.getPrototypeOf(value) === Object.prototype &&
+        Object.keys(value).length === EMPTY_LENGTH
+    );
 }
 
 /**
@@ -295,10 +324,10 @@ function isEmptyObject(
  * @returns {boolean} True if the value is an instance of the class.
  */
 function isInstanceOf<T>(
-  value: unknown,
-  constructor: new (...args: unknown[]) => T,
+    value: unknown,
+    constructor: new (...args: unknown[]) => T,
 ): value is T {
-  return value instanceof constructor;
+    return value instanceof constructor;
 }
 
 /**
@@ -306,10 +335,8 @@ function isInstanceOf<T>(
  * @param {unknown} object - The object to get the keys of.
  * @returns {Array} Keys of object.
  */
-function getKeys<T extends Record<string, unknown>>(
-  object: T,
-): (keyof T)[] {
-  return Object.keys(object) as (keyof T)[];
+function getKeys<T extends Record<string, unknown>>(object: T): (keyof T)[] {
+    return Object.keys(object) as (keyof T)[];
 }
 
 /**
@@ -322,21 +349,18 @@ function getKeys<T extends Record<string, unknown>>(
  */
 function parseInteger(value: unknown): Optional<number>;
 function parseInteger(value: unknown, defaultValue: number): number;
-function parseInteger(
-  value: unknown,
-  defaultValue?: number,
-): Optional<number> {
-  if (isNumber(value)) {
-    return Math.floor(value);
-  }
-
-  if (isString(value)) {
-    const parsed = Number(value.trim());
-    if (Number.isInteger(parsed)) {
-      return parsed;
+function parseInteger(value: unknown, defaultValue?: number): Optional<number> {
+    if (isNumber(value)) {
+        return Math.floor(value);
     }
-  }
-  return defaultValue;
+
+    if (isString(value)) {
+        const parsed = Number(value.trim());
+        if (Number.isInteger(parsed)) {
+            return parsed;
+        }
+    }
+    return defaultValue;
 }
 
 /**
@@ -345,7 +369,7 @@ function parseInteger(
  * @returns {boolean} True if the value is an integer.
  */
 function isInteger(value: unknown): value is number {
-  return typeof value === "number" && Number.isInteger(value);
+    return typeof value === "number" && Number.isInteger(value);
 }
 
 /**
@@ -354,11 +378,11 @@ function isInteger(value: unknown): value is number {
  * @returns {boolean} True if the value is a float.
  */
 function isFloat(value: unknown): value is number {
-  return (
-    typeof value === "number" &&
-    !Number.isNaN(value) &&
-    !Number.isInteger(value)
-  );
+    return (
+        typeof value === "number" &&
+        !Number.isNaN(value) &&
+        !Number.isInteger(value)
+    );
 }
 
 /**
@@ -371,21 +395,18 @@ function isFloat(value: unknown): value is number {
  */
 function parseFloat(value: unknown): Optional<number>;
 function parseFloat(value: unknown, defaultValue: number): number;
-function parseFloat(
-  value: unknown,
-  defaultValue?: number,
-): Optional<number> {
-  if (isNumber(value)) {
-    return value;
-  }
-  if (isString(value)) {
-    const normalizedValue = value.trim().replace(",", ".");
-    const parsed = Number.parseFloat(normalizedValue);
-    if (!Number.isNaN(parsed)) {
-      return parsed;
+function parseFloat(value: unknown, defaultValue?: number): Optional<number> {
+    if (isNumber(value)) {
+        return value;
     }
-  }
-  return defaultValue;
+    if (isString(value)) {
+        const normalizedValue = value.trim().replace(",", ".");
+        const parsed = Number.parseFloat(normalizedValue);
+        if (!Number.isNaN(parsed)) {
+            return parsed;
+        }
+    }
+    return defaultValue;
 }
 /**
  * Parses the input value as a number. Returns NaN if the value cannot be
@@ -397,21 +418,18 @@ function parseFloat(
  */
 function parseNumber(value: unknown): Optional<number>;
 function parseNumber(value: unknown, defaultValue: number): number;
-function parseNumber(
-  value: unknown,
-  defaultValue?: number,
-): Optional<number> {
-  if (isNumber(value)) {
-    return value;
-  }
-  if (isString(value)) {
-    const normalizedValue = value.trim().replace(",", ".");
-    const parsed = Number(normalizedValue);
-    if (Number.isFinite(parsed)) {
-      return parsed;
+function parseNumber(value: unknown, defaultValue?: number): Optional<number> {
+    if (isNumber(value)) {
+        return value;
+    }
+    if (isString(value)) {
+        const normalizedValue = value.trim().replace(",", ".");
+        const parsed = Number(normalizedValue);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
     }
-  }
-  return defaultValue;
+    return defaultValue;
 }
 
 /**
@@ -422,20 +440,17 @@ function parseNumber(
  * be parsed.
  * @returns {string} The parsed string.
  */
-function parseString(
-  value: unknown,
-  defaultValue = "",
-): string {
-  if (isString(value)) {
-    return value;
-  }
-  if (isNumber(value)) {
-    return value.toString();
-  }
-  if (typeof value === "boolean") {
-    return value.toString();
-  }
-  return defaultValue;
+function parseString(value: unknown, defaultValue = ""): string {
+    if (isString(value)) {
+        return value;
+    }
+    if (isNumber(value)) {
+        return value.toString();
+    }
+    if (typeof value === "boolean") {
+        return value.toString();
+    }
+    return defaultValue;
 }
 
 /**
@@ -445,27 +460,29 @@ function parseString(
  * false, or a plain object whose values are all empty-like.
  */
 function isEmptyLike(value: unknown): boolean {
-  if (isNull(value) || isUndefined(value)) {
-    return true;
-  }
-  if (isString(value)) {
-    return isEmptyString(value);
-  }
-  if (isArray(value)) {
-    return value.every((entry) => {return isEmptyLike(entry)});
-  }
-  if (isBoolean(value)) {
-    return !value;
-  }
-  if (isObject(value)) {
-    if (Object.getPrototypeOf(value) !== Object.prototype) {
-      return false;
+    if (isNull(value) || isUndefined(value)) {
+        return true;
     }
-    return Object.values(value).every((entry) =>
-      {return isEmptyLike(entry)},
-    );
-  }
-  return false;
+    if (isString(value)) {
+        return isEmptyString(value);
+    }
+    if (isArray(value)) {
+        return value.every((entry) => {
+            return isEmptyLike(entry);
+        });
+    }
+    if (isBoolean(value)) {
+        return !value;
+    }
+    if (isObject(value)) {
+        if (Object.getPrototypeOf(value) !== Object.prototype) {
+            return false;
+        }
+        return Object.values(value).every((entry) => {
+            return isEmptyLike(entry);
+        });
+    }
+    return false;
 }
 
 /**
@@ -479,15 +496,17 @@ function isEmptyLike(value: unknown): boolean {
  *          representation of an empty object; otherwise, `false`.
  */
 function hasEmptyValues(value: unknown): boolean {
-  if (isString(value)) {
-    try {
-      if (isEmptyObject(JSON.parse(value))) {return true;}
-    } catch {
-      return isEmptyString(value);
+    if (isString(value)) {
+        try {
+            if (isEmptyObject(JSON.parse(value))) {
+                return true;
+            }
+        } catch {
+            return isEmptyString(value);
+        }
+        return isEmptyString(value);
     }
-    return isEmptyString(value);
-  }
-  return isEmptyObject(value);
+    return isEmptyObject(value);
 }
 
 /**
@@ -506,30 +525,34 @@ function parseArray<T extends Record<string, unknown>>(value: T): T[];
 function parseArray<T>(value: unknown, defaultValue: readonly T[]): T[];
 function parseArray(value: unknown): unknown[] | undefined;
 function parseArray(
-  value: unknown,
-  defaultValue?: readonly unknown[],
+    value: unknown,
+    defaultValue?: readonly unknown[],
 ): unknown[] | undefined {
-  if (isArray(value)) {
-    return [...value];
-  }
-  if (isString(value)) {
-    const parsed = value
-      .split(/[,|;\n\t ]+/)
-      .map((entry) => {return entry.trim()})
-      .filter((entry) => {return entry.length > EMPTY_LENGTH});
-    return parsed;
-  }
-  if (isNumber(value)) {
-    return [value];
-  }
-  if (isEmptyObject(value)) {
-    return [value];
-  }
-
-  if (isNull(value) || isUndefined(value)) {
+    if (isArray(value)) {
+        return [...value];
+    }
+    if (isString(value)) {
+        const parsed = value
+            .split(/[,|;\n\t ]+/)
+            .map((entry) => {
+                return entry.trim();
+            })
+            .filter((entry) => {
+                return entry.length > EMPTY_LENGTH;
+            });
+        return parsed;
+    }
+    if (isNumber(value)) {
+        return [value];
+    }
+    if (isEmptyObject(value)) {
+        return [value];
+    }
+
+    if (isNull(value) || isUndefined(value)) {
+        return cloneDefaultArray(defaultValue);
+    }
     return cloneDefaultArray(defaultValue);
-  }
-  return cloneDefaultArray(defaultValue);
 }
 
 /**
@@ -539,13 +562,17 @@ function parseArray(
  * @returns {boolean} True if the arrays have at least one common value.
  */
 function arrayContainsCommonValue<T>(
-  array1: readonly T[],
-  array2: readonly T[],
+    array1: readonly T[],
+    array2: readonly T[],
 ): boolean {
-  if (!isArray(array1) || !isArray(array2)) {return false;}
+    if (!isArray(array1) || !isArray(array2)) {
+        return false;
+    }
 
-  const valueOccurrences = new Set(array1);
-  return array2.some((value) => {return valueOccurrences.has(value)});
+    const valueOccurrences = new Set(array1);
+    return array2.some((value) => {
+        return valueOccurrences.has(value);
+    });
 }
 
 /**
@@ -554,7 +581,7 @@ function arrayContainsCommonValue<T>(
  * @returns {boolean} True if the input is a UUID string.
  */
 function isUuidString(input: unknown): input is string {
-  return isString(input) && uuidRegex.test(input);
+    return isString(input) && uuidRegex.test(input);
 }
 
 /**
@@ -563,7 +590,7 @@ function isUuidString(input: unknown): input is string {
  * @returns {boolean} True if the input is a ULID string.
  */
 function isUlidString(input: unknown): input is string {
-  return typeof input === "string" && ulidRegex.test(input);
+    return typeof input === "string" && ulidRegex.test(input);
 }
 
 /**
@@ -574,71 +601,70 @@ function isUlidString(input: unknown): input is string {
  */
 function parseDomainName(url: string): Optional<string>;
 function parseDomainName(url: string, defaultValue: string): string;
-function parseDomainName(
-  url: string,
-  defaultValue?: string,
-): Optional<string> {
-  const normalizedValue = url.trim();
-  if (normalizedValue === "" || normalizedValue.startsWith("/")) {
-    return defaultValue;
-  }
+function parseDomainName(url: string, defaultValue?: string): Optional<string> {
+    const normalizedValue = url.trim();
+    if (normalizedValue === "" || normalizedValue.startsWith("/")) {
+        return defaultValue;
+    }
 
-  let urlCandidate = normalizedValue;
-  if (!normalizedValue.includes("://")) {
-    urlCandidate = `https://${normalizedValue}`;
-  }
+    let urlCandidate = normalizedValue;
+    if (!normalizedValue.includes("://")) {
+        urlCandidate = `https://${normalizedValue}`;
+    }
 
-  let hostname = "";
-  try {
-    ({ hostname } = new URL(urlCandidate));
-  } catch {
-    return defaultValue;
-  }
+    let hostname = "";
+    try {
+        ({ hostname } = new URL(urlCandidate));
+    } catch {
+        return defaultValue;
+    }
 
-  const normalizedHostname = hostname.replace(/^www\d?\./i, "");
-  const [domainName] = normalizedHostname.split(".");
-  if (!domainName) {
-    return defaultValue;
-  }
+    const normalizedHostname = hostname.replace(/^www\d?\./i, "");
+    const [domainName] = normalizedHostname.split(".");
+    if (!domainName) {
+        return defaultValue;
+    }
 
-  return domainName;
+    return domainName;
 }
 
 export {
-  arrayContainsCommonValue,
-  fastIsArray,
-  getKeys,
-  hasEmptyValues,
-  isArray,
-  isBoolean,
-  isDate,
-  isEmptyArray,
-  isEmptyLike,
-  isEmptyObject,
-  isEmptyString,
-  isError,
-  isFloat,
-  isFunction,
-  isInstanceOf,
-  isInteger,
-  isMaybe,
-  isNull,
-  isNullable,
-  isNumber,
-  isObject,
-  isOptional,
-  isPromise,
-  isRegExp,
-  isString,
-  isSuccess,
-  isSymbol,
-  isUlidString,
-  isUndefined,
-  isUuidString,
-  parseArray,
-  parseDomainName,
-  parseFloat,
-  parseInteger,
-  parseNumber,
-  parseString,
+    arrayContainsCommonValue,
+    err,
+    fastIsArray,
+    getKeys,
+    hasEmptyValues,
+    isArray,
+    isBoolean,
+    isDate,
+    isEmptyArray,
+    isEmptyLike,
+    isEmptyObject,
+    isEmptyString,
+    isError,
+    isFloat,
+    isFunction,
+    isInstanceOf,
+    isInteger,
+    isMaybe,
+    isNull,
+    isNullable,
+    isNumber,
+    isObject,
+    isOptional,
+    isPromise,
+    isRegExp,
+    isString,
+    isSuccess,
+    isSymbol,
+    isUlidString,
+    isUndefined,
+    isUuidString,
+    ok,
+    parseArray,
+    parseDomainName,
+    parseFloat,
+    parseInteger,
+    parseNumber,
+    parseString,
 };