[Question]
  [
The challenge is to follow (draw) the path:
* `^n` - up by n lines
* `vn` - down by n lines
* `>n` - right by n character positions
* `<n` - left by n characters positions
---
* `n` is an integer, greater than zero (i.e. you can't receive a command like `>-2`).
* There're no separators between the commands, the well-formed input looks like this: `>5v8<10^3`, no other form of input allowed.
* The number of commands is unlimited.
* No more characters are supposed to creep into the input.
Examples.
1. Input is an empty string, output:
```
*
```
2. Input is either `>3` or `<3`: note that this doesn't make any difference to the output:
```
****
```
3. Similar for `^3` and `v3`:
```
*
*
*
*
```
4. Input: `>1v2`, output:
```
**
 *
 *
```
5. Input: `^4>3v2<1`, output:
```
****
*  *
* **
*
*
```
6. If you go back and use the same path, don't draw anything new. E.g. `>5<5`
```
******
```
7. ...though you don't draw anything new, you obviously change the position. Hence, if your input looks like this: `>4<2v3`, the output is:
```
*****
  *
  *
  *
```
8. This is a more complex example: 1) the path can cross itself 2) note that the last three steps of the last command shift the whole path to the right. Input: `v6>4^3<7`, output:
```
   *
   *
   *
********
   *   *
   *   *
   *****
```
9. [Input](https://codegolf.stackexchange.com/posts/comments/165676):
```
^2v2>3<3v3>4^5v5>3^5>4v2<4v3>4^3v3>3^5>4v2<4v3>7^5>4v2<4v3>9^3<2^2v2>4^2v2<2v3>8^5>2v4>2^4v5<3>6^5>5<5v2>5<5v2>5<4v1>8^3<1^2v2>1v2>2^3v3>2^2>1^2v2<1v3<3>11^3<2^2v2>4^2v2<2v3>5^5>5<5v2>5<5v2>5<4v1>7^5>4v2<4v3>4^3v3>3^5>4v2<3v1<1v2>3^1>1v1
```
Output:
```
*   *  *****  *****  *****  *   *     *** *  ******  *     *    *   *  ******  *****  *****
*   *  *   *  *   *  *   *  *   *     * * *  *       *  *  *    *   *  *       *   *  *   *
*****  *****  *****  *****  *****     * * *  ******  ** * **    *****  ******  *****  *****
*   *  *   *  *      *        *       * * *  *        * * *       *    *       *   *  **
*   *  *   *  *      *        *       * ***  ******   *****       *    ******  *   *  *  **
*******************************************************************************************
```
  
[Answer]
# JavaScript (ES6), 204 ~~211 210~~
**Edit 1** Bug fix - output '\*' for void input  
**Edit 2** Simpler decoding of direction to x and y diff
Here is my answer to [The treasure map](https://codegolf.stackexchange.com/a/54361/21348), revised to fulfill the specs.
```
F=m=>(m.replace(/\D(\d+)/g,(d,z)=>{for(;z--;r=[...r],r[x]=m,p[y]=r.join``)for(d<'>'?--x:d<'^'?++x:d<'v'?--y:++y,p=~x?~y?p:[y=0,...p]:p.map(r=>' '+r,x=0),r=p[y]||'';!r[x];)r+=' '},x=y=0,p=[m='*']),p.join`
`)
```
**Less golfed** and explained more or less
```
f=m=>(
  x=y=0, // starting position
  p=['*'], // output string array (initialized with minimum output)
  m.replace( /\D(\d+)/g, 
  (d,z) => // execute the following for each group direction/length. Length in z, direction in d[0]
  {
    while( z--)  // repeat for the len
    {
      // check d to change values of x and y
      // all the comparison are with > and <, not equal
      // so that they work with the whole d, not just d[0]
      d<'>'?--x:d<'^'?++x:d<'v'?--y:++y,
      // now if x or y are < 0 then p must be adjusted  
      p = ~x 
        ? ~y
          ? p // both x and y are >= 0, p is not changed
          : [y = 0, ...p] // y < 0, shift p by on adding a 0 element and set y to 0
        : p.map(r=> ' ' + r, x = 0); // x < 0, add a space to the left for each row in p and set x to 0
      r = p[y] || ''; // get current row in r
      for( ; !r[x]; ) // if the current row is empty or too short
        r += ' '; // ... add spaces up to position x
      // set character in x position
      r = [...r], // the shorter way is converting to array ...
      r[x] = '*', // setting the element
      p[y] = r.join`` // and the back to string using join
    }
  }),
  p.join`\n` // return output array as a newline separated string
}
```
**Test**
```
F=m=>(m.replace(/\D(\d+)/g,(d,z)=>{for(;z--;r=[...r],r[x]='*',p[y]=r.join``)for(d<'>'?--x:d<'^'?++x:d<'v'?--y:++y,p=~x?~y?p:[y=0,...p]:p.map(r=>' '+r,x=0),r=p[y]||'';!r[x];)r+=' '},x=y=0,p=['*']),p.join`
`)
// TEST
console.log = x => O.textContent += x + '\n';
console.log(F('')+'\n')
console.log(F('v6>4^3<7')+'\n')
console.log(F('^2v2>3<3v3>4^5v5>3^5>4v2<4v3>4^3v3>3^5>4v2<4v3>7^5>4v2<4v3>9^3<2^2v2>4^2v2<2v3>8^5>2v4>2^4v5<3>6^5>5<5v2>5<5v2>5<4v1>8^3<1^2v2>1v2>2^3v3>2^2>1^2v2<1v3<3>11^3<2^2v2>4^2v2<2v3>5^5>5<5v2>5<5v2>5<4v1>7^5>4v2<4v3>4^3v3>3^5>4v2<3v1<1v2>3^1>1v1'))
```
```
<pre id=O></pre>
```
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 71 bytes
```
1thj'.\d+'XX"@Z)XK6L)U:"K1)XK118=K94=-K62=K60=-hv]]YstY)X<1--lqg10*32+c
```
Uses [current release (6.0.0)](https://github.com/lmendo/MATL/releases/tag/6.0.0) of the language/compiler. Works in Matlab and in Octave.
*EDIT (June 21, 2016): due to changes in the language, the code requires a few modifications to run in current release (16.0.0). You can [try it online](http://matl.tryitonline.net/#code=MXRoaicuXGQrJ1hYIkBZOlhLNEwpVToiSzEpWEsxMTg9Szk0PS1LNjI9SzYwPS1oMiR2XV1Zc3RYOlg8MS0tbGxYUWcxMCozMitj&input=XjJ2Mj4zPDN2Mz40XjV2NT4zXjU-NHYyPDR2Mz40XjN2Mz4zXjU-NHYyPDR2Mz43XjU-NHYyPDR2Mz45XjM8Ml4ydjI-NF4ydjI8MnYzPjheNT4ydjQ-Ml40djU8Mz42XjU-NTw1djI-NTw1djI-NTw0djE-OF4zPDFeMnYyPjF2Mj4yXjN2Mz4yXjI-MV4ydjI8MXYzPDM-MTFeMzwyXjJ2Mj40XjJ2MjwydjM-NV41PjU8NXYyPjU8NXYyPjU8NHYxPjdeNT40djI8NHYzPjReM3YzPjNeNT40djI8M3YxPDF2Mj4zXjE-MXYx) including the needed modifications.*
### Examples
```
>> matl
 > 1thj'.\d+'XX"@Z)XK6L)U:"K1)XK118=K94=-K62=K60=-hv]]YstY)X<1--lqg10*32+c
 > 
> ^4>3v2<1
    ****
    *  *
    * **
    *   
    *  
>> matl
 > 1thj'.\d+'XX"@Z)XK6L)U:"K1)XK118=K94=-K62=K60=-hv]]YstY)X<1--lqg10*32+c
 > 
> ^2v2>3<3v3>4^5v5>3^5>4v2<4v3>4^3v3>3^5>4v2<4v3>7^5>4v2<4v3>9^3<2^2v2>4^2v2<2v3>8^5>2v4>2^4v5<3>6^5>5<5v2>5<5v2>5<4v1>8^3<1^2v2>1v2>2^3v3>2^2>1^2v2<1v3<3>11^3<2^2v2>4^2v2<2v3>5^5>5<5v2>5<5v2>5<4v1>7^5>4v2<4v3>4^3v3>3^5>4v2<3v1<1v2>3^1>1v1
  *   *  *****  *****  *****  *   *     *** *  ******  *     *    *   *  ******  *****  *****
  *   *  *   *  *   *  *   *  *   *     * * *  *       *  *  *    *   *  *       *   *  *   *
  *****  *****  *****  *****  *****     * * *  ******  ** * **    *****  ******  *****  *****
  *   *  *   *  *      *        *       * * *  *        * * *       *    *       *   *  **   
  *   *  *   *  *      *        *       * ***  ******   *****       *    ******  *   *  *  **
  ******************************************************************************************* 
```
### Explanation
The program has four main steps:
1. Read input string and split into its components.
2. Build a 2-column matrix where each row describes a unit displacement in the appropriate direction. For example, `[0 -1]` indicates one step to the left. The first row is the origin of the path, `[1 1]`
3. Compute the cumulative sum of that matrix along the first dimension . Now each row describes the coordinates of a `*`. Normalize to minumum value `1`
4. Create a new matrix that contains `1` at the coordinates indicated by the matrix from step 3, and `0` otherwise. This is then transformed into a char matrix.
Code:
```
1th                         % row vector [1 1]. Initiallize matrix of step 2
j                           % (step 1) read input string 
'.\d+'XX                    % split into components. Creates cell array of substrings
"                           % (step 2) for each component
   @Z)XK                    % unbox to obtain substring and copy
   6L)U:                    % obtain number and build vector of that size
   "                        % repeat as many times as that number
      K1)                   % paste substring. Get first character: '^', 'v', '>', '<'
      XK118=K94=-           % vertical component of unit displacement: -1, 0 or 1
      K62=K60=-             % horizontal component of unit displacement: -1, 0 or 1
      h                     % concatenate horizontally
      v                     % append vertically to existing matrix
   ]                        % end
]                           % end
Ys                          % (step 3) cumulative sum along first dimension
tY)X<1--                    % normalize to minimum value 1
lqg                         % (step 4) build matrix with 0/1
10*32+c                     % replace 0 by space and 1 by asterisk
```
[Answer]
# Perl, 174 bytes
```
@M=(['*']);pop=~s/(.)(\d+)/($z=ord$1)&64?($y+=$z&8?-1:1)<0&&unshift@M,[$y++]:($x+=($z&2)-1)<0?@M=map{[$x=0,@$_]}@M:0,$M[$y][$x]='*'for1..$2/gre;print map{map{$_||$"}@$_,$/}@M
```
Expects input as commandline argument. *Be sure to quote the argument!*  
Example: `perl 177.pl "<1^2>3v4<5^6>7v8<9^10>11"`
**Somewhat readable:**
```
@M=(['*']);                                 # output origin/starting position
pop=~                                       # apply regex to cmdline arg
s!(.)(\d+)!                                 # match $1=direction, $2=count
    ($z=ord$1)                              # get ASCII code for char
    &64                                     # 'v^' have this bit set, '<>' don't
        ?                                   # adjust y:
            ($y += $z&8 ? -1 : 1)           # '^' has bit set, 'v' doesn't
            < 0 &&                          # negative y?
            unshift @M, [$y++]              # prepend row; abuse [] for $y++ saving 3 bytes
        :                                   # adjust x:
            ($x+= ($z&2) -1 )               # '>' has bit set: 2-1=1, '<' hasn't: 0-1=-1
            < 0 ?                           # negative x?
                @M = map{ [$x=0,@$_] } @M   # prepend column, reset x
                :0                          # '?:0' shorter than '&&()'
        ,                                   # oh, and also:
        $M[$y][$x]='*'                      # output current position.
    for 1..$2                               # iterate count
!grex;                                      
print map{ map{$_||$"} @$_, $/ } @M         # iterate rows/cols, print '*' or space
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal/tree/version-2) `?`, 197 [bitsv2](https://github.com/Vyxal/Vyncode/blob/main/README.md), 24.625 bytes
```
kdFf`^>v<`kd‚àöƒø?f‚åä0‚Ç¨·∏¢·πÖ‚åä‚Ä∫√ó?[√∏^
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2&c=1#WyI9PyIsIiIsImtkRmZgXj52PGBrZOKImsS/P2bijIow4oKs4bii4bmF4oyK4oC6w5c/W8O4XiIsIiIsIl4ydjI+MzwzdjM+NF41djU+M141PjR2Mjw0djM+NF4zdjM+M141PjR2Mjw0djM+N141PjR2Mjw0djM+OV4zPDJeMnYyPjReMnYyPDJ2Mz44XjU+MnY0PjJeNHY1PDM+Nl41PjU8NXYyPjU8NXYyPjU8NHYxPjheMzwxXjJ2Mj4xdjI+Ml4zdjM+Ml4yPjFeMnYyPDF2MzwzPjExXjM8Ml4ydjI+NF4ydjI8MnYzPjVeNT41PDV2Mj41PDV2Mj41PDR2MT43XjU+NHYyPDR2Mz40XjN2Mz4zXjU+NHYyPDN2MTwxdjI+M14xPjF2MSJd)
Bitstring:
```
10000000000001110010111101000000110111011010110000000000100001111110101111001000101011110011001101001000011000101100010101000011110111000110001011100110000011001111111111010010100100111110001000000
```
```
kdFf`^>v<`kd‚àöƒø?f‚åä0‚Ç¨·∏¢·πÖ‚åä‚Ä∫√ó?[√∏^¬≠‚Å°‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å§‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å¢‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å£‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å§‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å°‚Å™‚Äè‚Å†‚Å™‚Å™‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å§‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å¢‚Å™‚Äè‚Å†‚Å™‚Å™‚Å†‚Å™‚Å™‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å°‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å§‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å°‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å¢‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å§‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å£‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å¢‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å¢‚Å¢‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å§‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å¢‚Å£‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å£‚Å°‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å¢‚Å§‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å£‚Å¢‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å£‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å£‚Å¢‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å£‚Å£‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å£‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å£‚Å§‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å£‚Å§‚Äã‚Äé‚Äè‚Äã‚Å¢‚Å†‚Å°‚Äå¬≠
kdFf                          # ‚Äé‚Å°remove all digits from input and flatten
                              # ‚Äé‚Å°to give list of directions
    `^>v<`                    # ‚Äé‚Å¢arrows in canvas directions
          kd‚àö                 # ‚Äé‚Å£even digits (02468)
             ƒø                # ‚Äé‚Å§transliterate directions to corresponding canvas directional number (ignores the 8) [1]
              ?f‚åä             # ‚Äé‚Å¢‚Å°flatten the input and get the numbers
                 0‚Ç¨·∏¢          # ‚Äé‚Å¢‚Å¢split on 0 and remove the first element (always an empty list due to input format)
                    ·πÖ‚åä        # ‚Äé‚Å¢‚Å£join sublists by nothing and convert to number(deals with multi digit numbers)
                      ‚Ä∫       # ‚Äé‚Å¢‚Å§increment (no idea why i need this but the entire program breaks without it) [2]
                       √ó      # ‚Äé‚Å£‚Å°literal "*"
                        ?[    # ‚Äé‚Å£‚Å¢if the input is true
                          √∏^  # ‚Äé‚Å£‚Å£draw on the canvas using directions defined in [1] lengths defined in [2] and printing the text as "*"
# ‚Äé‚Å£‚Å§otherwise, implicitly print "*" 
üíé
```
Created with the help of [Luminespire](https://vyxal.github.io/Luminespire).
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 27 bytes
```
">^v<"≈æC√çS1√∫‚Ä°#¬¶Œµƒá)>}√∏`'*s<Œõ
```
[Try it online!](https://tio.run/##dY4xCgJBDEXvooVol2TGVQhpPIJ9UMHCymIhnWBn5QmsbLyBIBYWrrZ7CC8yZgeELdYiIXlJ/s@2XK4265R6osa992NWHedQ3T/7c/95qa@vw1B21W0xGJVcn1JSNBRiMpKg0aKQRgmGHDJpeJsUrXqqxJjvQ5MZnU18jhYENVhkkrH3kaPv/HIw8C1iyJfggdnFlSQzBvN/BKBDPnbKFX9fJgNuLEjBreAL "05AB1E ‚Äì Try It Online") (2020 is close enough so why not)
]