tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

iso2022jp-decoder.js (6941B)


      1 function dec2char(n) {
      2    // converts a decimal number to a Unicode character
      3    // n: the dec codepoint value to be converted
      4    if (n <= 0xffff) {
      5        out = String.fromCharCode(n);
      6    } else if (n <= 0x10ffff) {
      7        n -= 0x10000;
      8        out =
      9            String.fromCharCode(0xd800 | (n >> 10)) +
     10            String.fromCharCode(0xdc00 | (n & 0x3ff));
     11    } else out = "dec2char error: Code point out of range: " + n;
     12    return out;
     13 }
     14 
     15 function getIndexPtr(cp, index) {
     16    for (p = 0; p < index.length; p++) {
     17        if (index[p] == cp) {
     18            return p;
     19        }
     20    }
     21    return null;
     22 }
     23 
     24 function iso2022jpDecoder(stream) {
     25    stream = stream.replace(/%/g, " ");
     26    stream = stream.replace(/[\s]+/g, " ").trim();
     27    var bytes = stream.split(" ");
     28    for (var i = 0; i < bytes.length; i++) bytes[i] = parseInt(bytes[i], 16);
     29    var endofstream = 2000000;
     30    //bytes.push(endofstream)
     31    var out = "";
     32    var decState = "ascii";
     33    var outState = "ascii";
     34    var isoLead = 0x00;
     35    var outFlag = false;
     36    var cp, ptr, lead;
     37 
     38    var finished = false;
     39    while (!finished) {
     40        if (bytes.length == 0) byte = endofstream;
     41        else var byte = bytes.shift();
     42        //byte = bytes.shift()
     43 
     44        switch (decState) {
     45            case "ascii":
     46                if (byte == 0x1b) {
     47                    decState = "escStart";
     48                    continue;
     49                } else if (
     50                    byte >= 0x00 &&
     51                    byte <= 0x7f &&
     52                    byte !== 0x0e &&
     53                    byte !== 0x0f &&
     54                    byte !== 0x1b
     55                ) {
     56                    outFlag = false;
     57                    out += dec2char(byte);
     58                    continue;
     59                } else if (byte == endofstream) {
     60                    finished = true;
     61                    continue;
     62                } else {
     63                    outFlag = false;
     64                    out += "�";
     65                    continue;
     66                }
     67                break;
     68            case "roman":
     69                if (byte == 0x1b) {
     70                    decState = "escStart";
     71                    continue;
     72                } else if (byte == 0x5c) {
     73                    outFlag = false;
     74                    out += dec2char(0xa5);
     75                    continue;
     76                } else if (byte == 0x7e) {
     77                    outFlag = false;
     78                    out += dec2char(0x203e);
     79                    continue;
     80                } else if (
     81                    byte >= 0x00 &&
     82                    byte <= 0x7f &&
     83                    byte !== 0x0e &&
     84                    byte !== 0x0f &&
     85                    byte !== 0x1b &&
     86                    byte !== 0x5c &&
     87                    byte !== 0x7e
     88                ) {
     89                    outFlag = false;
     90                    out += dec2char(byte);
     91                    continue;
     92                } else if (byte == endofstream) {
     93                    finished = true;
     94                    continue;
     95                } else {
     96                    outFlag = false;
     97                    out += "�";
     98                    continue;
     99                }
    100                break;
    101            case "katakana":
    102                if (byte == 0x1b) {
    103                    decState = "escStart";
    104                    continue;
    105                } else if (byte >= 0x21 && byte <= 0x5f) {
    106                    outFlag = false;
    107                    out += dec2char(0xff61 + byte - 0x21);
    108                    continue;
    109                } else if (byte == endofstream) {
    110                    finished = true;
    111                    continue;
    112                } else {
    113                    outFlag = false;
    114                    out += "�";
    115                    continue;
    116                }
    117                break;
    118            case "leadbyte":
    119                if (byte == 0x1b) {
    120                    decState = "escStart";
    121                    continue;
    122                } else if (byte >= 0x21 && byte <= 0x7e) {
    123                    outFlag = false;
    124                    isoLead = byte;
    125                    decState = "trailbyte";
    126                    continue;
    127                } else if (byte == endofstream) {
    128                    finished = true;
    129                    continue;
    130                } else {
    131                    outFlag = false;
    132                    out += "�";
    133                    continue;
    134                }
    135                break;
    136            case "trailbyte":
    137                if (byte == 0x1b) {
    138                    decState = "escStart";
    139                    out += "�";
    140                    continue;
    141                } else if (byte >= 0x21 && byte <= 0x7e) {
    142                    decState = "leadbyte";
    143                    ptr = (isoLead - 0x21) * 94 + byte - 0x21;
    144                    cp = jis0208[ptr];
    145                    if (cp == null) {
    146                        out += "�";
    147                        continue;
    148                    }
    149                    out += dec2char(cp);
    150                    continue;
    151                } else if (byte == endofstream) {
    152                    decState = "leadbyte";
    153                    bytes.unshift(byte);
    154                    out += "�";
    155                    continue;
    156                } else {
    157                    decState = "leadbyte";
    158                    out += "�";
    159                    continue;
    160                }
    161                break;
    162            case "escStart":
    163                if (byte == 0x24 || byte == 0x28) {
    164                    isoLead = byte;
    165                    decState = "escape";
    166                    continue;
    167                } else {
    168                    bytes.unshift(byte);
    169                    outFlag = false;
    170                    decState = outState;
    171                    out += "�";
    172                    continue;
    173                }
    174                break;
    175            case "escape":
    176                lead = isoLead;
    177                isoLead = 0x00;
    178                var state = null;
    179                if (lead == 0x28 && byte == 0x42) state = "ascii";
    180                if (lead == 0x28 && byte == 0x4a) state = "roman";
    181                if (lead == 0x28 && byte == 0x49) state = "katakana";
    182                if (lead == 0x24 && (byte == 0x40 || byte == 0x42))
    183                    state = "leadbyte";
    184                if (state != null) {
    185                    decState = state;
    186                    outState = state;
    187                    var outputflag = false;
    188                    outputflag = outFlag;
    189                    outFlag = true;
    190                    if (outputflag == false) continue;
    191                    else {
    192                        out += "�";
    193                        continue;
    194                    }
    195                }
    196                // Prepend the sequence (lead, byte) to the stream
    197                bytes.unshift(lead, byte);
    198                outFlag = false;
    199                decState = outState;
    200                out += "�";
    201                continue;
    202                break;
    203        }
    204    }
    205    return out;
    206 }