Las cajas ASCII se ven así:

++    +---+    +------+    +---+    +---+
++    |   |    |      |    |   |    |   |
      |   |    |      |    |   |    |   |
+-+   |   |    |      |    |   |    |   |
+-+   |   |    |      |    |   |    +---+
      +---+    |      |    |   |
+--+           |      |    |   |    ++
|  |           |      |    |   |    ||
|  |           +------+    |   |    ||
+--+                       |   |    ||
                           +---+    ||
                                    ||
                  +-----+           ||
+------------+    |     |           ++
|            |    |     |
|            |    |     |
+------------+    +-----+

Aquí hay algunos ejemplos de los mismos cuadros ASCII, implosionados:

++    +- -+    +-    -+    +- -+    +- -+
++    | - |    | -  - |    | - |    | - |
       | |      | -- |      | |      | |
+-+    | |       |  |        "      | - |
+-+   | - |       ||        | |     +- -+
      +- -+      |  |      |   |
+--+            | -- |      | |     ++
|  |           | -  - |      "      ||
|  |           +-    -+     | |     ||
+--+                       | - |   |  |
                           +- -+   |  |
      --                            ||
     -  -         +-   -+           ||
+-  -    -  -+    | - - |           ++
| --      -- |     | = |
| --      -- |    | - - |
+-  -    -  -+    +-   -+
     -  -
      --

Aquí hay un enlace a todos estos cuadros de casos de prueba en un formato más fácil de copiar. El orden es todas las entradas seguidas de todas las salidas en el mismo orden.

Su objetivo es tomar un cuadro ASCII como entrada y devolver el cuadro implosionado. Las reglas de implosión son:

1. "+" nunca cambia; tampoco "-" o "|" directamente adyacente a "+"
2. A partir de las esquinas, el "-" y "|" muévete hacia adentro un espacio más que el mismo personaje más cerca de la esquina. Si un "-" y "|" alguna vez se movería al mismo lugar, ninguno se movería.
3. Si un "-" y "-" se mueven al mismo lugar, coloque un "=" en ese lugar. Si un "|" y "|" mover al mismo lugar, poner un "en ese lugar. Estos cuentan como dos de sus respectivos personajes en el mismo lugar moviéndose en direcciones opuestas.
4. Dos "-" o dos "|" pueden pasar uno al lado del otro, como se ve en el ejemplo inferior izquierdo.
5. Si la caja es lo suficientemente delgada, comenzará a expandirse hacia afuera de la misma manera, siempre alejándose del lado en el que comenzó.
6. El resultado debe ser simétrico a través de la línea central en las direcciones x e y (ignorando las nuevas líneas); esto incluye espacios, por lo que el resultado puede necesitar ser rellenado con espacios para satisfacer eso.

Detalles de la regla:

1. Este es el código de golf, por lo que gana el programa más corto en bytes.
2. Se aplican lagunas estándar.
3. Puede suponer que cada línea termina en un carácter de nueva línea.
4. Los únicos caracteres en la cadena de entrada serán "+", "-", "|", "" y "\ n" (nueva línea), y su cadena de salida debe seguir las mismas reglas, con la adición de "=" y "como posibles personajes.
5. Opcionalmente, puede tener una nueva línea final al final de la última línea.
6. El cuadro ASCII más pequeño que necesita manejar es el ejemplo superior izquierdo. Cada caja ASCII tendrá exactamente 4 "+" s, exactamente en sus esquinas.
7. Deberá manejar cajas de tamaño m x npara cualquier número entero m,ntal que 2<=m,n<256(el mayor tamaño de cadena posible 255*(255+1))
8. Puede suponer que siempre obtendrá un único cuadro ASCII válido como entrada.

Python 2 , 591 555 545 527 525 496 436 351 334 333 303 bytes

s=input()
w=len(s[0])
h=len(s)
V=max(0,w/2-h)
H=max(0,h/2-w)
p=[[' ']*w]*V
q=[' ']*H
s=[q+k+q for k in p+s+p]
d,c=' -=',' |"'
exec"c,d,V,H,w,h=d,c,H,V,h,w;s=map(list,zip(*s))[::-1]\nfor j in range(h-4):q=s[V+j+2];q[H]=c[q[H]==c[2]];r=H+min(j+1,h-4-j);q[r]=c[1+(q[r]>' ')]\n"*4
for x in s:print''.join(x)

Pruébalo en línea!

EDITAR : Mi antiguo método primero implosionó la parte superior e inferior, y luego la izquierda y la derecha. En cambio, podemos implosionar la parte superior, rotar 90 grados y hacerlo 4 veces. Además, estaba usando el código fácil de usar, este requiere que la entrada esté en la forma [['+', '-', '-', '-', '-', '-', '+'], ['|', ' ', ' ', ' ', ' ', ' ', '|'], ['|', ' ', ' ', ' ', ' ', ' ', '|'], ['|', ' ', ' ', ' ', ' ', ' ', '|'], ['+', '-', '-', '-', '-', '-', '+']]que es fea pero más corta para el programa: P (Gracias a Phoenix por atrapar eso)

Créditos a Leaky Nun por el código de encabezado en el enlace TIO utilizado para convertir entradas legibles por humanos en entradas legibles por computadora.

-85 bytes gracias a Leaky Nun!
-17 bytes cambiando de implosión superior a implosión izquierda, lo que permite almacenar toda la fila en una variable y modificarla. ¡Gracias a Leaky Nun por la sugerencia!
-1 byte cambiando las cosas para eliminar un espacio.
-30 bytes gracias a Leaky Nun!

C (clang) , 693 bytes

Nuevas líneas agregadas para facilitar la lectura. Los dos primeros son obligatorios pero el resto no.

#define P B[i][l]
#define m malloc(8)
I(B,h,V,S,J,Z,i,j,l,n,H,W,c,C,a,z,_,L,G,u,N,M)char**B,**Z;char*L,*G,*u;{
V=strlen(B[0]);
S=J=0;
Z=m;
for(i=0,j=h-1;i<h/2+h%2;i++,j--){
for(l=0,n=V-1;l<V/2+V%2;l++,n--){
if(P!=43&&((B[i][l-1]!=43&&i<1)||(B[i-1][l]!=43&&l<1))){
H=P==45;
W=P=='|';
P=B[j][l]=B[i][n]=B[j][n]=32;
if(H){
c=(N=i+l-1)==(M=j-l+1)?61:45;
if(M<0)L=m,sprintf(L,"%*s",V,""),L[l]=L[n]=c,Z[J]=L,J++;
else B[N][l]=B[N][n]=B[M][l]=B[M][n]=c;
}
if(W){
c=(N=l+i-1)==(M=n-i+1)?34:'|';
if(M<0)G=m,sprintf(G,"|%*s%s%*s|",i-n-2,"",B[i],i-n-2,""),B[i]=B[j]=G,S++;
else B[i][N]=B[j][N]=B[i][M]=B[j][M]=c;
}
}
}
}
for(a=-J+1;a<=h+J;u=a<1?Z[-a]:a<=h?B[a-1]:Z[a-h-1],C=S+1-strlen(u)/2,printf("%*s%s\n",C>0?C:0,"",u),a++);
}

Gracias por el gran reto! Fue bastante complicado, pero todavía me divertí mucho.

Esto toma la entrada como argumentos de línea de comandos y salidas a STDOUT una cadena de varias líneas del cuadro implosionado. Como siempre, los consejos de golf son muy apreciados.

Pruébalo en línea!