Trench Map

For each pixel in the input image
  Concatenate the values of all nine pixels that form a grid with the current pixel at its center - moving horizontally in order from top-left to bottom-right
  Coerce each value to its boolean equivalent: `0` for `.` and `1` for `#`
  Parse that 9-digit integer as a binary number to generate a base-10 integer between 0 and 512
  Look-up the character at the base-10 integer's index in the provided algorithm
  Re-assign the input pixel's value to the searched-for value

let arr1 = [[0,1,0],[1,0,1],[0,1,0]];
let arr2 = arr1; // Nope. Just a reference.
let arr2 = arr1.slice(); // Not quite. Too shallow.
let arr2 = Array.from(arr1); // Same as previous. Too shallow.
let arr2 = arr1.map(nestedArray => nestedArray.slice()); // Yup!

(-1,-1)(-1, 0)(-1, 1)
( 0,-1)( 0, 0)( 0, 1)
( 1,-1)( 1, 0)( 1, 1)

Once, at the start of the program
  Store all nine coordinates in a list
At the start of each enhancement
  Pad the input image area by an extra row and column on each side
Loop through each index, starting from the 2nd row and column and ending at the 2nd to last row and column
  Update each pixel's value to the one resulting from this calculation:
    Loop through each position-relative coordinate in the stored reference list
      Look-up the value from the cloned image in the position corresponding to the row whose index equals the sum of: the pixel's row index and the value in the first position of the current iteration's coordinate from the stored reference list...and the column who index equals a similar sum, but using the value in the second position
    Concatenate those nine values into one string
    Parse that string as a binary number to generate a base-10 integer between 0 and 512
    Look-up and return the character at the base-10 integer's index in the provided algorithm

...    ...    ###
... -> .#. -> ###
...    ...    ###

Store the number of times we want to enhance the image
  Increment that number by one, for reasons described below
Store the number of enhancements complete, starting at 0

Sub-routine:
Prepare the image for enhancement by applying an appropriately-sized frame of dark pixels
  Re-assign to the input image a mutated copy where:
    X new rows - where x is the current number of times remaining - of equal columns are added before all current rows and after
      Each new row is filled with items whose value is:
        The value stored in the variable storing the number of completed enhancements, subtracted from 1: starts at 0, then `1 - 0 = 1`, then `1 - 1 = 0`, etc.
        If it is 0, use `.`
        Else - it is 1 - use `#`
    X new columns - where x is the current number of times remaining - are added to each row - including originals and new ones
      Same as above: each new column is assigned the appropriate value `.` or `#`

Core loop:
While the image still needs to enhance (times > 1):
  Clone the input image
  Enhance the input image by referencing each pixel in the cloned image
  Update the enhancements completed tracker to equal 1 minus the current value, in essence toggling between `0` and `1`
  Slice off the no-longer-relevant framing pixel rows and columns
    Remove rows and columns from the enhanced image:
      Starting from the row or column equal to `times` - 1`
      Ending at the row of column equal to `its length - (times - 1)`
  Generate new framing rows and pixels
  Decrement times by 1