inibase 1.0.0-rc.4 → 1.0.0-rc.42

package/dist/index.thread.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.thread.js

@@ -0,0 +1,6 @@
+import Inibase from "./index.js";
+import { parentPort, workerData } from "node:worker_threads";
+const { _constructor, functionName, arg } = workerData;
+// @ts-ignore
+new Inibase(..._constructor)[functionName](...arg)
+    .then((res) => parentPort?.postMessage(res));

package/dist/utils.d.ts

@@ -0,0 +1,206 @@
+import type { FieldType, ComparisonOperator } from "./index.js";
+/**
+ * Type guard function to check if the input is an array of objects.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is an array of objects, false otherwise.
+ *
+ * Note: Considers empty arrays and arrays where every element is an object.
+ */
+export declare const isArrayOfObjects: (input: any) => input is Record<any, any>[];
+/**
+ * Type guard function to check if the input is an array of arrays.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is an array of arrays, false otherwise.
+ *
+ * Note: Considers empty arrays and arrays where every element is also an array.
+ */
+export declare const isArrayOfArrays: (input: any) => input is any[][];
+/**
+ * Type guard function to check if the input is an array of nulls or an array of arrays of nulls.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is an array consisting entirely of nulls or arrays of nulls, false otherwise.
+ *
+ * Note: Recursively checks each element, allowing for nested arrays of nulls.
+ */
+export declare const isArrayOfNulls: (input: any) => input is null[] | null[][];
+/**
+ * Type guard function to check if the input is an object.
+ *
+ * @param obj - The value to be checked.
+ * @returns boolean - True if the input is an object (excluding arrays), false otherwise.
+ *
+ * Note: Checks if the input is non-null and either has 'Object' as its constructor name or is of type 'object' without being an array.
+ */
+export declare const isObject: (obj: any) => obj is Record<any, any>;
+/**
+ * Recursively merges properties from a source object into a target object. If a property exists in both, the source's value overwrites the target's.
+ *
+ * @param target - The target object to merge properties into.
+ * @param source - The source object from which properties are merged.
+ * @returns any - The modified target object with merged properties.
+ *
+ * Note: Performs a deep merge for nested objects. Non-object properties are directly overwritten.
+ */
+export declare const deepMerge: (target: any, source: any) => any;
+/**
+ * Combines an array of objects into a single object. If the same key exists in multiple objects, the values are merged.
+ *
+ * @param arr - Array of objects to be combined.
+ * @returns Record<string, any> - A single object with combined keys and values.
+ *
+ * Note: Handles nested objects by recursively combining them. Non-object values with the same key are merged into arrays.
+ */
+export declare const combineObjects: (arr: Record<string, any>[]) => Record<string, any>;
+/**
+ * Type guard function to check if the input is a number.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a number, false otherwise.
+ *
+ * Note: Validates that the input can be parsed as a float and that subtracting zero results in a number, ensuring it's a numeric value.
+ */
+export declare const isNumber: (input: any) => input is number;
+/**
+ * Checks if the input is a valid email format.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input matches the email format, false otherwise.
+ *
+ * Note: Uses a regular expression to validate the email format, ensuring it has parts separated by '@' and contains a domain with a period.
+ */
+export declare const isEmail: (input: any) => boolean;
+/**
+ * Checks if the input is a valid URL format.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input matches the URL format, false otherwise.
+ *
+ * Note: Validates URLs including protocols (http/https), domain names, IP addresses, ports, paths, query strings, and fragments.
+ *       Also recognizes 'tel:' and 'mailto:' as valid URL formats, as well as strings starting with '#' without spaces.
+ */
+export declare const isURL: (input: any) => boolean;
+/**
+ * Checks if the input contains HTML tags or entities.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input contains HTML tags or entities, false otherwise.
+ *
+ * Note: Uses a regular expression to detect HTML tags (like <tag>) and entities (like &entity;).
+ *       Recognizes both opening and closing tags, as well as self-closing tags.
+ */
+export declare const isHTML: (input: any) => boolean;
+/**
+ * Type guard function to check if the input is a string, excluding strings that match specific formats (number, boolean, email, URL, IP).
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a string that doesn't match the specific formats, false otherwise.
+ *
+ * Note: Validates the input against being a number, boolean, email, URL, or IP address to ensure it's a general string.
+ */
+export declare const isString: (input: any) => input is string;
+/**
+ * Checks if the input is a valid IP address format.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input matches the IP address format, false otherwise.
+ *
+ * Note: Uses a regular expression to validate IP addresses, ensuring they consist of four octets, each ranging from 0 to 255.
+ */
+export declare const isIP: (input: any) => boolean;
+/**
+ * Type guard function to check if the input is a boolean or a string representation of a boolean.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a boolean value or 'true'/'false' strings, false otherwise.
+ *
+ * Note: Recognizes both boolean literals (true, false) and their string representations ("true", "false").
+ */
+export declare const isBoolean: (input: any) => input is boolean;
+/**
+ * Type guard function to check if the input is a password based on a specific length criterion.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a string with a length of 161 characters, false otherwise.
+ *
+ * Note: Specifically checks for string length to determine if it matches the defined password length criterion.
+ */
+export declare const isPassword: (input: any) => input is string;
+/**
+ * Checks if the input can be converted to a valid date.
+ *
+ * @param input - The input to be checked, can be of any type.
+ * @returns A boolean indicating whether the input is a valid date.
+ */
+export declare const isDate: (input: any) => boolean;
+/**
+ * Checks if the input is a valid ID.
+ *
+ * @param input - The input to be checked, can be of any type.
+ * @returns A boolean indicating whether the input is a string representing a valid ID of length 32.
+ */
+export declare const isValidID: (input: any) => input is string;
+/**
+ * Checks if a given string is a valid JSON.
+ *
+ * @param {string} str - The string to be checked.
+ * @returns {boolean} Returns true if the string is valid JSON, otherwise false.
+ */
+export declare const isJSON: (str: string) => boolean;
+/**
+ * Identifies and returns properties that have changed between two objects.
+ *
+ * @param obj1 - The first object for comparison, with string keys and values.
+ * @param obj2 - The second object for comparison, with string keys and values.
+ * @returns A record of changed properties with original values from obj1 and new values from obj2, or null if no changes are found.
+ */
+export declare const findChangedProperties: (obj1: Record<string, string>, obj2: Record<string, string>) => Record<string, string> | null;
+/**
+ * Detects the field type of an input based on available types.
+ *
+ * @param input - The input whose field type is to be detected.
+ * @param availableTypes - An array of potential field types to consider.
+ * @returns The detected field type as a string, or undefined if no matching type is found.
+ */
+export declare const detectFieldType: (input: any, availableTypes: FieldType[]) => FieldType | undefined;
+/**
+ * Validates if the given value matches the specified field type(s).
+ *
+ * @param value - The value to be validated.
+ * @param fieldType - The expected field type or an array of possible field types.
+ * @param fieldChildrenType - Optional; the expected type(s) of children elements, used if the field type is an array.
+ * @returns A boolean indicating whether the value matches the specified field type(s).
+ */
+export declare const validateFieldType: (value: any, fieldType: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[]) => boolean;
+export declare function FormatObjectCriteriaValue(value: string, isParentArray?: boolean): [
+    ComparisonOperator,
+    string | number | boolean | null | (string | number | null)[]
+];
+type ValidKey = number | string;
+export declare const swapKeyValue: <K extends ValidKey, V extends ValidKey>(object: Record<K, V>) => Record<V, K>;
+export default class Utils {
+    static isNumber: (input: any) => input is number;
+    static isObject: (obj: any) => obj is Record<any, any>;
+    static isEmail: (input: any) => boolean;
+    static isDate: (input: any) => boolean;
+    static isURL: (input: any) => boolean;
+    static isValidID: (input: any) => input is string;
+    static isPassword: (input: any) => input is string;
+    static deepMerge: (target: any, source: any) => any;
+    static combineObjects: (arr: Record<string, any>[]) => Record<string, any>;
+    static isArrayOfObjects: (input: any) => input is Record<any, any>[];
+    static findChangedProperties: (obj1: Record<string, string>, obj2: Record<string, string>) => Record<string, string> | null;
+    static detectFieldType: (input: any, availableTypes: FieldType[]) => FieldType | undefined;
+    static isArrayOfArrays: (input: any) => input is any[][];
+    static isBoolean: (input: any) => input is boolean;
+    static isString: (input: any) => input is string;
+    static isHTML: (input: any) => boolean;
+    static isIP: (input: any) => boolean;
+    static validateFieldType: (value: any, fieldType: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[] | undefined) => boolean;
+    static isArrayOfNulls: (input: any) => input is null[] | null[][];
+    static FormatObjectCriteriaValue: typeof FormatObjectCriteriaValue;
+    static swapKeyValue: <K extends ValidKey, V extends ValidKey>(object: Record<K, V>) => Record<V, K>;
+}
+export {};

package/dist/utils.js

@@ -0,0 +1,418 @@
+/**
+ * Type guard function to check if the input is an array of objects.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is an array of objects, false otherwise.
+ *
+ * Note: Considers empty arrays and arrays where every element is an object.
+ */
+export const isArrayOfObjects = (input) => Array.isArray(input) && (input.length === 0 || input.every(isObject));
+/**
+ * Type guard function to check if the input is an array of arrays.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is an array of arrays, false otherwise.
+ *
+ * Note: Considers empty arrays and arrays where every element is also an array.
+ */
+export const isArrayOfArrays = (input) => Array.isArray(input) && (input.length === 0 || input.every(Array.isArray));
+/**
+ * Type guard function to check if the input is an array of nulls or an array of arrays of nulls.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is an array consisting entirely of nulls or arrays of nulls, false otherwise.
+ *
+ * Note: Recursively checks each element, allowing for nested arrays of nulls.
+ */
+export const isArrayOfNulls = (input) => input.every((_input) => Array.isArray(_input) ? isArrayOfNulls(_input) : _input === null);
+/**
+ * Type guard function to check if the input is an object.
+ *
+ * @param obj - The value to be checked.
+ * @returns boolean - True if the input is an object (excluding arrays), false otherwise.
+ *
+ * Note: Checks if the input is non-null and either has 'Object' as its constructor name or is of type 'object' without being an array.
+ */
+export const isObject = (obj) => obj != null &&
+    (obj.constructor.name === "Object" ||
+        (typeof obj === "object" && !Array.isArray(obj)));
+/**
+ * Recursively merges properties from a source object into a target object. If a property exists in both, the source's value overwrites the target's.
+ *
+ * @param target - The target object to merge properties into.
+ * @param source - The source object from which properties are merged.
+ * @returns any - The modified target object with merged properties.
+ *
+ * Note: Performs a deep merge for nested objects. Non-object properties are directly overwritten.
+ */
+export const deepMerge = (target, source) => {
+    for (const key in source) {
+        if (source.hasOwnProperty(key)) {
+            if (isObject(source[key]) && isObject(target[key]))
+                target[key] = deepMerge(target[key], source[key]);
+            else
+                target[key] = source[key];
+        }
+    }
+    return target;
+};
+/**
+ * Combines an array of objects into a single object. If the same key exists in multiple objects, the values are merged.
+ *
+ * @param arr - Array of objects to be combined.
+ * @returns Record<string, any> - A single object with combined keys and values.
+ *
+ * Note: Handles nested objects by recursively combining them. Non-object values with the same key are merged into arrays.
+ */
+export const combineObjects = (arr) => {
+    const result = {};
+    for (const obj of arr) {
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                const existingValue = result[key];
+                const newValue = obj[key];
+                if (isObject(existingValue) &&
+                    isObject(newValue) &&
+                    existingValue !== null &&
+                    existingValue !== undefined &&
+                    newValue !== null &&
+                    newValue !== undefined) {
+                    // If both values are objects, recursively combine them
+                    result[key] = combineObjects([existingValue, newValue]);
+                }
+                else {
+                    // If one or both values are not objects, overwrite the existing value
+                    result[key] =
+                        existingValue !== null && existingValue !== undefined
+                            ? Array.isArray(existingValue)
+                                ? Array.isArray(newValue)
+                                    ? [...existingValue, ...newValue]
+                                    : [...existingValue, newValue]
+                                : Array.isArray(newValue)
+                                    ? [existingValue, ...newValue]
+                                    : [existingValue, newValue]
+                            : newValue;
+                }
+            }
+        }
+    }
+    return result;
+};
+/**
+ * Type guard function to check if the input is a number.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a number, false otherwise.
+ *
+ * Note: Validates that the input can be parsed as a float and that subtracting zero results in a number, ensuring it's a numeric value.
+ */
+export const isNumber = (input) => !isNaN(parseFloat(input)) && !isNaN(input - 0);
+/**
+ * Checks if the input is a valid email format.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input matches the email format, false otherwise.
+ *
+ * Note: Uses a regular expression to validate the email format, ensuring it has parts separated by '@' and contains a domain with a period.
+ */
+export const isEmail = (input) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(input));
+/**
+ * Checks if the input is a valid URL format.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input matches the URL format, false otherwise.
+ *
+ * Note: Validates URLs including protocols (http/https), domain names, IP addresses, ports, paths, query strings, and fragments.
+ *       Also recognizes 'tel:' and 'mailto:' as valid URL formats, as well as strings starting with '#' without spaces.
+ */
+export const isURL = (input) => {
+    if (typeof input !== "string")
+        return false;
+    if ((input[0] === "#" && !input.includes(" ")) ||
+        input.startsWith("tel:") ||
+        input.startsWith("mailto:"))
+        return true;
+    else {
+        var pattern = new RegExp("^(https?:\\/\\/)?" + // protocol
+            "((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|" + // domain name
+            "localhost|" + // OR localhost
+            "((\\d{1,3}\\.){3}\\d{1,3}))" + // OR ip (v4) address
+            "(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*" + // port and path
+            "(\\?[;&a-z\\d%_.~+=-]*)?" + // query string
+            "(\\#[-a-z\\d_]*)?$", "i"); // fragment locator
+        return !!pattern.test(input);
+    }
+};
+/**
+ * Checks if the input contains HTML tags or entities.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input contains HTML tags or entities, false otherwise.
+ *
+ * Note: Uses a regular expression to detect HTML tags (like <tag>) and entities (like &entity;).
+ *       Recognizes both opening and closing tags, as well as self-closing tags.
+ */
+export const isHTML = (input) => /<\/?\s*[a-z-][^>]*\s*>|(\&(?:[\w\d]+|#\d+|#x[a-f\d]+);)/g.test(input);
+/**
+ * Type guard function to check if the input is a string, excluding strings that match specific formats (number, boolean, email, URL, IP).
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a string that doesn't match the specific formats, false otherwise.
+ *
+ * Note: Validates the input against being a number, boolean, email, URL, or IP address to ensure it's a general string.
+ */
+export const isString = (input) => Object.prototype.toString.call(input) === "[object String]" &&
+    [isNumber, isBoolean, isEmail, isURL, isIP].every((fn) => !fn(input));
+/**
+ * Checks if the input is a valid IP address format.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input matches the IP address format, false otherwise.
+ *
+ * Note: Uses a regular expression to validate IP addresses, ensuring they consist of four octets, each ranging from 0 to 255.
+ */
+export const isIP = (input) => /^(?:(?:^|\.)(?:2(?:5[0-5]|[0-4]\d)|1?\d?\d)){4}$/.test(input);
+/**
+ * Type guard function to check if the input is a boolean or a string representation of a boolean.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a boolean value or 'true'/'false' strings, false otherwise.
+ *
+ * Note: Recognizes both boolean literals (true, false) and their string representations ("true", "false").
+ */
+export const isBoolean = (input) => typeof input === "boolean" ||
+    input === "true" ||
+    input === "false" ||
+    input === true ||
+    input === false;
+/**
+ * Type guard function to check if the input is a password based on a specific length criterion.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a string with a length of 161 characters, false otherwise.
+ *
+ * Note: Specifically checks for string length to determine if it matches the defined password length criterion.
+ */
+export const isPassword = (input) => typeof input === "string" && input.length === 97;
+/**
+ * Checks if the input can be converted to a valid date.
+ *
+ * @param input - The input to be checked, can be of any type.
+ * @returns A boolean indicating whether the input is a valid date.
+ */
+export const isDate = (input) => !isNaN(new Date(input).getTime()) || !isNaN(Date.parse(input));
+/**
+ * Checks if the input is a valid ID.
+ *
+ * @param input - The input to be checked, can be of any type.
+ * @returns A boolean indicating whether the input is a string representing a valid ID of length 32.
+ */
+export const isValidID = (input) => {
+    return typeof input === "string" && input.length === 32;
+};
+/**
+ * Checks if a given string is a valid JSON.
+ *
+ * @param {string} str - The string to be checked.
+ * @returns {boolean} Returns true if the string is valid JSON, otherwise false.
+ */
+export const isJSON = (str) => str[0] === "{" || str[0] === "[";
+/**
+ * Identifies and returns properties that have changed between two objects.
+ *
+ * @param obj1 - The first object for comparison, with string keys and values.
+ * @param obj2 - The second object for comparison, with string keys and values.
+ * @returns A record of changed properties with original values from obj1 and new values from obj2, or null if no changes are found.
+ */
+export const findChangedProperties = (obj1, obj2) => {
+    const result = {};
+    for (const key1 in obj1)
+        if (obj2.hasOwnProperty(key1) && obj1[key1] !== obj2[key1])
+            result[obj1[key1]] = obj2[key1];
+    return Object.keys(result).length ? result : null;
+};
+/**
+ * Detects the field type of an input based on available types.
+ *
+ * @param input - The input whose field type is to be detected.
+ * @param availableTypes - An array of potential field types to consider.
+ * @returns The detected field type as a string, or undefined if no matching type is found.
+ */
+export const detectFieldType = (input, availableTypes) => {
+    if (!Array.isArray(input)) {
+        if ((input === "0" ||
+            input === "1" ||
+            input === "true" ||
+            input === "false") &&
+            availableTypes.includes("boolean"))
+            return "boolean";
+        else if (isNumber(input)) {
+            if (availableTypes.includes("table"))
+                return "table";
+            else if (availableTypes.includes("date"))
+                return "date";
+            else if (availableTypes.includes("number"))
+                return "number";
+        }
+        else if (availableTypes.includes("table") && isValidID(input))
+            return "table";
+        else if (input.includes(",") && availableTypes.includes("array"))
+            return "array";
+        else if (availableTypes.includes("email") && isEmail(input))
+            return "email";
+        else if (availableTypes.includes("url") && isURL(input))
+            return "url";
+        else if (availableTypes.includes("password") && isPassword(input))
+            return "password";
+        else if (availableTypes.includes("json") && isJSON(input))
+            return "json";
+        else if (availableTypes.includes("json") && isDate(input))
+            return "json";
+        else if (availableTypes.includes("string") && isString(input))
+            return "string";
+        else if (availableTypes.includes("ip") && isIP(input))
+            return "ip";
+    }
+    else
+        return "array";
+    return undefined;
+};
+/**
+ * Validates if the given value matches the specified field type(s).
+ *
+ * @param value - The value to be validated.
+ * @param fieldType - The expected field type or an array of possible field types.
+ * @param fieldChildrenType - Optional; the expected type(s) of children elements, used if the field type is an array.
+ * @returns A boolean indicating whether the value matches the specified field type(s).
+ */
+export const validateFieldType = (value, fieldType, fieldChildrenType) => {
+    if (value === null)
+        return true;
+    if (Array.isArray(fieldType))
+        return detectFieldType(value, fieldType) !== undefined;
+    if (fieldType === "array" && fieldChildrenType && Array.isArray(value))
+        return value.every((v) => detectFieldType(v, Array.isArray(fieldChildrenType)
+            ? fieldChildrenType
+            : [fieldChildrenType]) !== undefined);
+    switch (fieldType) {
+        case "string":
+            return isString(value);
+        case "password":
+            return isNumber(value) || isPassword(value) || isString(value);
+        case "number":
+            return isNumber(value);
+        case "html":
+            return isHTML(value);
+        case "ip":
+            return isIP(value);
+        case "boolean":
+            return isBoolean(value);
+        case "date":
+            return isDate(value);
+        case "object":
+            return isObject(value);
+        case "array":
+            return Array.isArray(value);
+        case "email":
+            return isEmail(value);
+        case "url":
+            return isURL(value);
+        case "table":
+            // feat: check if id exists
+            if (Array.isArray(value))
+                return ((isArrayOfObjects(value) &&
+                    value.every((element) => element.hasOwnProperty("id") &&
+                        (isValidID(element.id) || isNumber(element.id)))) ||
+                    value.every(isNumber) ||
+                    isValidID(value));
+            else if (isObject(value))
+                return (value.hasOwnProperty("id") &&
+                    (isValidID(value.id) || isNumber(value.id)));
+            else
+                return isNumber(value) || isValidID(value);
+        case "id":
+            return isNumber(value) || isValidID(value);
+        case "json":
+            return isJSON(value) || Array.isArray(value) || isObject(value);
+        default:
+            return false;
+    }
+};
+export function FormatObjectCriteriaValue(value, isParentArray = false) {
+    switch (value[0]) {
+        case ">":
+        case "<":
+            return value[1] === "="
+                ? [
+                    value.slice(0, 2),
+                    value.slice(2),
+                ]
+                : [
+                    value.slice(0, 1),
+                    value.slice(1),
+                ];
+        case "[":
+            return value[1] === "]"
+                ? [
+                    value.slice(0, 2),
+                    value.slice(2).toString().split(","),
+                ]
+                : ["[]", value.slice(1)];
+        case "!":
+            return ["=", "*"].includes(value[1])
+                ? [
+                    value.slice(0, 2),
+                    value.slice(2),
+                ]
+                : value[1] === "["
+                    ? [
+                        value.slice(0, 3),
+                        value.slice(3),
+                    ]
+                    : [
+                        (value.slice(0, 1) + "="),
+                        value.slice(1),
+                    ];
+        case "=":
+            return isParentArray
+                ? [
+                    value.slice(0, 1),
+                    value.slice(1),
+                ]
+                : [
+                    value.slice(0, 1),
+                    (value.slice(1) + ","),
+                ];
+        case "*":
+            return [
+                value.slice(0, 1),
+                value.slice(1),
+            ];
+        default:
+            return ["=", value];
+    }
+}
+export const swapKeyValue = (object) => Object.entries(object).reduce((swapped, [key, value]) => ({ ...swapped, [value]: key }), {});
+export default class Utils {
+    static isNumber = isNumber;
+    static isObject = isObject;
+    static isEmail = isEmail;
+    static isDate = isDate;
+    static isURL = isURL;
+    static isValidID = isValidID;
+    static isPassword = isPassword;
+    static deepMerge = deepMerge;
+    static combineObjects = combineObjects;
+    static isArrayOfObjects = isArrayOfObjects;
+    static findChangedProperties = findChangedProperties;
+    static detectFieldType = detectFieldType;
+    static isArrayOfArrays = isArrayOfArrays;
+    static isBoolean = isBoolean;
+    static isString = isString;
+    static isHTML = isHTML;
+    static isIP = isIP;
+    static validateFieldType = validateFieldType;
+    static isArrayOfNulls = isArrayOfNulls;
+    static FormatObjectCriteriaValue = FormatObjectCriteriaValue;
+    static swapKeyValue = swapKeyValue;
+}