Count Like a Babylonian Challenge

Given an ASCII representation of a Babylonian number as input, output the number in Western Arabic numerals.

Babylonian Numeral System

How did the Babylonians count? Interestingly, they used a Base 60 system with an element of a Base 10 system. Let's first consider the unit column of the system:

The Babylonians had only three symbols: T (or, if you can render it: ) which represented 1, and &lt; (or, if you can render it: ) which represented 10, and \ (or, if you render it: ) which represented zero.

Note: Technically, \ (or ) isn't zero (because the Babylonians did not have a notion of 'zero'). 'Zero' was invented later, so \ was a placeholder symbol added later to prevent ambiguity. However, for the purposes of this challenge, it's enough to consider \ as zero

So, in each column you just add up the value of the symbols, e.g.:

&lt;&lt;&lt; = 30
&lt;&lt;&lt;&lt;TTTTTT = 46
TTTTTTTTT = 9
\ = 0


There will never be more than five &lt; or more than nine T in each column. \ will always appear alone in the column.

Now, we need to extend this to adding more columns. This works exactly the same as any other base sixty, where you multiply the value of the rightmost column by \$60^0\$, the one to the left by \$60^1\$, the one to the left by \$60^2\$ and so on. You then add up the value of each to get the value of the number.

Columns will be separated by spaces to prevent ambiguity.

Some examples:

&lt;&lt; &lt;TT = 20*60 + 12*1 = 1212
&lt;&lt;&lt;TT \ TTTT = 32*60^2 + 0*60 + 4*1 = 115204


Rules


You are free to accept either ASCII input (T&lt;\) or Unicode input ()
The inputted number will always be under \$10^7\$
The &lt;s will always be to the left of the Ts in each column
\ will always appear alone in a column


Winning

Shortest code in bytes wins.
JavaScript (ES6), 44 bytes

Takes input as an array of ASCII characters.



a=&gt;a.map(c=&gt;k+=c&lt;1?k*59:c&lt;'?'?10:c&lt;{},k=0)|k


Try it online!

How?

The Babylonian Numeral System can be seen as a 4-instruction language working with a single register -- let's call it the accumulator.

Starting with \$k=0\$, each character \$c\$ in the input array \$a\$ modifies the accumulator \$k\$ as follows:


space: multiply \$k\$ by \$60\$ (implemented as: add \$59k\$ to \$k\$)
&lt;: add \$10\$ to \$k\$
T: increment \$k\$
\: do nothing; this is the NOP instruction of this language (implemented as: add \$0\$ to \$k\$)