Coincidencia para {[^}]+}

Coincidencia de código simple en el controlador de excepciones, siempre que no haya llaves anidadas:

 catch *\((\w+)\) *{[^}]+(\1)(\.stack)[^}]+}

La expresión regular anterior coincide con estos ejemplos
(capturando grupos por mi bien, elimínelos si no es necesario):

 try { print(new Function (astatement)()) } catch (e) { print(e.stack) } try { print(new Function (bstatement)()) } catch (exception) { print(exception.stack) }

Puedes probarlo aquí:
https://regex101.com/r/PuytDJ/2

Algunas técnicas utilizadas aquí

 \w+

En lugar de solo . Supongo que puede dar cualquier nombre a la instancia de excepción, por lo que tal vez sea más seguro usar \w+ aquí.

 {[^}]+

Esto busca una llave de apertura y atrapa todas las llaves que no cierran hasta la siguiente expresión. Funciona solo si no tiene llaves anidadas en su controlador de excepciones.

 (\1)

Aquí hago referencia al nombre de la variable de la excepción que se encuentra en el grupo de captura 1.

 (\.stack)

Aquí está encontrando .stack literalmente

 [^}]+}

Continúo analizando todos los caracteres que no son llaves y, finalmente, el corchete de cierre.

Descargo de responsabilidad

⚠ Dicho esto, las expresiones regulares no pueden analizar muy bien los elementos anidados, o solo hasta cierto punto con expresiones cada vez más complejas.
Por lo tanto, los bloques de código, las etiquetas HTML/XML, los objetos JSON, etc. se analizan mejor, no se buscan en el texto.

Usando un analizador de Javascript, puede atravesar el árbol de sintaxis (AST) y encontrar cada ".pila" dentro de un bloque de captura.

Por ejemplo, use slimit en Python:

 from slimit import ast from slimit.parser import Parser from slimit.visitors import nodevisitor data = """ try { print(new Function(astatement)()) } catch (e) { print(e.stack) } """ parser = Parser() tree = parser.parse(data) def nextCatch(tree): for node in nodevisitor.visit(tree): if isinstance(node, ast.Catch): return node def nextIdentifierStack(tree): for node in nodevisitor.visit(tree): if isinstance(node, ast.Identifier) and node.value == 'stack': return node def printChildren(node): for i, ch in enumerate(node.children()): print(f"{i:2}: {ch.to_ecma()}") catch = nextCatch(tree) printChildren(catch) stack = nextIdentifierStack(catch) print(stack.to_ecma())

Impresiones: el bloque catch con 2 hijos y el identificador de stack encontrado

 0: e 1: { print(e.stack); } stack

Véase también analizador de JavaScript en Python