Encode/decode number pairs to letters
First a few suggestions to your design.
You are effectively trying to represent list of small numbers as String, with no actual meaning (at least that's how I understood it).
I'd consider:


Represent it for what it is - list of small numbers could be represented as byte array. That seems a lot more natural and convenient.
Use some simpler mapping, if it doesn't matter what kind of character is the result. If numbers really are in range between 0 and 32 and not much higher, I'd go for mapping function, that for example adds 65 (and substracts 65 in reverse). That mapping function is really simple and you don't need any kind of map. Your code would be reduced only to initial tokenization basically. 00 becomes A, 30 becomes _ according to their ASCII codes (+65).


In case you wanna keep your String representation, here are my points to your code:

getValueMap


Names getValueMap name and lettersFirst don't really say what much about what do they do. 
There's no point to recalculate reverse map everytime. Flag parameters with this kind of if are typical code smell and bad practice. 
I suggest creating 2 module variables codesToCharacters (original map) and charactersToCodes (once pre-calculated) instead. 


decode


I'd love if this function was just mapping encoded data to decoded data based on mapping function. 
Not sure, why is there that if. I think you are trying to check, if current character is letter or not and if so, map it, otherwise use the character. That took me a while to understand. If there was really need, I would extract that to function with propper name (like isLetter) to increase readability.
Anyway, why even doing that? Why not instead look into the map and if map contains key, use map value, otherwise use original character.


Function would look something like (pseudocode, not tested):

function decode(encoded) {

    return encoded.split("").map(
        c =&gt; {
            charactersToCodes.hasKey(c) ? charactersToCodes[c] : c
        }).join()

}


encode would be on same principle, only difference is, that you need to tokenize it correctly first and then map :)