// ==========================================================================
// JavaScript Tool for URL Encoding/Decoding
// Copyright (C) 2006 Netzreport (netzreport.googlepages.com)
//
// Website: http://netzreport.googlepages.com/online_tool_for_url_en_decoding.html
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
//
// The GNU General Public License is also available from:
// http://www.gnu.org/copyleft/gpl.html
//
// A local copy of the GNU General Public License is available here:
// http://netzreport.googlepages.com/gpl.txt
// ==========================================================================
//
// --------------------------------------------------------------------------
// 2006-12-18: Changed character encoding. Now, one can choose between URL
//             encoding/decoding strings that are character encoded as ASCII
//             or UTF-8.
// 2006-11-19: First release
// --------------------------------------------------------------------------

// According to RFC 3986, only characters from a set of reserved and a set
// of unreserved characters are allowed in a URL:
var unreserved = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_.~";
var reserved = "!*'();:@&=+$,/?%#[]";
var allowed = unreserved + reserved;
var hexchars = "0123456789ABCDEFabcdef";

// --------------------------------- Encoding -------------------------------

// This function returns a percent sign followed by two hexadecimal digits.
// Input is a decimal value not greater than 255.
function gethex(decimal) {return "%" + hexchars.charAt(decimal >> 4) + hexchars.charAt(decimal & 0xF);}

function encode(data,charset) {

  // Some variables:
  var decoded = data;
  var encoded = "";
 

  // ---------------- If ASCII character encoding was chosen: ----------------

  if (charset == "ascii") { 

    // Remember non-ASCII characters, which will not be encoded:
    var notascii = "";

    for (var i = 0; i < decoded.length; i++ ) {
      var ch = decoded.charAt(i);
      // Check if character is an unreserved character:
      if (unreserved.indexOf(ch) != -1) {
        encoded = encoded + ch;
      } else {
        // If position in the Unicode table is smaller than 128, then we have
        // an ASCII character:
        var charcode = decoded.charCodeAt(i);
        if (charcode < 128) {
          encoded = encoded + gethex(charcode);
        } else {
          encoded = encoded + ch;
          notascii = notascii + ch + " ";
        }
      }
    }

    // Write result:
    data = encoded;

    // Display warning message if necessary:
    if (notascii != "") alert("Warning: Non-ASCII characters in decoded text!\n\nThus, these characters have not been encoded:\n" + notascii);
  }

  // ---------------- If UTF-8 character encoding was chosen: ----------------

  if (charset == "utf8") {
    for (var i = 0; i < decoded.length; i++ ) {
      var ch = decoded.charAt(i);
      // Check if character is an unreserved character:
      if (unreserved.indexOf(ch) != -1) {
        encoded = encoded + ch;
      } else {

        // The position in the Unicode table tells us how many bytes are needed.
        // Note that if we talk about first, second, etc. in the following, we are
        // counting from left to right:
        //
        //   Position in   |  Bytes needed   | Binary representation
        //  Unicode table  |   for UTF-8     |       of UTF-8
        // ----------------------------------------------------------
        //     0 -     127 |    1 byte       | 0XXX.XXXX
        //   128 -    2047 |    2 bytes      | 110X.XXXX 10XX.XXXX
        //  2048 -   65535 |    3 bytes      | 1110.XXXX 10XX.XXXX 10XX.XXXX
        // 65536 - 2097151 |    4 bytes      | 1111.0XXX 10XX.XXXX 10XX.XXXX 10XX.XXXX

        var charcode = decoded.charCodeAt(i);

        // Position 0 - 127 is equal to percent-encoding with an ASCII character encoding:
        if (charcode < 128) {
          encoded = encoded + gethex(charcode);
        }

        // Position 128 - 2047: two bytes for UTF-8 character encoding.
        if (charcode > 127 && charcode < 2048) {
          // First UTF byte: Mask the first five bits of charcode with binary 110X.XXXX:
          encoded = encoded + gethex((charcode >> 6) | 0xC0);
          // Second UTF byte: Get last six bits of charcode and mask them with binary 10XX.XXXX:
          encoded = encoded + gethex((charcode & 0x3F) | 0x80);
        }

        // Position 2048 - 65535: three bytes for UTF-8 character encoding.
        if (charcode > 2047 && charcode < 65536) {
          // First UTF byte: Mask the first four bits of charcode with binary 1110.XXXX:
          encoded = encoded + gethex((charcode >> 12) | 0xE0);
          // Second UTF byte: Get the next six bits of charcode and mask them binary 10XX.XXXX:
          encoded = encoded + gethex(((charcode >> 6) & 0x3F) | 0x80);
          // Third UTF byte: Get the last six bits of charcode and mask them binary 10XX.XXXX:
          encoded = encoded + gethex((charcode & 0x3F) | 0x80);
        }

        // Position 65536 - : four bytes for UTF-8 character encoding.
        if (charcode > 65535) {
          // First UTF byte: Mask the first three bits of charcode with binary 1111.0XXX:
          encoded = encoded + gethex((charcode >> 18) | 0xF0);
          // Second UTF byte: Get the next six bits of charcode and mask them binary 10XX.XXXX:
          encoded = encoded + gethex(((charcode >> 12) & 0x3F) | 0x80);
          // Third UTF byte: Get the last six bits of charcode and mask them binary 10XX.XXXX:
          encoded = encoded + gethex(((charcode >> 6) & 0x3F) | 0x80);
          // Fourth UTF byte: Get the last six bits of charcode and mask them binary 10XX.XXXX:
          encoded = encoded + gethex((charcode & 0x3F) | 0x80);
        }

      }

    }  // end of for ...

    // Write result:
    return encoded;
	
  }
}

// --------------------------------- Decoding -------------------------------

// This function returns the decimal value of two hexadecimal digits.
// Input is a percent sign followed by two hexadecimal digits. If the input
// string is shorter than three characters, the percent sign is missing or if
// not a hexadecimal numeral is used, then the decimal value 256 is returned:
function getdec(hexencoded) {
  if (hexencoded.length == 3) {
    if (hexencoded.charAt(0) == "%") {
      if (hexchars.indexOf(hexencoded.charAt(1)) != -1 && hexchars.indexOf(hexencoded.charAt(2)) != -1) {
        return parseInt(hexencoded.substr(1,2),16);
      }
    }
  }
  return 256;
}

function decode() {
  // Clear output field:
  document.converter.decoded.value = "";

  // Some variables:
  var encoded = data;
  var decoded = "";
  // Remember characters that are not allowed in a URL:
  var notallowed = "";
  // Remember illegal percent encoding:
  var illegalencoding = "";

  // ---------------- If ASCII character encoding was chosen: ----------------
  if (charset == "ascii") {
    var i = 0;
    while (i < encoded.length) {
      var ch = encoded.charAt(i);
      // Check for percent-encoded string:
      if (ch == "%") {
        // Check if percent-encoded string represents an ASCII character:
        if (getdec(encoded.substr(i,3)) < 128) {
          decoded = decoded + unescape(encoded.substr(i,3));
        } else {
          decoded = decoded + encoded.substr(i,3);
          illegalencoding = illegalencoding + encoded.substr(i,3) + " ";
        }
        i = i + 3;
      } else {
        // Check if character is an allowed character:
        if (allowed.indexOf(ch) == -1) notallowed = notallowed + ch + " ";
        decoded = decoded + ch;
        i++;
      }
    }

    // Write result:
    document.converter.decoded.value = decoded;

    // Display warning message if necessary:
    var warning = "";
    if (notallowed != "") warning = warning + "Characters not allowed in a URL:\n" + notallowed + "\n\n";
    if (illegalencoding != "") warning = warning + "Illegal percent-encoding (for ASCII):\n" + illegalencoding  + "\n\n";
    if (warning != "") alert("Warning: Illegal characters/strings in encoded text!\n\n" + warning);
  }

  // ---------------- If UTF-8 character encoding was chosen: ----------------
  if (charset == "utf8") {
    // UTF-8 bytes from left to right:
    var byte1, byte2, byte3, byte4 = 0;

    var i = 0;
    while (i < encoded.length) {
      var ch = encoded.charAt(i);
      // Check for percent-encoded string:
      if (ch == "%") {

        // Check for legal percent-encoding of first byte:
        if (getdec(encoded.substr(i,3)) < 255) {

          // Get the decimal values of all (potential) UTF-bytes:
          byte1 = getdec(encoded.substr(i,3));
          byte2 = getdec(encoded.substr(i+3,3));
          byte3 = getdec(encoded.substr(i+6,3));
          byte4 = getdec(encoded.substr(i+9,3));

          // Check for one byte UTF-8 character encoding:
          if (byte1 < 128) {
            decoded = decoded + String.fromCharCode(byte1);
            i = i + 3;
          }

          // Check for illegal one byte UTF-8 character encoding:
          if (byte1 > 127 && byte1 < 192) {
            decoded = decoded + encoded.substr(i,3);
            illegalencoding = illegalencoding + encoded.substr(i,3) + " ";
            i = i + 3;
          }

          // Check for two byte UTF-8 character encoding:
          if (byte1 > 191 && byte1 < 224) {
            if (byte2 > 127 && byte2 < 192) {
              decoded = decoded + String.fromCharCode(((byte1 & 0x1F) << 6) | (byte2 & 0x3F));
            } else {
              decoded = decoded + encoded.substr(i,6);
              illegalencoding = illegalencoding + encoded.substr(i,6) + " ";
            }
            i = i + 6;
          }

          // Check for three byte UTF-8 character encoding:
          if (byte1 > 223 && byte1 < 240) {
            if (byte2 > 127 && byte2 < 192) {
              if (byte3 > 127 && byte3 < 192) {
                decoded = decoded + String.fromCharCode(((byte1 & 0xF) << 12) | ((byte2 & 0x3F) << 6) | (byte3 & 0x3F));
              } else {
                decoded = decoded + encoded.substr(i,9);
                illegalencoding = illegalencoding + encoded.substr(i,9) + " ";
              }
            } else {
              decoded = decoded + encoded.substr(i,9);
              illegalencoding = illegalencoding + encoded.substr(i,9) + " ";
            }
            i = i + 9;
          }

          // Check for four byte UTF-8 character encoding:
          if (byte1 > 239) {
            if (byte2 > 127 && byte2 < 192) {
              if (byte3 > 127 && byte3 < 192) {
                if (byte4 > 127 && byte4 < 192) {
                  decoded = decoded + String.fromCharCode(((byte1 & 0x7) << 18) | ((byte2 & 0x3F) << 12) | ((byte3 & 0x3F) << 6) | (byte4 & 0x3F));
                } else {
                  decoded = decoded + encoded.substr(i,12);
                  illegalencoding = illegalencoding + encoded.substr(i,12) + " ";
                }
              } else {
                decoded = decoded + encoded.substr(i,12);
                illegalencoding = illegalencoding + encoded.substr(i,12) + " ";
              }
            } else {
              decoded = decoded + encoded.substr(i,12);
              illegalencoding = illegalencoding + encoded.substr(i,12) + " ";
            }
            i = i + 12;
          }

        } else {  // the first byte is not legally percent-encoded
          decoded = decoded + encoded.substr(i,3);
          illegalencoding = illegalencoding + encoded.substr(i,3) + " ";
          i = i + 3;
        }

      } else {  // the string is not percent encoded
        // Check if character is an allowed character:
        if (allowed.indexOf(ch) == -1) notallowed = notallowed + ch + " ";
        decoded = decoded + ch;
        i++;
      }
    }  // end of while ...

    // Write result:
    document.converter.decoded.value = decoded;

    // Display warning message if necessary:
    var warning = "";
    if (notallowed != "") warning = warning + "Characters not allowed in a URL:\n" + notallowed + "\n\n";
    if (illegalencoding != "") warning = warning + "Illegal percent-encoding (for UTF-8):\n" + illegalencoding  + "\n\n";
    if (warning != "") alert("Warning: Illegal characters/strings in encoded text!\n\n" + warning);
  }
}


//-----------------------------------------------------------
function kiriltolatin(text){
		//Alfavit
	text = str_replace('Р','r',text); // Р
	text = str_replace('А','a',text); // А
	text = str_replace('Б','b',text); // Б
	text = str_replace('В','v',text); // В
	text = str_replace('Г','g',text); // Г
	text = str_replace('Д','d',text); // Д
	text = str_replace('Е','e',text); // Е
	text = str_replace('Ё','yo',text); // Ё
	text = str_replace('Ж','zh',text); // Ж
	text = str_replace('З','z',text); // З
	text = str_replace('И','i',text); // И
	text = str_replace('Й','y',text); // Й
	text = str_replace('К','k',text); // К
	text = str_replace('Л','l',text); // Л
	text = str_replace('М','m',text); // М
	text = str_replace('Н','n',text); // Н
	text = str_replace('О','o',text); // О
	text = str_replace('П','p',text); // П
	text = str_replace('С','s',text); // С
	text = str_replace('Т','t',text); // Т
	text = str_replace('У','u',text); // У
	text = str_replace('Ф','f',text); // Ф
	text = str_replace('Х','h',text); // Х
	text = str_replace('Ц','c',text); // Ц
	text = str_replace('Ч','ch',text); // Ч
	text = str_replace('Ш','sh',text); // Ш
	text = str_replace('Щ','sh',text); // Щ
	text = str_replace('Ъ','',text); // Ъ
	text = str_replace('Ы','y',text); // Ы
	text = str_replace('Ь','',text); // Ь
	text = str_replace('Э','e',text); // Э
	text = str_replace('Ю','yu',text); // Ю
	text = str_replace('Я','ya',text); // Я
	text = str_replace('а','a',text); // а
	text = str_replace('б','b',text); // б
	text = str_replace('в','v',text); // в
	text = str_replace('г','g',text); // г
	text = str_replace('д','d',text); // д
	text = str_replace('е','e',text); // е
	text = str_replace('ё','yo',text); // ё
	text = str_replace('ж','zh',text); // ж
	text = str_replace('з','z',text); // з
	text = str_replace('и','i',text); // и
	text = str_replace('й','y',text); // й
	text = str_replace('к','k',text); // к
	text = str_replace('л','l',text); // л
	text = str_replace('м','m',text); // м
	text = str_replace('н','n',text); // н
	text = str_replace('о','o',text); // о
	text = str_replace('п','p',text); // п
	text = str_replace('р','r',text); // р
	text = str_replace('с','s',text); // с
	text = str_replace('т','t',text); // т
	text = str_replace('у','u',text); // у
	text = str_replace('ф','f',text); // ф
	text = str_replace('х','h',text); // х
	text = str_replace('ц','c',text); // ц
	text = str_replace('ч','ch',text); // ч
	text = str_replace('ш','sh',text); // ш
	text = str_replace('щ','sh',text); // щ
	text = str_replace('ъ','',text); // ъ
	text = str_replace('ы','y',text); // ы
	text = str_replace('ь','',text); // ь
	text = str_replace('э','e',text); // э
	text = str_replace('ю','yu',text); // ю
	text = str_replace('я','ya',text); // я
	//Other 
	text = str_replace('&','',text); //
	text = str_replace('!','',text); // 
	text = str_replace('/','',text); // /
	text = str_replace('(','',text); // (
	text = str_replace(')','',text); // )
	text = str_replace('|','',text); // |
	text = str_replace('.','',text); // |
	text = str_replace(',','',text); // |
	text = str_replace('+','',text); // |
	text = str_replace(':','',text); // |
	text = str_replace(']','',text); // |
	text = str_replace('[','',text); // |
	text = str_replace('-','',text); // |
	text = str_replace('"','',text); // |
	text = str_replace("'",'',text);
	text = str_replace("&",'',text); // |
return text;
}

//--------------------------------------------------
function str_replace(search, replace, subject, count){ 
var i = 0, j = 0, temp = '', repl = '', sl = 0, fl = 0, 
f = [].concat(search), 
r = [].concat(replace), 
s = subject, 
ra = r instanceof Array, sa = s instanceof Array; 
s = [].concat(s); 
if (count) { 
this.window[count] = 0; 
} 
for (i=0, sl=s.length; i < sl; i++) { 
if (s[i] === '') { 
continue; 
} 
for (j=0, fl=f.length; j < fl; j++) { 
temp = s[i]+''; 
repl = ra ? (r[j] !== undefined ? r[j] : '') : r[0]; 
s[i] = (temp).split(f[j]).join(repl); 
if (count && s[i] !== temp) { 
this.window[count] += (temp.length-s[i].length)/f[j].length;} 
} 
} 
return sa ? s : s[0]; }