async function functionRecognizerInData(data, functionName, imports) {
    if (!data || !functionName) {
        return null;
    }

    try {
        let func = null;
        functionName = functionName.split(new RegExp('\\;|\\{|\\(|\\[|\\"|\\\'|\\`|\\}|\\)|\\]|\\:|\\,|\\*|\\+'));
        if (functionName.length > 1) {
            functionName = functionName.filter(r => r != '');
            if (utils.isNumeric(functionName[1])) {
                /* issue: (#45) */ functionName = functionName[0];
            } else {
                functionName = functionName[1];
            }
        } else {
            functionName = functionName[0];
        }

        if (functionName == '') {
            return null;
        }

        // TO REFACTOR
        if (data.split(new RegExp(`\\w+${functionName}|${functionName}\\w+|\\w+${functionName}\\w+`)).length > 1) {
            data = data.replaceAll(new RegExp(`\\s*\\n*\\t*\\.\\s*\\n*\\t*headers\\s*\\n*\\t*\\.\\s*\\n*\\t*${functionName}`), '____HEADERS____');
            data = data.replaceAll(new RegExp(`\\s*\\n*\\t*\\.\\s*\\n*\\t*headers\\s*\\n*\\t*\\[\\s*\\n*\\t*"${functionName}`), '____HEADERS1____');
            data = data.replaceAll(new RegExp(`\\s*\\n*\\t*\\.\\s*\\n*\\t*headers\\s*\\n*\\t*\\[\\s*\\n*\\t*'${functionName}`), '____HEADERS2____');
            data = data.replaceAll(new RegExp(`\\s*\\n*\\t*\\.\\s*\\n*\\t*headers\\s*\\n*\\t*\\[\\s*\\n*\\t*\`${functionName}`), '____HEADERS3____');

            data = data.replaceAll(new RegExp(`var\\s+\\n*\\t*\\{\\s*\\n*\\t*${functionName}`), '____VARIABLE_DEST____');
            data = data.replaceAll(new RegExp(`let\\s+\\n*\\t*\\{\\s*\\n*\\t*${functionName}`), '____VARIABLE_DEST____');
            data = data.replaceAll(new RegExp(`const\\s+\\n*\\t*\\{\\s*\\n*\\t*${functionName}`), '____VARIABLE_DEST____');
            data = data.replaceAll(new RegExp(`\\,\\s*\\n*\\t*${functionName}`), '____VARIABLE____');
            data = data.replaceAll(new RegExp(`body\\s*\\n*\\t*\\.\\s*\\n*\\t*${functionName}`), '____VARIABLE_BODY____');
            data = data.replaceAll(new RegExp(`query\\s*\\n*\\t*\\.\\s*\\n*\\t*${functionName}`), '____VARIABLE_QUERY____');
            data = data.replaceAll(new RegExp(`headers\\s*\\n*\\t*\\.\\s*\\n*\\t*${functionName}`), '____VARIABLE_HEADERS____');

            data = data.split(new RegExp(`${functionName}`));
            if (data.length > 1) {
                for (let idxHeader = 1; idxHeader < data.length; ++idxHeader) {
                    let startComment = utils.getFirstPosition('/*', data[idxHeader].split('//')[0]);
                    let endComment = utils.getFirstPosition('*/', data[idxHeader].split('//')[0]);
                    if ((endComment && !startComment) || startComment > endComment) {
                        // keep in comment
                        data[idxHeader] = '____KEEP_NAME____' + data[idxHeader];
                    } else {
                        data[idxHeader] = `${functionName}` + data[idxHeader];
                    }
                }
                data = data.join('');
            } else {
                data = data[0];
            }
            data = data.split(new RegExp(`\\w+${functionName}|${functionName}\\w+|\\w+${functionName}\\w+`));
            data = data.join(' ');

            data = data.replaceAll('____KEEP_NAME____', `${functionName}`);
            data = data.replaceAll('____HEADERS____', `.headers.${functionName}`);
            data = data.replaceAll('____HEADERS1____', `.headers["${functionName}`);
            data = data.replaceAll('____HEADERS2____', `.headers['${functionName}`);
            data = data.replaceAll('____HEADERS3____', `.headers[\`${functionName}`);
            data = data.replaceAll('____VARIABLE_DEST____', `let { ${functionName}`);
            data = data.replaceAll('____VARIABLE____', `, ${functionName}`);
            data = data.replaceAll('____VARIABLE_BODY____', `body.${functionName}`);
            data = data.replaceAll('____VARIABLE_QUERY____', `query.${functionName}`);
            data = data.replaceAll('____VARIABLE_HEADERS____', `headers.${functionName}`);
        }

        data = data.replaceAll(' function ', ' ');

        let arrowFunction = data.split(new RegExp(`(${functionName}\\s*\\n*\\t*\\:?\\s*\\n*\\t*\\w*\\s*\\n*\\t*\\=\\s*\\n*\\t*\\([\\s\\S]*\\)\\s*\\t*=>\\s*\\n*\\t*\\{)`));
        let arrowFunctionWithoutCurlyBracket = [''];
        let traditionalFunction = [''];
        let arrowFunctionType = 1;
        let regexImports = [];

        if (arrowFunction.length == 1) {
            arrowFunctionWithoutCurlyBracket = data.split(new RegExp(`(${functionName}\\s*\\n*\\t*\\:?\\s*\\n*\\t*\\w*\\s*\\n*\\t*\\=\\s*\\n*\\t*\\([\\s\\S]*\\)\\s*\\t*=>)`));
            if (arrowFunctionWithoutCurlyBracket.length == 1) {
                // CASE:  foo: (req, res) => {
                arrowFunction = data.split(new RegExp(`(${functionName}\\s*\\n*\\t*\\:?\\s*\\n*\\t*\\s*\\n*\\t*\\s*\\n*\\t*\\([\\s\\S]*\\)\\s*\\t*=>\\s*\\n*\\t*\\{)`));
                if (arrowFunction.length > 1) {
                    arrowFunctionType = 2;
                } else {
                    traditionalFunction = data.split(new RegExp(`(${functionName}\\s*\\n*\\t*\\:?\\s*\\n*\\t*\\=?\\s*\\n*\\t*\\([\\s\\S]*\\)\\s*\\n*\\t*\\:?\\s*\\n*\\t*\\w*\\s*\\n*\\t*\\<?\\s*\\n*\\t*\\w*\\s*\\n*\\t*\\>?\\s*\\n*\\t*\\{)`));
                    if (traditionalFunction.length == 1 && data.split(new RegExp(`${functionName}\\s*\\n*\\t*=\\s*\\n*\\t*\\[`)).length == 1) {
                        let myRegexp = new RegExp('(\\=\\s*\\n*\\t*\\([\\s\\S]*?\\)\\s*:[\\s\\S]*?=>)');
                        let matchFunctions = myRegexp.exec(data);

                        if (matchFunctions && matchFunctions.length > 0) {
                            for (let idx = 0; idx < matchFunctions.length; idx++) {
                                let match = matchFunctions[idx];
                                if (match.includes('=>')) {
                                    match = match.split(':');
                                    match.pop();
                                    match = match.join(':') + ' => ';
                                    data = data.replace(matchFunctions[idx], match);
                                }
                                arrowFunction = data.split(new RegExp(`(${functionName}\\s*\\n*\\t*\\:?\\s*\\n*\\t*\\w*\\s*\\n*\\t*\\=\\s*\\n*\\t*\\([\\s\\S]*\\)\\s*\\t*=>\\s*\\n*\\t*\\{)`));
                            }
                        } else if (imports) {
                            imports
                                .filter(e => e)
                                .forEach(imp => {
                                    if (imp.varFileName) {
                                        regexImports.push(imp.varFileName);
                                    }
                                    if (imp.exports) {
                                        imp.exports
                                            .filter(e => e)
                                            .forEach(imp => {
                                                regexImports.push(imp.varName || imp.varAlias);
                                            });
                                    }
                                });

                            for (let idxImp = 0; idxImp < regexImports.length; idxImp++) {
                                const originalArrowFunction = arrowFunction;
                                try {
                                    arrowFunction = data.split(new RegExp(`(${functionName}\\s*\\n*\\t*\\:?\\s*\\n*\\t*\\w*\\s*\\n*\\t*\\=\\s*\\n*\\t*${regexImports[idxImp]}\\s*\\n*\\t*\\([\\s\\S]*\\)\\s*\\t*=>\\s*\\n*\\t*\\{)`));
                                } catch (err) {
                                    arrowFunction = originalArrowFunction;
                                }
                                if (arrowFunction.length > 1) {
                                    break;
                                }
                            }
                            if (arrowFunction.length > 3) {
                                // avoiding ambiguity
                                arrowFunction = [];
                                arrowFunction[0] = data;
                                regexImports = '';
                            }
                        } else {
                            // CASE: exports.foo = [ ]
                            return null;
                        }
                    }
                }
            }
        }

        let isArrowFunction = false;
        let isArrowFunctionWithoutCurlyBracket = false;
        let isTraditionalFunction = false;

        if (arrowFunction.length > 1) {
            func = arrowFunction;
            isArrowFunction = true;
        } else if (arrowFunctionWithoutCurlyBracket.length > 1) {
            func = arrowFunctionWithoutCurlyBracket;
            isArrowFunctionWithoutCurlyBracket = true;
        } else if (traditionalFunction.length > 1) {
            func = traditionalFunction;
            isTraditionalFunction = true;
        } else {
            // CASE: exports.validateUser = [ ]
            let array = data.split(new RegExp(`${functionName}\\s*\\n*\\t*=\\s*\\n*\\t*\\[`));
            if (array.length > 1) {
                array[1] = await utils.stackSymbolRecognizer(array[1], '[', ']');
                let resp = await utils.stackSymbolRecognizer(array[1], '(', ')');
                return '[' + resp;
            }
        }

        if (func && func.length > 1) {
            func.shift();
            func = func.join(' ');
        }

        if (func && func.length > 1) {
            if (isArrowFunctionWithoutCurlyBracket) {
                // CASE: arrow funciton without {, for example: func => func(...);
                let funcStr = func;
                funcStr = funcStr.split('=>')[0];
                if (funcStr.includes('=')) {
                    funcStr = funcStr.split('=')[1];
                }
                funcStr = funcStr + '=> {';
                let arrowFunc = func.split('=>')[1].trimLeft();
                arrowFunc = arrowFunc.split(new RegExp('\\n|\\s|\\t|\\;'));
                for (let idx = 0; idx < arrowFunc.length; idx++) {
                    if (arrowFunc[idx] != '') {
                        let strRet = funcStr + arrowFunc[idx] + '}';
                        return strRet;
                    }
                    if (idx == arrowFunc.length - 1) {
                        return null;
                    }
                }
            } else if (isArrowFunction || isTraditionalFunction) {
                func = func.split('{');
                func.shift();
                func = func.join('{');
                let funcStr = null;
                if (isArrowFunction && arrowFunctionType == 1) {
                    funcStr = data.split(new RegExp(`${functionName}\\s*\\n*\\t*\\:?\\s*\\n*\\t*\\w*\\s*\\n*\\t*\\=\\s*\\n*\\t*\\(`));
                    if (funcStr.length == 1 && regexImports.length > 0) {
                        for (let idxImp = 0; idxImp < regexImports.length; idxImp++) {
                            funcStr = data.split(new RegExp(`${functionName}\\s*\\n*\\t*\\:?\\s*\\n*\\t*\\w*\\s*\\n*\\t*\\=\\s*\\n*\\t*${regexImports[idxImp]}\\s*\\n*\\t*\\(`));
                            if (funcStr.length > 1) {
                                break;
                            }
                        }
                    }
                    if (funcStr.length > 1) {
                        funcStr = funcStr[1];
                    } else {
                        funcStr = null;
                    }
                }
                if (isArrowFunction && arrowFunctionType == 2) {
                    funcStr = data.split(new RegExp(`${functionName}\\s*\\n*\\t*\\:?\\s*\\n*\\t*\\s*\\n*\\t*\\s*\\n*\\t*\\(`))[1];
                } else if (isTraditionalFunction) {
                    funcStr = data.split(new RegExp(`${functionName}\\s*\\n*\\t*\\:?\\s*\\n*\\t*\\=?\\s*\\n*\\t*\\(`))[1];
                }

                if (funcStr && funcStr.split('}').length > 1) {
                    funcStr = funcStr.split('{')[0];
                }
                funcStr = '(' + funcStr + (isArrowFunction ? ' { ' : ' => { '); // TODO: Verify case 'funcStr' with '=> =>'
                let cleanedParams = funcStr.split(')')[0];
                cleanedParams = cleanedParams
                    .split(',')
                    .map(p => {
                        return p.split('=')[0];
                    })
                    .join(',');
                let aux = funcStr.split(')');
                aux.shift();
                aux = aux.join(')');
                funcStr = cleanedParams + ')' + aux;
                funcStr = funcStr.replace('((', '(');
                let finalFunc = await utils.stackSymbolRecognizer(func, '{', '}');
                return funcStr + finalFunc;
            } else {
                return null;
            }
        } else {
            return null;
        }
    } catch (err) {
        return null;
    }
}
TODO: REFACTOR THIS FUNCTION
Recognize function in a string data.
@param {string} data content.
@param {string} functionName