Simulating Crashing Cars Introduction

I have some ASCII cars that have velocity and direction. Their velocity is represented by their number. If a car is &lt;&gt; then it has stopped. For example:

&lt;&gt;
1&gt;
2&gt;
3&gt;


After one second, I get

&lt;&gt;
 1&gt;
  2&gt;
   3&gt;


After two, I get

&lt;&gt;
  1&gt;
    2&gt;
      3&gt;


If two cars are too close, they crash.

1&gt; &lt;1
1&gt; &lt;2


After a second, this becomes

 ###
 ##


If two cars intersect, they become hashtags were they would be.

If one car is fast enough to 'hop' over the other, it does not result in a crash.

3&gt;&lt;1   2&gt;&lt;1   4&gt;&lt;&gt;


becomes

 &lt;13&gt;   ###     &lt;&gt;4&gt;


If a car goes left off-screen, it disappears (unless there's a crash). There is no way for a car to go right off-screen.

 &lt;11&gt;
&lt;1  1&gt;
1    1&gt;
      1&gt;


Challenge

Based on the given car physics, you must create a program that can time-step one second into the future. The input will be cars with spaces and a maximum velocity of 5 (matching regex (&lt;[1-5]|[1-5]&gt;|&lt;&gt;| )+). The simulation will happen on one line, however that line has no fixed size.

Test cases

&lt;&gt; 1&gt; 2&gt; 3&gt; 4&gt; 5&gt;
&lt;&gt;  1&gt;  2&gt;  3&gt;  4&gt;  5&gt;

1&gt;&lt;1   1&gt; &lt;1   1&gt;  &lt;1
 ##     ###     1&gt;&lt;1

2&gt;&lt;2   2&gt; &lt;2   2&gt;  &lt;2   2&gt;   &lt;2   2&gt;    &lt;2
&lt;22&gt;    ###      ##       ###       2&gt;&lt;2

&lt;22&gt;  &lt;1 3&gt;   &lt;2
    ###     ##

&lt;&gt;&lt;&gt;     1&gt;&lt;&gt;     2&gt;&lt;&gt;     3&gt;&lt;&gt;     4&gt;&lt;&gt;     5&gt;&lt;&gt;
&lt;&gt;&lt;&gt;      ###       ##       ###      &lt;&gt;4&gt;     &lt;&gt; 5&gt;

&lt;&gt;&lt;1 &lt;2 &lt;3 &lt;4 &lt;5
###&lt;2&lt;3&lt;4&lt;5


Scoring

This is code-golf, so code with the smallest number of bytes wins!
JavaScript (ES6), 140 bytes

s=&gt;[...s.replace(/\S./g,([a,b],i)=&gt;r[r[i+=+b?-b:~~a]=r[i]?C:a,++i]=r[i]?C:b,r=[],C='#')&amp;&amp;r].map((c,i)=&gt;c?r[i-1]==C|r[i+1]==C?C:c:' ').join``

Try it online!
Commented
s =&gt;                      // given the input string s
  [ ...s.replace(         // search in s ...
    /\S./g,               //   ... all substrings consisting of 2 non-whitespace characters
    ([a, b], i) =&gt;        //   let a be the 1st character, b the 2nd one and i the position
      r[                  //   update r[]:
        r[i +=            //     apply the car velocity to i:
          +b ? -b         //       if b is a digit, then move b cells backwards
                  : ~~a   //       else: use a to move forwards (or don't move at all)
        ] = r[i] ? C : a, //     if r[i] is set, overwrite it with '#'; otherwise, insert a
        ++i               //     increment i for the 2nd character
      ] = r[i] ? C : b,   //     if r[i] is set, overwrite it with '#'; otherwise, insert b
      r = [],             //   initialize r[] to an empty array
      C = '#'             //   define C as the 'crash' character
  ) &amp;&amp; r ]                // end of replace(); return a fully iterable copy of r[]
  .map((c, i) =&gt;          // for each entry c at position i in this array:
    c ?                   //   if c is defined:
      r[i - 1] == C |     //     if either the previous
      r[i + 1] == C ?     //     or the next cell is '#' (in the original array):
        C                 //       replace the current cell with '#'
      :                   //     else:
        c                 //       let c unchanged
    :                     //   else:
      ' '                 //     insert a space
  ).join``                // end of map(); join the result