5.7.2

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cyberchef",
-  "version": "5.7.0",
+  "version": "5.7.2",
   "description": "The Cyber Swiss Army Knife for encryption, encoding, compression and data analysis.",
   "author": "n1474335 <n1474335@gmail.com>",
   "homepage": "https://gchq.github.io/CyberChef",
@@ -34,7 +34,6 @@
     "babel-loader": "^6.4.0",
     "babel-polyfill": "^6.23.0",
     "babel-preset-env": "^1.2.2",
-    "bootstrap": "^3.3.7",
     "css-loader": "^0.27.3",
     "exports-loader": "^0.6.4",
     "extract-text-webpack-plugin": "^2.1.0",
@@ -64,8 +63,8 @@
     "webpack": "^2.2.1"
   },
   "dependencies": {
+    "bootstrap": "^3.3.7",
     "bootstrap-colorpicker": "^2.5.1",
-    "bootstrap-sass": "^3.3.7",
     "bootstrap-switch": "^3.3.4",
     "crypto-api": "^0.6.2",
     "crypto-js": "^3.1.9-1",

src/core/Utils.js

@@ -498,127 +498,6 @@ const Utils = {
     },
 
 
-    /**
-     * Mapping of Unicode code points to Windows-1251
-     * @private
-     * @constant
-     */
-    UNIC_WIN1251_MAP: {
-        0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13,
-        14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24,
-        25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, 32: 32, 33: 33, 34: 34, 35: 35,
-        36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46,
-        47: 47, 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57,
-        58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, 64: 64, 65: 65, 66: 66, 67: 67, 68: 68,
-        69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79,
-        80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90,
-        91: 91, 92: 92, 93: 93, 94: 94, 95: 95, 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101,
-        102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110,
-        111: 111, 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119,
-        120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, 1027: 129,
-        8225: 135, 1046: 198, 8222: 132, 1047: 199, 1168: 165, 1048: 200, 1113: 154, 1049: 201,
-        1045: 197, 1050: 202, 1028: 170, 160: 160, 1040: 192, 1051: 203, 164: 164, 166: 166,
-        167: 167, 169: 169, 171: 171, 172: 172, 173: 173, 174: 174, 1053: 205, 176: 176, 177: 177,
-        1114: 156, 181: 181, 182: 182, 183: 183, 8221: 148, 187: 187, 1029: 189, 1056: 208,
-        1057: 209, 1058: 210, 8364: 136, 1112: 188, 1115: 158, 1059: 211, 1060: 212, 1030: 178,
-        1061: 213, 1062: 214, 1063: 215, 1116: 157, 1064: 216, 1065: 217, 1031: 175, 1066: 218,
-        1067: 219, 1068: 220, 1069: 221, 1070: 222, 1032: 163, 8226: 149, 1071: 223, 1072: 224,
-        8482: 153, 1073: 225, 8240: 137, 1118: 162, 1074: 226, 1110: 179, 8230: 133, 1075: 227,
-        1033: 138, 1076: 228, 1077: 229, 8211: 150, 1078: 230, 1119: 159, 1079: 231, 1042: 194,
-        1080: 232, 1034: 140, 1025: 168, 1081: 233, 1082: 234, 8212: 151, 1083: 235, 1169: 180,
-        1084: 236, 1052: 204, 1085: 237, 1035: 142, 1086: 238, 1087: 239, 1088: 240, 1089: 241,
-        1090: 242, 1036: 141, 1041: 193, 1091: 243, 1092: 244, 8224: 134, 1093: 245, 8470: 185,
-        1094: 246, 1054: 206, 1095: 247, 1096: 248, 8249: 139, 1097: 249, 1098: 250, 1044: 196,
-        1099: 251, 1111: 191, 1055: 207, 1100: 252, 1038: 161, 8220: 147, 1101: 253, 8250: 155,
-        1102: 254, 8216: 145, 1103: 255, 1043: 195, 1105: 184, 1039: 143, 1026: 128, 1106: 144,
-        8218: 130, 1107: 131, 8217: 146, 1108: 186, 1109: 190
-    },
-
-    /**
-     * Mapping of Windows-1251 code points to Unicode
-     * @private
-     * @constant
-     */
-    WIN1251_UNIC_MAP: {
-        0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13,
-        14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24,
-        25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, 32: 32, 33: 33, 34: 34, 35: 35,
-        36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46,
-        47: 47, 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57,
-        58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, 64: 64, 65: 65, 66: 66, 67: 67, 68: 68,
-        69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79,
-        80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90,
-        91: 91, 92: 92, 93: 93, 94: 94, 95: 95, 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101,
-        102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110,
-        111: 111, 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119,
-        120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, 160: 160,
-        164: 164, 166: 166, 167: 167, 169: 169, 171: 171, 172: 172, 173: 173, 174: 174, 176: 176,
-        177: 177, 181: 181, 182: 182, 183: 183, 187: 187, 168: 1025, 128: 1026, 129: 1027,
-        170: 1028, 189: 1029, 178: 1030, 175: 1031, 163: 1032, 138: 1033, 140: 1034, 142: 1035,
-        141: 1036, 161: 1038, 143: 1039, 192: 1040, 193: 1041, 194: 1042, 195: 1043, 196: 1044,
-        197: 1045, 198: 1046, 199: 1047, 200: 1048, 201: 1049, 202: 1050, 203: 1051, 204: 1052,
-        205: 1053, 206: 1054, 207: 1055, 208: 1056, 209: 1057, 210: 1058, 211: 1059, 212: 1060,
-        213: 1061, 214: 1062, 215: 1063, 216: 1064, 217: 1065, 218: 1066, 219: 1067, 220: 1068,
-        221: 1069, 222: 1070, 223: 1071, 224: 1072, 225: 1073, 226: 1074, 227: 1075, 228: 1076,
-        229: 1077, 230: 1078, 231: 1079, 232: 1080, 233: 1081, 234: 1082, 235: 1083, 236: 1084,
-        237: 1085, 238: 1086, 239: 1087, 240: 1088, 241: 1089, 242: 1090, 243: 1091, 244: 1092,
-        245: 1093, 246: 1094, 247: 1095, 248: 1096, 249: 1097, 250: 1098, 251: 1099, 252: 1100,
-        253: 1101, 254: 1102, 255: 1103, 184: 1105, 144: 1106, 131: 1107, 186: 1108, 190: 1109,
-        179: 1110, 191: 1111, 188: 1112, 154: 1113, 156: 1114, 158: 1115, 157: 1116, 162: 1118,
-        159: 1119, 165: 1168, 180: 1169, 150: 8211, 151: 8212, 145: 8216, 146: 8217, 130: 8218,
-        147: 8220, 148: 8221, 132: 8222, 134: 8224, 135: 8225, 149: 8226, 133: 8230, 137: 8240,
-        139: 8249, 155: 8250, 136: 8364, 185: 8470, 153: 8482
-    },
-
-
-    /**
-     * Converts a Unicode string to Windows-1251 encoding
-     *
-     * @param {string} unicStr
-     * @returns {string} String encoded in Windows-1251
-     *
-     * @example
-     * // returns "îáíîâëåííàÿ òåõíè÷êà ïî Áîèíãó. îðèãèíàë ó ìåíÿ. çàáåðåòå êîãäà áóäåòå â ÊÈ"
-     * Utils.unicodeToWin1251("обновленная техничка по Боингу. оригинал у меня. заберете когда будете в КИ");
-     */
-    unicodeToWin1251: function(unicStr) {
-        const res = [];
-
-        for (let i = 0; i < unicStr.length; i++) {
-            const ord = unicStr.charCodeAt(i);
-            if (!(ord in Utils.UNIC_WIN1251_MAP))
-                throw "Character '" + unicStr.charAt(i) + "' isn't supported by Windows-1251";
-            res.push(String.fromCharCode(Utils.UNIC_WIN1251_MAP[ord]));
-        }
-
-        return res.join("");
-    },
-
-
-    /**
-     * Converts a Windows-1251 string to Unicode encoding
-     *
-     * @param {string} win1251Str
-     * @returns {string} String encoded in Unicode
-     *
-     * @example
-     * // returns "обновленная техничка по Боингу. оригинал у меня. заберете когда будете в КИ"
-     * Utils.unicodeToWin1251("îáíîâëåííàÿ òåõíè÷êà ïî Áîèíãó. îðèãèíàë ó ìåíÿ. çàáåðåòå êîãäà áóäåòå â ÊÈ");
-     */
-    win1251ToUnicode: function(win1251Str) {
-        const res = [];
-
-        for (let i = 0; i < win1251Str.length; i++) {
-            const ord = win1251Str.charCodeAt(i);
-            if (!(ord in Utils.WIN1251_UNIC_MAP))
-                throw "Character '" + win1251Str.charAt(i) + "' isn't supported by Windows-1251";
-            res.push(String.fromCharCode(Utils.WIN1251_UNIC_MAP[ord]));
-        }
-
-        return res.join("");
-    },
-
-
     /**
      * Base64's the input byte array using the given alphabet, returning a string.
      *

src/core/lib/js-codepage/cputils.js

@@ -0,0 +1,515 @@
+/* cputils.js (C) 2013-present SheetJS -- http://sheetjs.com */
+/* vim: set ft=javascript: */
+/*jshint newcap: false */
+(function(root, factory) {
+  "use strict";
+  if(typeof cptable === "undefined") {
+    if(typeof require !== "undefined"){
+      var cpt = require('./cptable');
+      if (typeof module !== 'undefined' && module.exports) module.exports = factory(cpt);
+      else root.cptable = factory(cpt);
+    } else throw new Error("cptable not found");
+  } else cptable = factory(cptable);
+}(this, function(cpt){
+  "use strict";
+  var magic = {
+    "1200":"utf16le",
+    "1201":"utf16be",
+    "12000":"utf32le",
+    "12001":"utf32be",
+    "16969":"utf64le",
+    "20127":"ascii",
+    "65000":"utf7",
+    "65001":"utf8"
+  };
+
+  var sbcs_cache = [874,1250,1251,1252,1253,1254,1255,1256,10000];
+  var dbcs_cache = [932,936,949,950];
+  var magic_cache = [65001];
+  var magic_decode = {};
+  var magic_encode = {};
+  var cpdcache = {};
+  var cpecache = {};
+
+  var sfcc = function sfcc(x) { return String.fromCharCode(x); };
+  var cca = function cca(x) { return x.charCodeAt(0); };
+
+  var has_buf = (typeof Buffer !== 'undefined');
+  if(has_buf) {
+    var mdl = 1024, mdb = new Buffer(mdl);
+    var make_EE = function make_EE(E){
+      var EE = new Buffer(65536);
+      for(var i = 0; i < 65536;++i) EE[i] = 0;
+      var keys = Object.keys(E), len = keys.length;
+      for(var ee = 0, e = keys[ee]; ee < len; ++ee) {
+        if(!(e = keys[ee])) continue;
+        EE[e.charCodeAt(0)] = E[e];
+      }
+      return EE;
+    };
+    var sbcs_encode = function make_sbcs_encode(cp) {
+      var EE = make_EE(cpt[cp].enc);
+      return function sbcs_e(data, ofmt) {
+        var len = data.length;
+        var out, i=0, j=0, D=0, w=0;
+        if(typeof data === 'string') {
+          out = new Buffer(len);
+          for(i = 0; i < len; ++i) out[i] = EE[data.charCodeAt(i)];
+        } else if(Buffer.isBuffer(data)) {
+          out = new Buffer(2*len);
+          j = 0;
+          for(i = 0; i < len; ++i) {
+            D = data[i];
+            if(D < 128) out[j++] = EE[D];
+            else if(D < 224) { out[j++] = EE[((D&31)<<6)+(data[i+1]&63)]; ++i; }
+            else if(D < 240) { out[j++] = EE[((D&15)<<12)+((data[i+1]&63)<<6)+(data[i+2]&63)]; i+=2; }
+            else {
+              w = ((D&7)<<18)+((data[i+1]&63)<<12)+((data[i+2]&63)<<6)+(data[i+3]&63); i+=3;
+              if(w < 65536) out[j++] = EE[w];
+              else { w -= 65536; out[j++] = EE[0xD800 + ((w>>10)&1023)]; out[j++] = EE[0xDC00 + (w&1023)]; }
+            }
+          }
+          out = out.slice(0,j);
+        } else {
+          out = new Buffer(len);
+          for(i = 0; i < len; ++i) out[i] = EE[data[i].charCodeAt(0)];
+        }
+        if(!ofmt || ofmt === 'buf') return out;
+        if(ofmt !== 'arr') return out.toString('binary');
+        return [].slice.call(out);
+      };
+    };
+    var sbcs_decode = function make_sbcs_decode(cp) {
+      var D = cpt[cp].dec;
+      var DD = new Buffer(131072), d=0, c="";
+      for(d=0;d<D.length;++d) {
+        if(!(c=D[d])) continue;
+        var w = c.charCodeAt(0);
+        DD[2*d] = w&255; DD[2*d+1] = w>>8;
+      }
+      return function sbcs_d(data) {
+        var len = data.length, i=0, j=0;
+        if(2 * len > mdl) { mdl = 2 * len; mdb = new Buffer(mdl); }
+        if(Buffer.isBuffer(data)) {
+          for(i = 0; i < len; i++) {
+            j = 2*data[i];
+            mdb[2*i] = DD[j]; mdb[2*i+1] = DD[j+1];
+          }
+        } else if(typeof data === "string") {
+          for(i = 0; i < len; i++) {
+            j = 2*data.charCodeAt(i);
+            mdb[2*i] = DD[j]; mdb[2*i+1] = DD[j+1];
+          }
+        } else {
+          for(i = 0; i < len; i++) {
+            j = 2*data[i];
+            mdb[2*i] = DD[j]; mdb[2*i+1] = DD[j+1];
+          }
+        }
+        return mdb.slice(0, 2 * len).toString('ucs2');
+      };
+    };
+    var dbcs_encode = function make_dbcs_encode(cp) {
+      var E = cpt[cp].enc;
+      var EE = new Buffer(131072);
+      for(var i = 0; i < 131072; ++i) EE[i] = 0;
+      var keys = Object.keys(E);
+      for(var ee = 0, e = keys[ee]; ee < keys.length; ++ee) {
+        if(!(e = keys[ee])) continue;
+        var f = e.charCodeAt(0);
+        EE[2*f] = E[e] & 255; EE[2*f+1] = E[e]>>8;
+      }
+      return function dbcs_e(data, ofmt) {
+        var len = data.length, out = new Buffer(2*len), i=0, j=0, jj=0, k=0, D=0;
+        if(typeof data === 'string') {
+          for(i = k = 0; i < len; ++i) {
+            j = data.charCodeAt(i)*2;
+            out[k++] = EE[j+1] || EE[j]; if(EE[j+1] > 0) out[k++] = EE[j];
+          }
+          out = out.slice(0,k);
+        } else if(Buffer.isBuffer(data)) {
+          for(i = k = 0; i < len; ++i) {
+            D = data[i];
+            if(D < 128) j = D;
+            else if(D < 224) { j = ((D&31)<<6)+(data[i+1]&63); ++i; }
+            else if(D < 240) { j = ((D&15)<<12)+((data[i+1]&63)<<6)+(data[i+2]&63); i+=2; }
+            else { j = ((D&7)<<18)+((data[i+1]&63)<<12)+((data[i+2]&63)<<6)+(data[i+3]&63); i+=3; }
+            if(j<65536) { j*=2; out[k++] = EE[j+1] || EE[j]; if(EE[j+1] > 0) out[k++] = EE[j]; }
+            else { jj = j-65536;
+              j=2*(0xD800 + ((jj>>10)&1023)); out[k++] = EE[j+1] || EE[j]; if(EE[j+1] > 0) out[k++] = EE[j];
+              j=2*(0xDC00 + (jj&1023)); out[k++] = EE[j+1] || EE[j]; if(EE[j+1] > 0) out[k++] = EE[j];
+            }
+          }
+          out = out.slice(0,k);
+        } else {
+          for(i = k = 0; i < len; i++) {
+            j = data[i].charCodeAt(0)*2;
+            out[k++] = EE[j+1] || EE[j]; if(EE[j+1] > 0) out[k++] = EE[j];
+          }
+        }
+        if(!ofmt || ofmt === 'buf') return out;
+        if(ofmt !== 'arr') return out.toString('binary');
+        return [].slice.call(out);
+      };
+    };
+    var dbcs_decode = function make_dbcs_decode(cp) {
+      var D = cpt[cp].dec;
+      var DD = new Buffer(131072), d=0, c, w=0, j=0, i=0;
+      for(i = 0; i < 65536; ++i) { DD[2*i] = 0xFF; DD[2*i+1] = 0xFD;}
+      for(d = 0; d < D.length; ++d) {
+        if(!(c=D[d])) continue;
+        w = c.charCodeAt(0);
+        j = 2*d;
+        DD[j] = w&255; DD[j+1] = w>>8;
+      }
+      return function dbcs_d(data) {
+        var len = data.length, out = new Buffer(2*len), i=0, j=0, k=0;
+        if(Buffer.isBuffer(data)) {
+          for(i = 0; i < len; i++) {
+            j = 2*data[i];
+            if(DD[j]===0xFF && DD[j+1]===0xFD) { j=2*((data[i]<<8)+data[i+1]); ++i; }
+            out[k++] = DD[j]; out[k++] = DD[j+1];
+          }
+        } else if(typeof data === "string") {
+          for(i = 0; i < len; i++) {
+            j = 2*data.charCodeAt(i);
+            if(DD[j]===0xFF && DD[j+1]===0xFD) { j=2*((data.charCodeAt(i)<<8)+data.charCodeAt(i+1)); ++i; }
+            out[k++] = DD[j]; out[k++] = DD[j+1];
+          }
+        } else {
+          for(i = 0; i < len; i++) {
+            j = 2*data[i];
+            if(DD[j]===0xFF && DD[j+1]===0xFD) { j=2*((data[i]<<8)+data[i+1]); ++i; }
+            out[k++] = DD[j]; out[k++] = DD[j+1];
+          }
+        }
+        return out.slice(0,k).toString('ucs2');
+      };
+    };
+    magic_decode[65001] = function utf8_d(data) {
+      if(typeof data === "string") return utf8_d(data.split("").map(cca));
+      var len = data.length, w = 0, ww = 0;
+      if(4 * len > mdl) { mdl = 4 * len; mdb = new Buffer(mdl); }
+      var i = 0;
+      if(len >= 3 && data[0] == 0xEF) if(data[1] == 0xBB && data[2] == 0xBF) i = 3;
+      for(var j = 1, k = 0, D = 0; i < len; i+=j) {
+        j = 1; D = data[i];
+        if(D < 128) w = D;
+        else if(D < 224) { w=(D&31)*64+(data[i+1]&63); j=2; }
+        else if(D < 240) { w=((D&15)<<12)+(data[i+1]&63)*64+(data[i+2]&63); j=3; }
+        else { w=(D&7)*262144+((data[i+1]&63)<<12)+(data[i+2]&63)*64+(data[i+3]&63); j=4; }
+        if(w < 65536) { mdb[k++] = w&255; mdb[k++] = w>>8; }
+        else {
+          w -= 65536; ww = 0xD800 + ((w>>10)&1023); w = 0xDC00 + (w&1023);
+          mdb[k++] = ww&255; mdb[k++] = ww>>>8; mdb[k++] = w&255; mdb[k++] = (w>>>8)&255;
+        }
+      }
+      return mdb.slice(0,k).toString('ucs2');
+    };
+    magic_encode[65001] = function utf8_e(data, ofmt) {
+      if(has_buf && Buffer.isBuffer(data)) {
+        if(!ofmt || ofmt === 'buf') return data;
+        if(ofmt !== 'arr') return data.toString('binary');
+        return [].slice.call(data);
+      }
+      var len = data.length, w = 0, ww = 0, j = 0;
+      var direct = typeof data === "string";
+      if(4 * len > mdl) { mdl = 4 * len; mdb = new Buffer(mdl); }
+      for(var i = 0; i < len; ++i) {
+        w = direct ? data.charCodeAt(i) : data[i].charCodeAt(0);
+        if(w <= 0x007F) mdb[j++] = w;
+        else if(w <= 0x07FF) {
+          mdb[j++] = 192 + (w >> 6);
+          mdb[j++] = 128 + (w&63);
+        } else if(w >= 0xD800 && w <= 0xDFFF) {
+          w -= 0xD800; ++i;
+          ww = (direct ? data.charCodeAt(i) : data[i].charCodeAt(0)) - 0xDC00 + (w << 10);
+          mdb[j++] = 240 + ((ww>>>18) & 0x07);
+          mdb[j++] = 144 + ((ww>>>12) & 0x3F);
+          mdb[j++] = 128 + ((ww>>>6) & 0x3F);
+          mdb[j++] = 128 + (ww & 0x3F);
+        } else {
+          mdb[j++] = 224 + (w >> 12);
+          mdb[j++] = 128 + ((w >> 6)&63);
+          mdb[j++] = 128 + (w&63);
+        }
+      }
+      if(!ofmt || ofmt === 'buf') return mdb.slice(0,j);
+      if(ofmt !== 'arr') return mdb.slice(0,j).toString('binary');
+      return [].slice.call(mdb, 0, j);
+    };
+  }
+
+  var encache = function encache() {
+    if(has_buf) {
+      if(cpdcache[sbcs_cache[0]]) return;
+      var i=0, s=0;
+      for(i = 0; i < sbcs_cache.length; ++i) {
+        s = sbcs_cache[i];
+        if(cpt[s]) {
+          cpdcache[s] = sbcs_decode(s);
+          cpecache[s] = sbcs_encode(s);
+        }
+      }
+      for(i = 0; i < dbcs_cache.length; ++i) {
+        s = dbcs_cache[i];
+        if(cpt[s]) {
+          cpdcache[s] = dbcs_decode(s);
+          cpecache[s] = dbcs_encode(s);
+        }
+      }
+      for(i = 0; i < magic_cache.length; ++i) {
+        s = magic_cache[i];
+        if(magic_decode[s]) cpdcache[s] = magic_decode[s];
+        if(magic_encode[s]) cpecache[s] = magic_encode[s];
+      }
+    }
+  };
+  var null_enc = function(data, ofmt) { return ""; };
+  var cp_decache = function cp_decache(cp) { delete cpdcache[cp]; delete cpecache[cp]; };
+  var decache = function decache() {
+    if(has_buf) {
+      if(!cpdcache[sbcs_cache[0]]) return;
+      sbcs_cache.forEach(cp_decache);
+      dbcs_cache.forEach(cp_decache);
+      magic_cache.forEach(cp_decache);
+    }
+    last_enc = null_enc; last_cp = 0;
+  };
+  var cache = {
+    encache: encache,
+    decache: decache,
+    sbcs: sbcs_cache,
+    dbcs: dbcs_cache
+  };
+
+  encache();
+
+  var BM = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  var SetD = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'(),-./:?";
+  var last_enc = null_enc, last_cp = 0;
+  var encode = function encode(cp, data, ofmt) {
+    if(cp === last_cp && last_enc) { return last_enc(data, ofmt); }
+    if(cpecache[cp]) { last_enc = cpecache[last_cp=cp]; return last_enc(data, ofmt); }
+    if(has_buf && Buffer.isBuffer(data)) data = data.toString('utf8');
+    var len = data.length;
+    var out = has_buf ? new Buffer(4*len) : [], w=0, i=0, j = 0, ww=0;
+    var C = cpt[cp], E, M = "";
+    var isstr = typeof data === 'string';
+    if(C && (E=C.enc)) for(i = 0; i < len; ++i, ++j) {
+      w = E[isstr? data.charAt(i) : data[i]];
+      if(w > 255) {
+        out[j] = w>>8;
+        out[++j] = w&255;
+      } else out[j] = w&255;
+    }
+    else if((M=magic[cp])) switch(M) {
+      case "utf8":
+        if(has_buf && isstr) { out = new Buffer(data, M); j = out.length; break; }
+        for(i = 0; i < len; ++i, ++j) {
+          w = isstr ? data.charCodeAt(i) : data[i].charCodeAt(0);
+          if(w <= 0x007F) out[j] = w;
+          else if(w <= 0x07FF) {
+            out[j]   = 192 + (w >> 6);
+            out[++j] = 128 + (w&63);
+          } else if(w >= 0xD800 && w <= 0xDFFF) {
+            w -= 0xD800;
+            ww = (isstr ? data.charCodeAt(++i) : data[++i].charCodeAt(0)) - 0xDC00 + (w << 10);
+            out[j]   = 240 + ((ww>>>18) & 0x07);
+            out[++j] = 144 + ((ww>>>12) & 0x3F);
+            out[++j] = 128 + ((ww>>>6) & 0x3F);
+            out[++j] = 128 + (ww & 0x3F);
+          } else {
+            out[j]   = 224 + (w >> 12);
+            out[++j] = 128 + ((w >> 6)&63);
+            out[++j] = 128 + (w&63);
+          }
+        }
+        break;
+      case "ascii":
+        if(has_buf && typeof data === "string") { out = new Buffer(data, M); j = out.length; break; }
+        for(i = 0; i < len; ++i, ++j) {
+          w = isstr ? data.charCodeAt(i) : data[i].charCodeAt(0);
+          if(w <= 0x007F) out[j] = w;
+          else throw new Error("bad ascii " + w);
+        }
+        break;
+      case "utf16le":
+        if(has_buf && typeof data === "string") { out = new Buffer(data, M); j = out.length; break; }
+        for(i = 0; i < len; ++i) {
+          w = isstr ? data.charCodeAt(i) : data[i].charCodeAt(0);
+          out[j++] = w&255;
+          out[j++] = w>>8;
+        }
+        break;
+      case "utf16be":
+        for(i = 0; i < len; ++i) {
+          w = isstr ? data.charCodeAt(i) : data[i].charCodeAt(0);
+          out[j++] = w>>8;
+          out[j++] = w&255;
+        }
+        break;
+      case "utf32le":
+        for(i = 0; i < len; ++i) {
+          w = isstr ? data.charCodeAt(i) : data[i].charCodeAt(0);
+          if(w >= 0xD800 && w <= 0xDFFF) w = 0x10000 + ((w - 0xD800) << 10) + (data[++i].charCodeAt(0) - 0xDC00);
+          out[j++] = w&255; w >>= 8;
+          out[j++] = w&255; w >>= 8;
+          out[j++] = w&255; w >>= 8;
+          out[j++] = w&255;
+        }
+        break;
+      case "utf32be":
+        for(i = 0; i < len; ++i) {
+          w = isstr ? data.charCodeAt(i) : data[i].charCodeAt(0);
+          if(w >= 0xD800 && w <= 0xDFFF) w = 0x10000 + ((w - 0xD800) << 10) + (data[++i].charCodeAt(0) - 0xDC00);
+          out[j+3] = w&255; w >>= 8;
+          out[j+2] = w&255; w >>= 8;
+          out[j+1] = w&255; w >>= 8;
+          out[j] = w&255;
+          j+=4;
+        }
+        break;
+      case "utf7":
+        for(i = 0; i < len; i++) {
+          var c = isstr ? data.charAt(i) : data[i].charAt(0);
+          if(c === "+") { out[j++] = 0x2b; out[j++] = 0x2d; continue; }
+          if(SetD.indexOf(c) > -1) { out[j++] = c.charCodeAt(0); continue; }
+          var tt = encode(1201, c);
+          out[j++] = 0x2b;
+          out[j++] = BM.charCodeAt(tt[0]>>2);
+          out[j++] = BM.charCodeAt(((tt[0]&0x03)<<4) + ((tt[1]||0)>>4));
+          out[j++] = BM.charCodeAt(((tt[1]&0x0F)<<2) + ((tt[2]||0)>>6));
+          out[j++] = 0x2d;
+        }
+        break;
+      default: throw new Error("Unsupported magic: " + cp + " " + magic[cp]);
+    }
+    else throw new Error("Unrecognized CP: " + cp);
+    out = out.slice(0,j);
+    if(!has_buf) return (ofmt == 'str') ? (out).map(sfcc).join("") : out;
+    if(!ofmt || ofmt === 'buf') return out;
+    if(ofmt !== 'arr') return out.toString('binary');
+    return [].slice.call(out);
+  };
+  var decode = function decode(cp, data) {
+    var F; if((F=cpdcache[cp])) return F(data);
+    if(typeof data === "string") return decode(cp, data.split("").map(cca));
+    var len = data.length, out = new Array(len), s="", w=0, i=0, j=1, k=0, ww=0;
+    var C = cpt[cp], D, M="";
+    if(C && (D=C.dec)) {
+      for(i = 0; i < len; i+=j) {
+        j = 2;
+        s = D[(data[i]<<8)+ data[i+1]];
+        if(!s) {
+          j = 1;
+          s = D[data[i]];
+        }
+        if(!s) throw new Error('Unrecognized code: ' + data[i] + ' ' + data[i+j-1] + ' ' + i + ' ' + j + ' ' + D[data[i]]);
+        out[k++] = s;
+      }
+    }
+    else if((M=magic[cp])) switch(M) {
+      case "utf8":
+        if(len >= 3 && data[0] == 0xEF) if(data[1] == 0xBB && data[2] == 0xBF) i = 3;
+        for(; i < len; i+=j) {
+          j = 1;
+          if(data[i] < 128) w = data[i];
+          else if(data[i] < 224) { w=(data[i]&31)*64+(data[i+1]&63); j=2; }
+          else if(data[i] < 240) { w=((data[i]&15)<<12)+(data[i+1]&63)*64+(data[i+2]&63); j=3; }
+          else { w=(data[i]&7)*262144+((data[i+1]&63)<<12)+(data[i+2]&63)*64+(data[i+3]&63); j=4; }
+          if(w < 65536) { out[k++] = String.fromCharCode(w); }
+          else {
+            w -= 65536; ww = 0xD800 + ((w>>10)&1023); w = 0xDC00 + (w&1023);
+            out[k++] = String.fromCharCode(ww); out[k++] = String.fromCharCode(w);
+          }
+        }
+        break;
+      case "ascii":
+        if(has_buf && Buffer.isBuffer(data)) return data.toString(M);
+        for(i = 0; i < len; i++) out[i] = String.fromCharCode(data[i]);
+        k = len; break;
+      case "utf16le":
+        if(len >= 2 && data[0] == 0xFF) if(data[1] == 0xFE) i = 2;
+        if(has_buf && Buffer.isBuffer(data)) return data.toString(M);
+        j = 2;
+        for(; i+1 < len; i+=j) {
+          out[k++] = String.fromCharCode((data[i+1]<<8) + data[i]);
+        }
+        break;
+      case "utf16be":
+        if(len >= 2 && data[0] == 0xFE) if(data[1] == 0xFF) i = 2;
+        j = 2;
+        for(; i+1 < len; i+=j) {
+          out[k++] = String.fromCharCode((data[i]<<8) + data[i+1]);
+        }
+        break;
+      case "utf32le":
+        if(len >= 4 && data[0] == 0xFF) if(data[1] == 0xFE && data[2] === 0 && data[3] === 0) i = 4;
+        j = 4;
+        for(; i < len; i+=j) {
+          w = (data[i+3]<<24) + (data[i+2]<<16) + (data[i+1]<<8) + (data[i]);
+          if(w > 0xFFFF) {
+            w -= 0x10000;
+            out[k++] = String.fromCharCode(0xD800 + ((w >> 10) & 0x3FF));
+            out[k++] = String.fromCharCode(0xDC00 + (w & 0x3FF));
+          }
+          else out[k++] = String.fromCharCode(w);
+        }
+        break;
+      case "utf32be":
+        if(len >= 4 && data[3] == 0xFF) if(data[2] == 0xFE && data[1] === 0 && data[0] === 0) i = 4;
+        j = 4;
+        for(; i < len; i+=j) {
+          w = (data[i]<<24) + (data[i+1]<<16) + (data[i+2]<<8) + (data[i+3]);
+          if(w > 0xFFFF) {
+            w -= 0x10000;
+            out[k++] = String.fromCharCode(0xD800 + ((w >> 10) & 0x3FF));
+            out[k++] = String.fromCharCode(0xDC00 + (w & 0x3FF));
+          }
+          else out[k++] = String.fromCharCode(w);
+        }
+        break;
+      case "utf7":
+        if(len >= 4 && data[0] == 0x2B && data[1] == 0x2F && data[2] == 0x76) {
+          if(len >= 5 && data[3] == 0x38 && data[4] == 0x2D) i = 5;
+          else if(data[3] == 0x38 || data[3] == 0x39 || data[3] == 0x2B || data[3] == 0x2F) i = 4;
+        }
+        for(; i < len; i+=j) {
+          if(data[i] !== 0x2b) { j=1; out[k++] = String.fromCharCode(data[i]); continue; }
+          j=1;
+          if(data[i+1] === 0x2d) { j = 2; out[k++] = "+"; continue; }
+          while(String.fromCharCode(data[i+j]).match(/[A-Za-z0-9+\/]/)) j++;
+          var dash = 0;
+          if(data[i+j] === 0x2d) { ++j; dash=1; }
+          var tt = [];
+          var o64 = "";
+          var c1=0, c2=0, c3=0;
+          var e1=0, e2=0, e3=0, e4=0;
+          for(var l = 1; l < j - dash;) {
+            e1 = BM.indexOf(String.fromCharCode(data[i+l++]));
+            e2 = BM.indexOf(String.fromCharCode(data[i+l++]));
+            c1 = e1 << 2 | e2 >> 4;
+            tt.push(c1);
+            e3 = BM.indexOf(String.fromCharCode(data[i+l++]));
+            if(e3 === -1) break;
+            c2 = (e2 & 15) << 4 | e3 >> 2;
+            tt.push(c2);
+            e4 = BM.indexOf(String.fromCharCode(data[i+l++]));
+            if(e4 === -1) break;
+            c3 = (e3 & 3) << 6 | e4;
+            if(e4 < 64) tt.push(c3);
+          }
+          o64 = decode(1201, tt);
+          for(l = 0; l < o64.length; ++l) out[k++] = o64.charAt(l);
+        }
+        break;
+      default: throw new Error("Unsupported magic: " + cp + " " + magic[cp]);
+    }
+    else throw new Error("Unrecognized CP: " + cp);
+    return out.slice(0,k).join("");
+  };
+  var hascp = function hascp(cp) { return !!(cpt[cp] || magic[cp]); };
+  cpt.utils = { decode: decode, encode: encode, hascp: hascp, magic: magic, cache:cache };
+  return cpt;
+}));

src/core/operations/CharEnc.js

@@ -1,4 +1,4 @@
-import cptable from "../lib/codepage.js";
+import cptable from "../lib/js-codepage/cptable.js";
 import Utils from "../Utils.js";
 import CryptoJS from "crypto-js";
 

src/web/App.js

@@ -70,6 +70,9 @@ App.prototype.loaded = function() {
         document.getElementById("loader-wrapper").remove();
         document.body.classList.remove("loaded");
     }, 1000);
+
+    // Clear the loading message interval
+    clearInterval(window.loadingMsgInt);
 };
 
 

src/web/html/index.html

@@ -34,12 +34,37 @@
         <script type="application/javascript">
             // Load theme before the preloader is shown
             document.querySelector(":root").className = JSON.parse(localStorage.getItem("options")).theme;
+
+            // Cycle loading messages
+            const loadingMsgs = [
+                "Proving P = NP...",
+                "Computing 6 x 9...",
+                "Mining bitcoin...",
+                "Dividing by 0...",
+                "Initialising Skynet...",
+                "[REDACTED]",
+                "Downloading more RAM...",
+                "Loading more loading messages...",
+                "Ordering 1s and 0s...",
+                "Navigating neural network...",
+                "Importing machine learning..."
+            ];
+            function changeLoadingMsg() {
+                try {
+                    const el = document.getElementById("preloader-msg");
+                    el.className = "loading"; // Causes CSS transition on first message
+                    el.innerHTML = loadingMsgs[Math.floor(Math.random()*loadingMsgs.length)];
+                } catch (err) {}
+            }
+            changeLoadingMsg();
+            window.loadingMsgsInt = setInterval(changeLoadingMsg, (Math.random()*500) + 500);
         </script>
     </head>
     <body>
         <!-- Preloader overlay -->
         <div id="loader-wrapper">
             <div id="preloader"></div>
+            <div id="preloader-msg"></div>
         </div>
         <!-- End preloader overlay -->
         <span id="edit-favourites" class="btn btn-default btn-sm"><img aria-hidden="true" src="<%- require('../static/images/favourite-16x16.png') %>" alt="Star Icon"/> Edit</span>

src/web/stylesheets/preloader.css

@@ -55,9 +55,26 @@
     animation: spin 1.5s linear infinite;
 }
 
+#preloader-msg {
+    display: block;
+    position: relative;
+    width: 300px;
+    left: calc(50% - 150px);
+    top: calc(50% + 50px);
+    text-align: center;
+    margin-top: 50px;
+    opacity: 0;
+}
+
+#preloader-msg.loading {
+    opacity: 1;
+    transition: all 0.1s ease-in;
+}
+
 
 /* Loaded */
-.loaded #preloader {
+.loaded #preloader,
+.loaded #preloader-msg {
     opacity: 0;
     transition: all 0.3s ease-out;
 }

test/tests/operations/CharEnc.js

@@ -68,4 +68,23 @@ TestRegister.addTests([
             },
         ],
     },
+    {
+        name: "Generate Base64 Windows Powershell",
+        input: "ZABpAHIAIAAiAGMAOgBcAHAAcgBvAGcAcgBhAG0AIABmAGkAbABlAHMAIgAgAA==",
+        expectedOutput: "dir \"c:\\program files\" ",
+        recipeConfig: [
+            {
+                "op": "From Base64",
+                "args": ["A-Za-z0-9+/=", true]
+            },
+            {
+                "op": "Decode text",
+                "args": ["UTF16LE (1200)"]
+            },
+            {
+                "op": "Encode text",
+                "args": ["UTF-8 (65001)"]
+            },
+        ],
+    },
 ]);