Nothing to repeat error

Nothing to repeat is a syntax error within your regular expression. It means that there is a quantifier ( *, ?, +, {m,n}) that is in a position where it has nothing to repeat. It usually happens with a quantifier at the beginning of the expression, or with one quantifier following another (invalid).

It is common to see it when a special character for the regular expression is not being escaped correctly.

/*  Ejemplo  */
var regex = /abc++?/; //El segundo + no está repitiendo nada!!!

For your specific case, it happens because you are dynamically generating a regex from some text without escaping the special characters. When the user enters something like this.name="Genera [error???]", you are trying to generate a regex with "error???", which is an invalid expression.

To generate a literal regex from a string, you have to escape it using this function

function escaparRegex(string) {
    return string.replace(/[\\^$.|?*+()[{]/g, '\\$&'); 
}

• More information at: Safe way to escape user input to be processed by regular expressions in JavaScript

Code

Let's forget about the problem of escaping the text, let's simplify.

We are going to use the regex /\[([^\]]*)\]/.

• \[- literal bracket.
• (... )- Capturing group. Generates a reference to the text it matched.
  Coincides with:
  • [^\]]*- A character, any except ']', repeated ( *) 0 or more times.
    That is, " matches all characters other than] ".
• \]- literal bracket.

In the replace() , instead of passing a string, we can pass an anonymous function that will be called to evaluate the regex replacement.

function entreCorchetes (texto) {
    var regex = /\[([^\]]*)\]/,
        resultado;
    
    resultado = texto.replace(regex, function(m, mostrar) {
        if (mostrar !== '') { //si tiene texto
            //Y acá llamarías a drawText
            console.log('Entre corchetes:', mostrar);
        }
        return ''; //reemplazamos por "" (eliminamos)
    });
    
    return resultado;
}



// EJEMPLO

var original = "Prueba [abc+++]";
console.log("Original:", original);

var final = entreCorchetes(original); //llamamos a la función (elimina el primer texto entre corchetes que encuentre)
console.log("Final:", final);

The anonymous function receives as parameters the string that the regex matched, and then a parameter for each capture made by each group.

In the regex /\[([^\]]*)\]/we use 1 set of parentheses, to capture the text that is inside the brackets. In other words, the function will receive mthe text with brackets as the first parameter ( ), and mostrarthe same text as the second parameter ( ), but without the brackets.

The result of the function is what will actually be used in the string replacement. That's why we always return ''(empty text), so that the brackets are removed from the original string. It's the same as doing, texto.replace( regex, '');, but evaluating the match in the function.

What if we try something simpler?

In these questions, I always ask myself if it is not convenient to simplify everything and use classic string management functions. Why start with regex scrambles and nested anonymous functions? Is it fashionable? Does it seem more "pro"? How many lines do we save?

The only thing you are looking for is:

1. Get the first occurrence of a text between brackets (print it without brackets).
2. Delete that occurrence of the string, also removing the brackets (print it).

Step by step, with comments in the code:

 
//Usemos un ejemplo
var name = 'Mariano] [clan][no eliminar]';
//Las variables para el resultado
var texto,
    mostrar = "";


//Busquemos el primer "["
var posInicial = name.indexOf('[');

if (posInicial >= 0) { //Encontramos un "["

    //Ahora buscamos la posición de un "]" DESDE la anterior
    var posFinal = name.indexOf(']', posInicial + 1);
    
    if (posFinal >= 0) { //Encontramos un "]"
    
        //Obtenemos el clan
        mostrar = name.substring(posInicial + 1, posFinal);
        
        //Obtenemos el texto sin los primeros corchetes
        // (del inicio hasta antes del que abre + despues del que cierra hasta el final)
        texto = name.substr(0, posInicial) + name.substr(posFinal + 1);
    
    } else { //No tiene ningún "]" luego del "["
        //Creo que acá no harías nada, no sé, fijate
        texto = name;
    }
    
} else { //No tiene ningún "["
    //Creo que acá no harías nada, no sé, fijate
    texto = name;
}


//Mostremos el resultado
console.log("Original:", name);
console.log("Posiciones:", posInicial, posFinal);
console.log("Final:", texto);
console.log("Clan:", mostrar);