How can I build a string by repeating it as many as the number before it?

I need code that converts a string into the following form:
'3[a]2[bc]'
to the following figure:
'aaabcbc'

I have created the following code:

function string_builder(expression) {
    let string = expression; //I put the text string into a variable called string.
    let splitString = string.replaceAll('[', ',').replaceAll(']', ',') .split(','); //Replace [and] with , then convert it to an array using that comma.
    let ArrStr = splitString.slice(0,-1); //Delete the last element in the array which is just an empty element. 

    let result = []; //Just empty array inside a variable called result.

    for(let i = 0; i < ArrStr.length; i+=2){ //this loop will take only the numbers by jumping two element every time.
        let num = ArrStr[i]; //variable for numbers.
        let str = ArrStr[i+1]; //variable for stings.
        for(let e = 1; e <= num; e++){ //this loop put every sting in the empty array that called result with the required number.
            result.push(str);
        }
    }

    let finalresult = result.toString().replaceAll(',', ''); //Convert the array (result) to a string and delete the comma between each element.
    return finalresult; //Returns the final result

}

But it does not work in the following cases:
'2[abc]3[cd]ef'
'3[a2[c]]'

I'm a beginner, and I've been trying for three days to solve this problem, and I haven't found any suitable idea, any help?

I want this result:

Input: '2[abc]3[cd]ef'
Output: 'abcabccdcdcdef'

Input: '3[a2[c]]'
Output: 'accaccacc'

Try this approach using the stack data structure to keep track of the nested patterns in the input string. Should work.

function decodeString(s) {
// Create an empty stack to keep track of characters
const stack = [];
// Iterate over each character in the input string
for (let i = 0; i < s.length; i++) {
// If the character is a closing bracket, we need to decode a nested pattern
if (s[i] === ']') {
// Create an empty string to store the decoded string inside the nested pattern
let str = '';
// Pop characters off the stack until we reach the corresponding opening bracket
while (stack[stack.length - 1] !== '[') {
// Concatenate the popped characters to the decoded string
str = stack.pop() + str;
}
// Pop the opening bracket off the stack
stack.pop();
// Create an empty string to store the repeat count
let count = '';
// Pop characters off the stack until we reach a digit
while (stack.length > 0 && !isNaN(stack[stack.length - 1])) {
// Concatenate the popped characters to the repeat count
count = stack.pop() + count;
}
// Convert the repeat count to an integer using parseInt
count = parseInt(count);
// Push the repeated decoded string back onto the stack
stack.push(str.repeat(count));
} else {
// If the character is not a closing bracket, push it onto the stack
stack.push(s[i]);
}
}
// Join the characters remaining on the stack to form the final decoded string
return stack.join('');
}
// Test the function with the input string "2[abc]3[cd]ef"
const input = "2[abc]3[cd]ef";
const output = decodeString(input); 
console.log(output)  //abcabccdcdcdef