8.15.1

Merge branch 'j433866-master'
Magic crib now only applies after all branches have been explored.
2025-12-05 23:53:27 +00:00 · 2018-12-19 17:25:05 +00:00 · 2018-12-19 17:24:52 +00:00 · 2018-12-19 17:24:38 +00:00 · 2018-12-19 16:38:34 +00:00 · 2018-12-19 09:42:09 +00:00
48 changed files with 3256 additions and 1174 deletions
--- a/.babelrc
+++ b/.babelrc
@@ -1,19 +0,0 @@
-{
-    "presets": [
-        ["@babel/preset-env", {
-            "targets": {
-                "chrome": 40,
-                "firefox": 35,
-                "edge": 14,
-                "node": "6.5"
-            },
-            "modules": false,
-            "useBuiltIns": "entry"
-        }]
-    ],
-    "plugins": [
-        ["babel-plugin-transform-builtin-extend", {
-            "globals": ["Error"]
-        }]
-    ]
-}
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,24 @@
 # Changelog
-All notable changes to CyberChef will be documented in this file.
+All major and minor version changes will be documented in this file. Details of patch-level version changes can be found in [commit messages](https://github.com/gchq/CyberChef/commits/master).
+
+
+### [8.15.0] - 2018-12-18
+- 'Text Encoding Brute Force' operation added [@Cynser] | [#439]
+
+### [8.14.0] - 2018-12-18
+- 'To Base62' and 'From Base62' operations added [@tcode2k16] | [#443]
+
+### [8.13.0] - 2018-12-15
+- 'A1Z26 Cipher Encode' and 'A1Z26 Cipher Decode' operations added [@jarmovanlenthe] | [#441]
+
+### [8.12.0] - 2018-11-21
+- 'Citrix CTX1 Encode' and 'Citrix CTX1 Decode' operations added [@bwhitn] | [#428]
+
+### [8.11.0] - 2018-11-13
+- 'CSV to JSON' and 'JSON to CSV' operations added [@n1474335] | [#277]
+
+### [8.10.0] - 2018-11-07
+- 'Remove Diacritics' operation added [@klaxon1] | [#387]

 ### [8.9.0] - 2018-11-07
 - 'Defang URL' operation added [@arnydo] | [#394]
@@ -46,7 +65,7 @@ All notable changes to CyberChef will be documented in this file.
 - Added support for loading, processing and downloading files up to 500MB [@n1474335] | [#224]

 ## [6.0.0] - 2017-09-19
- Threading support added. All recipe processing moved into a [Web Worker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers) to increase performance and allowing long-running operations to be cancelled [@n1474335] | [#173]
+- Threading support added. All recipe processing moved into a [Web Worker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers) to increase performance and to allow long-running operations to be cancelled [@n1474335] | [#173]
 - Module system created so that operations relying on large libraries can be downloaded separately as required, reducing the initial loading time for the app [@n1474335] | [#173]

 ## [5.0.0] - 2017-03-30
@@ -56,6 +75,14 @@ All notable changes to CyberChef will be documented in this file.
 -  Initial open source commit [@n1474335] | [b1d73a72](https://github.com/gchq/CyberChef/commit/b1d73a725dc7ab9fb7eb789296efd2b7e4b08306)


+
+[8.15.0]: https://github.com/gchq/CyberChef/releases/tag/v8.15.0
+[8.14.0]: https://github.com/gchq/CyberChef/releases/tag/v8.14.0
+[8.13.0]: https://github.com/gchq/CyberChef/releases/tag/v8.13.0
+[8.12.0]: https://github.com/gchq/CyberChef/releases/tag/v8.12.0
+[8.11.0]: https://github.com/gchq/CyberChef/releases/tag/v8.11.0
+[8.10.0]: https://github.com/gchq/CyberChef/releases/tag/v8.10.0
+[8.9.0]: https://github.com/gchq/CyberChef/releases/tag/v8.9.0
 [8.8.0]: https://github.com/gchq/CyberChef/releases/tag/v8.8.0
 [8.7.0]: https://github.com/gchq/CyberChef/releases/tag/v8.7.0
 [8.6.0]: https://github.com/gchq/CyberChef/releases/tag/v8.6.0
@@ -80,6 +107,11 @@ All notable changes to CyberChef will be documented in this file.
 [@sevzero]: https://github.com/sevzero
 [@PenguinGeorge]: https://github.com/PenguinGeorge
 [@arnydo]: https://github.com/arnydo
+[@klaxon1]: https://github.com/klaxon1
+[@bwhitn]: https://github.com/bwhitn
+[@jarmovanlenthe]: https://github.com/jarmovanlenthe
+[@tcode2k16]: https://github.com/tcode2k16
+[@Cynser]: https://github.com/Cynser

 [#95]: https://github.com/gchq/CyberChef/pull/299
 [#173]: https://github.com/gchq/CyberChef/pull/173
@@ -87,6 +119,7 @@ All notable changes to CyberChef will be documented in this file.
 [#239]: https://github.com/gchq/CyberChef/pull/239
 [#248]: https://github.com/gchq/CyberChef/pull/248
 [#255]: https://github.com/gchq/CyberChef/issues/255
+[#277]: https://github.com/gchq/CyberChef/issues/277
 [#281]: https://github.com/gchq/CyberChef/pull/281
 [#284]: https://github.com/gchq/CyberChef/pull/284
 [#294]: https://github.com/gchq/CyberChef/pull/294
@@ -99,4 +132,9 @@ All notable changes to CyberChef will be documented in this file.
 [#344]: https://github.com/gchq/CyberChef/pull/344
 [#348]: https://github.com/gchq/CyberChef/pull/348
 [#351]: https://github.com/gchq/CyberChef/pull/351
+[#387]: https://github.com/gchq/CyberChef/pull/387
 [#394]: https://github.com/gchq/CyberChef/pull/394
+[#428]: https://github.com/gchq/CyberChef/pull/428
+[#439]: https://github.com/gchq/CyberChef/pull/439
+[#441]: https://github.com/gchq/CyberChef/pull/441
+[#443]: https://github.com/gchq/CyberChef/pull/443
--- a/Gruntfile.js
+++ b/Gruntfile.js
@@ -143,7 +143,7 @@ module.exports = function (grunt) {
            options: {
                configFile: "./.eslintrc.json"
            },
-            configs: ["Gruntfile.js"],
+            configs: ["*.js"],
            core: ["src/core/**/*.{js,mjs}", "!src/core/vendor/**/*", "!src/core/operations/legacy/**/*"],
            web: ["src/web/**/*.{js,mjs}"],
            node: ["src/node/**/*.{js,mjs}"],
--- a/babel.config.js
+++ b/babel.config.js
@@ -0,0 +1,23 @@
+module.exports = function(api) {
+    api.cache.forever();
+
+    return {
+        "presets": [
+            ["@babel/preset-env", {
+                "targets": {
+                    "chrome": 40,
+                    "firefox": 35,
+                    "edge": 14,
+                    "node": "6.5"
+                },
+                "modules": false,
+                "useBuiltIns": "entry"
+            }]
+        ],
+        "plugins": [
+            ["babel-plugin-transform-builtin-extend", {
+                "globals": ["Error"]
+            }]
+        ]
+    };
+};
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "cyberchef",
-  "version": "8.9.2",
+  "version": "8.15.1",
  "description": "The Cyber Swiss Army Knife for encryption, encoding, compression and data analysis.",
  "author": "n1474335 <n1474335@gmail.com>",
  "homepage": "https://gchq.github.io/CyberChef",
--- a/src/core/Utils.mjs
+++ b/src/core/Utils.mjs
@@ -9,6 +9,7 @@ import moment from "moment-timezone";
 import {fromBase64} from "./lib/Base64";
 import {fromHex} from "./lib/Hex";
 import {fromDecimal} from "./lib/Decimal";
+import {fromBinary} from "./lib/Binary";


 /**
@@ -298,7 +299,7 @@ class Utils {
     * Accepts hex, Base64, UTF8 and Latin1 strings.
     *
     * @param {string} str
-     * @param {string} type - One of "Hex", "Decimal", "Base64", "UTF8" or "Latin1"
+     * @param {string} type - One of "Binary", "Hex", "Decimal", "Base64", "UTF8" or "Latin1"
     * @returns {byteArray}
     *
     * @example
@@ -313,6 +314,8 @@ class Utils {
     */
    static convertToByteArray(str, type) {
        switch (type.toLowerCase()) {
+            case "binary":
+                return fromBinary(str);
            case "hex":
                return fromHex(str);
            case "decimal":
@@ -333,7 +336,7 @@ class Utils {
     * Accepts hex, Base64, UTF8 and Latin1 strings.
     *
     * @param {string} str
-     * @param {string} type - One of "Hex", "Decimal", "Base64", "UTF8" or "Latin1"
+     * @param {string} type - One of "Binary", "Hex", "Decimal", "Base64", "UTF8" or "Latin1"
     * @returns {string}
     *
     * @example
@@ -348,6 +351,8 @@ class Utils {
     */
    static convertToByteString(str, type) {
        switch (type.toLowerCase()) {
+            case "binary":
+                return Utils.byteArrayToChars(fromBinary(str));
            case "hex":
                return Utils.byteArrayToChars(fromHex(str));
            case "decimal":
@@ -568,6 +573,10 @@ class Utils {
                cell = "";
                lines.push(line);
                line = [];
+                // Skip next byte if it is also a line delim (e.g. \r\n)
+                if (lineDelims.indexOf(next) >= 0 && next !== b) {
+                    i++;
+                }
            } else {
                cell += b;
            }
--- a/src/core/config/Categories.json
+++ b/src/core/config/Categories.json
@@ -25,6 +25,8 @@
            "From Base32",
            "To Base58",
            "From Base58",
+            "To Base62",
+            "From Base62",
            "To Base85",
            "From Base85",
            "To Base",
@@ -49,12 +51,15 @@
            "Change IP format",
            "Encode text",
            "Decode text",
+            "Text Encoding Brute Force",
            "Swap endianness",
            "To MessagePack",
            "From MessagePack",
            "To Braille",
            "From Braille",
-            "Parse TLV"
+            "Parse TLV",
+            "CSV to JSON",
+            "JSON to CSV"
        ]
    },
    {
@@ -84,6 +89,8 @@
            "Bifid Cipher Decode",
            "Affine Cipher Encode",
            "Affine Cipher Decode",
+            "A1Z26 Cipher Encode",
+            "A1Z26 Cipher Decode",
            "Atbash Cipher",
            "Substitute",
            "Derive PBKDF2 key",
@@ -93,6 +100,8 @@
            "JWT Sign",
            "JWT Verify",
            "JWT Decode",
+            "Citrix CTX1 Encode",
+            "Citrix CTX1 Decode",
            "Pseudo-Random Number Generator"
        ]
    },
@@ -168,6 +177,7 @@
        "ops": [
            "Encode text",
            "Decode text",
+            "Remove Diacritics",
            "Unescape Unicode Characters"
        ]
    },
--- a/src/core/lib/Base64.mjs
+++ b/src/core/lib/Base64.mjs
@@ -126,14 +126,14 @@ export function fromBase64(data, alphabet="A-Za-z0-9+/=", returnType="string", r
 * Base64 alphabets.
 */
 export const ALPHABET_OPTIONS = [
-    {name: "Standard: A-Za-z0-9+/=", value: "A-Za-z0-9+/="},
-    {name: "URL safe: A-Za-z0-9-_", value: "A-Za-z0-9-_"},
+    {name: "Standard (RFC 4648): A-Za-z0-9+/=", value: "A-Za-z0-9+/="},
+    {name: "URL safe (RFC 4648 \u00A75): A-Za-z0-9-_", value: "A-Za-z0-9-_"},
    {name: "Filename safe: A-Za-z0-9+-=", value: "A-Za-z0-9+\\-="},
    {name: "itoa64: ./0-9A-Za-z=", value: "./0-9A-Za-z="},
    {name: "XML: A-Za-z0-9_.", value: "A-Za-z0-9_."},
    {name: "y64: A-Za-z0-9._-", value: "A-Za-z0-9._-"},
    {name: "z64: 0-9a-zA-Z+/=", value: "0-9a-zA-Z+/="},
-    {name: "Radix-64: 0-9A-Za-z+/=", value: "0-9A-Za-z+/="},
+    {name: "Radix-64 (RFC 4880): 0-9A-Za-z+/=", value: "0-9A-Za-z+/="},
    {name: "Uuencoding: [space]-_", value: " -_"},
    {name: "Xxencoding: +-0-9A-Za-z", value: "+\\-0-9A-Za-z"},
    {name: "BinHex: !-,-0-689@A-NP-VX-Z[`a-fh-mp-r", value: "!-,-0-689@A-NP-VX-Z[`a-fh-mp-r"},
--- a/src/core/lib/Binary.mjs
+++ b/src/core/lib/Binary.mjs
@@ -0,0 +1,70 @@
+/**
+ * Binary functions.
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+
+import Utils from "../Utils";
+
+
+/**
+ * Convert a byte array into a binary string.
+ *
+ * @param {Uint8Array|byteArray} data
+ * @param {string} [delim="Space"]
+ * @param {number} [padding=8]
+ * @returns {string}
+ *
+ * @example
+ * // returns "00010000 00100000 00110000"
+ * toBinary([10,20,30]);
+ *
+ * // returns "00010000 00100000 00110000"
+ * toBinary([10,20,30], ":");
+ */
+export function toBinary(data, delim="Space", padding=8) {
+    if (!data) return "";
+
+    delim = Utils.charRep(delim);
+    let output = "";
+
+    for (let i = 0; i < data.length; i++) {
+        output += data[i].toString(2).padStart(padding, "0") + delim;
+    }
+
+    if (delim.length) {
+        return output.slice(0, -delim.length);
+    } else {
+        return output;
+    }
+}
+
+
+/**
+ * Convert a binary string into a byte array.
+ *
+ * @param {string} data
+ * @param {string} [delim]
+ * @param {number} [byteLen=8]
+ * @returns {byteArray}
+ *
+ * @example
+ * // returns [10,20,30]
+ * fromBinary("00010000 00100000 00110000");
+ *
+ * // returns [10,20,30]
+ * fromBinary("00010000:00100000:00110000", "Colon");
+ */
+export function fromBinary(data, delim="Space", byteLen=8) {
+    const delimRegex = Utils.regexRep(delim);
+    data = data.replace(delimRegex, "");
+
+    const output = [];
+    for (let i = 0; i < data.length; i += byteLen) {
+        output.push(parseInt(data.substr(i, byteLen), 2));
+    }
+    return output;
+}
+
--- a/src/core/lib/BitwiseOp.mjs
+++ b/src/core/lib/BitwiseOp.mjs
@@ -116,3 +116,9 @@ export function sub(operand, key) {
    const result = operand - key;
    return (result < 0) ? 256 + result : result;
 }
+
+
+/**
+ * Delimiter options for bitwise operations
+ */
+export const BITWISE_OP_DELIMS = ["Hex", "Decimal", "Binary", "Base64", "UTF8", "Latin1"];
--- a/src/core/lib/Magic.mjs
+++ b/src/core/lib/Magic.mjs
@@ -265,9 +265,10 @@ class Magic {
     *                                      performance)
     * @param {Object[]} [recipeConfig=[]] - The recipe configuration up to this point
     * @param {boolean} [useful=false] - Whether the current recipe should be scored highly
+     * @param {string} [crib=null] - The regex crib provided by the user, for filtering the operation output
     * @returns {Object[]} - A sorted list of the recipes most likely to result in correct decoding
     */
-    async speculativeExecution(depth=0, extLang=false, intensive=false, recipeConfig=[], useful=false) {
+    async speculativeExecution(depth=0, extLang=false, intensive=false, recipeConfig=[], useful=false, crib=null) {
        if (depth < 0) return [];

        // Find any operations that can be run on this data
@@ -284,9 +285,9 @@ class Magic {
            isUTF8: this.isUTF8(),
            entropy: this.calcEntropy(),
            matchingOps: matchingOps,
-            useful: useful
+            useful: useful,
+            matchesCrib: crib && crib.test(this.inputStr)
        });
-
        const prevOp = recipeConfig[recipeConfig.length - 1];

        // Execute each of the matching operations, then recursively call the speculativeExecution()
@@ -305,7 +306,7 @@ class Magic {

            const magic = new Magic(output, this.opPatterns),
                speculativeResults = await magic.speculativeExecution(
-                    depth-1, extLang, intensive, [...recipeConfig, opConfig], op.useful);
+                    depth-1, extLang, intensive, [...recipeConfig, opConfig], op.useful, crib);

            results = results.concat(speculativeResults);
        }));
@@ -317,7 +318,7 @@ class Magic {
            await Promise.all(bfEncodings.map(async enc => {
                const magic = new Magic(enc.data, this.opPatterns),
                    bfResults = await magic.speculativeExecution(
-                        depth-1, extLang, false, [...recipeConfig, enc.conf]);
+                        depth-1, extLang, false, [...recipeConfig, enc.conf], false, crib);

                results = results.concat(bfResults);
            }));
--- a/src/core/operations/A1Z26CipherDecode.mjs
+++ b/src/core/operations/A1Z26CipherDecode.mjs
@@ -0,0 +1,63 @@
+/**
+ * @author Jarmo van Lenthe [github.com/jarmovanlenthe]
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import Utils from "../Utils";
+import {DELIM_OPTIONS} from "../lib/Delim";
+import OperationError from "../errors/OperationError";
+
+/**
+ * A1Z26 Cipher Decode operation
+ */
+class A1Z26CipherDecode extends Operation {
+
+    /**
+     * A1Z26CipherDecode constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "A1Z26 Cipher Decode";
+        this.module = "Ciphers";
+        this.description = "Converts alphabet order numbers into their corresponding  alphabet character.<br><br>e.g. <code>1</code> becomes <code>a</code> and <code>2</code> becomes <code>b</code>.";
+        this.infoURL = "";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Delimiter",
+                type: "option",
+                value: DELIM_OPTIONS
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const delim = Utils.charRep(args[0] || "Space");
+
+        if (input.length === 0) {
+            return [];
+        }
+
+        const bites = input.split(delim);
+        let latin1 = "";
+        for (let i = 0; i < bites.length; i++) {
+            if (bites[i] < 1 || bites[i] > 26) {
+                throw new OperationError("Error: all numbers must be between 1 and 26.");
+            }
+            latin1 += Utils.chr(parseInt(bites[i], 10) + 96);
+        }
+        return latin1;
+    }
+
+}
+
+export default A1Z26CipherDecode;
--- a/src/core/operations/A1Z26CipherEncode.mjs
+++ b/src/core/operations/A1Z26CipherEncode.mjs
@@ -0,0 +1,61 @@
+/**
+ * @author Jarmo van Lenthe [github.com/jarmovanlenthe]
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import Utils from "../Utils";
+import {DELIM_OPTIONS} from "../lib/Delim";
+
+/**
+ * A1Z26 Cipher Encode operation
+ */
+class A1Z26CipherEncode extends Operation {
+
+    /**
+     * A1Z26CipherEncode constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "A1Z26 Cipher Encode";
+        this.module = "Ciphers";
+        this.description = "Converts alphabet characters into their corresponding alphabet order number.<br><br>e.g. <code>a</code> becomes <code>1</code> and <code>b</code> becomes <code>2</code>.<br><br>Non-alphabet characters are dropped.";
+        this.infoURL = "";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Delimiter",
+                type: "option",
+                value: DELIM_OPTIONS
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const delim = Utils.charRep(args[0] || "Space");
+        let output = "";
+
+        const sanitizedinput = input.toLowerCase(),
+            charcode = Utils.strToCharcode(sanitizedinput);
+
+        for (let i = 0; i < charcode.length; i++) {
+            const ordinal = charcode[i] - 96;
+
+            if (ordinal > 0 && ordinal <= 26) {
+                output += ordinal.toString(10) + delim;
+            }
+        }
+        return output.slice(0, -delim.length);
+    }
+
+}
+
+export default A1Z26CipherEncode;
--- a/src/core/operations/ADD.mjs
+++ b/src/core/operations/ADD.mjs
@@ -6,7 +6,7 @@

 import Operation from "../Operation";
 import Utils from "../Utils";
-import { bitOp, add } from "../lib/BitwiseOp";
+import { bitOp, add, BITWISE_OP_DELIMS } from "../lib/BitwiseOp";

 /**
 * ADD operation
@@ -30,7 +30,7 @@ class ADD extends Operation {
                "name": "Key",
                "type": "toggleString",
                "value": "",
-                "toggleValues": ["Hex", "Decimal", "Base64", "UTF8", "Latin1"]
+                "toggleValues": BITWISE_OP_DELIMS
            }
        ];
    }
--- a/src/core/operations/AND.mjs
+++ b/src/core/operations/AND.mjs
@@ -6,7 +6,7 @@

 import Operation from "../Operation";
 import Utils from "../Utils";
-import { bitOp, and } from "../lib/BitwiseOp";
+import { bitOp, and, BITWISE_OP_DELIMS } from "../lib/BitwiseOp";

 /**
 * AND operation
@@ -30,7 +30,7 @@ class AND extends Operation {
                "name": "Key",
                "type": "toggleString",
                "value": "",
-                "toggleValues": ["Hex", "Decimal", "Base64", "UTF8", "Latin1"]
+                "toggleValues": BITWISE_OP_DELIMS
            }
        ];
    }
--- a/src/core/operations/CSVToJSON.mjs
+++ b/src/core/operations/CSVToJSON.mjs
@@ -0,0 +1,80 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import Utils from "../Utils";
+
+/**
+ * CSV to JSON operation
+ */
+class CSVToJSON extends Operation {
+
+    /**
+     * CSVToJSON constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "CSV to JSON";
+        this.module = "Default";
+        this.description = "Converts a CSV file to JSON format.";
+        this.infoURL = "https://wikipedia.org/wiki/Comma-separated_values";
+        this.inputType = "string";
+        this.outputType = "JSON";
+        this.args = [
+            {
+                name: "Cell delimiters",
+                type: "binaryShortString",
+                value: ","
+            },
+            {
+                name: "Row delimiters",
+                type: "binaryShortString",
+                value: "\\r\\n"
+            },
+            {
+                name: "Format",
+                type: "option",
+                value: ["Array of dictionaries", "Array of arrays"]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {JSON}
+     */
+    run(input, args) {
+        const [cellDelims, rowDelims, format] = args;
+        let json, header;
+
+        try {
+            json = Utils.parseCSV(input, cellDelims.split(""), rowDelims.split(""));
+        } catch (err) {
+            throw new OperationError("Unable to parse CSV: " + err);
+        }
+
+        switch (format) {
+            case "Array of dictionaries":
+                header = json[0];
+                return json.slice(1).map(row => {
+                    const obj = {};
+                    header.forEach((h, i) => {
+                        obj[h] = row[i];
+                    });
+                    return obj;
+                });
+            case "Array of arrays":
+            default:
+                return json;
+        }
+    }
+
+}
+
+export default CSVToJSON;
--- a/src/core/operations/CitrixCTX1Decode.mjs
+++ b/src/core/operations/CitrixCTX1Decode.mjs
@@ -0,0 +1,58 @@
+/**
+ * @author bwhitn [brian.m.whitney@gmail.com]
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import cptable from "../vendor/js-codepage/cptable.js";
+
+/**
+ * Citrix CTX1 Decode operation
+ */
+class CitrixCTX1Decode extends Operation {
+
+    /**
+     * CitrixCTX1Decode constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Citrix CTX1 Decode";
+        this.module = "Encodings";
+        this.description = "Decodes strings in a Citrix CTX1 password format to plaintext.";
+        this.infoURL = "https://www.reddit.com/r/AskNetsec/comments/1s3r6y/citrix_ctx1_hash_decoding/";
+        this.inputType = "byteArray";
+        this.outputType = "string";
+        this.args = [];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        if (input.length % 4 !== 0) {
+            throw new OperationError("Incorrect hash length");
+        }
+        const revinput = input.reverse();
+        const result = [];
+        let temp = 0;
+        for (let i = 0; i < revinput.length; i += 2) {
+            if (i + 2 >= revinput.length) {
+                temp = 0;
+            } else {
+                temp = ((revinput[i + 2] - 0x41) & 0xf) ^ (((revinput[i + 3]- 0x41) << 4) & 0xf0);
+            }
+            temp = (((revinput[i] - 0x41) & 0xf) ^ (((revinput[i + 1] - 0x41) << 4) & 0xf0)) ^ 0xa5 ^ temp;
+            result.push(temp);
+        }
+        // Decodes a utf-16le string
+        return cptable.utils.decode(1200, result.reverse());
+    }
+
+}
+
+export default CitrixCTX1Decode;
--- a/src/core/operations/CitrixCTX1Encode.mjs
+++ b/src/core/operations/CitrixCTX1Encode.mjs
@@ -0,0 +1,50 @@
+/**
+ * @author bwhitn [brian.m.whitney@gmail.com]
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import cptable from "../vendor/js-codepage/cptable.js";
+
+/**
+ * Citrix CTX1 Encode operation
+ */
+class CitrixCTX1Encode extends Operation {
+
+    /**
+     * CitrixCTX1Encode constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Citrix CTX1 Encode";
+        this.module = "Encodings";
+        this.description = "Encodes strings to Citrix CTX1 password format.";
+        this.infoURL = "https://www.reddit.com/r/AskNetsec/comments/1s3r6y/citrix_ctx1_hash_decoding/";
+        this.inputType = "string";
+        this.outputType = "byteArray";
+        this.args = [];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    run(input, args) {
+        const utf16pass = Array.from(cptable.utils.encode(1200, input));
+        const result = [];
+        let temp = 0;
+        for (let i = 0; i < utf16pass.length; i++) {
+            temp = utf16pass[i] ^ 0xa5 ^ temp;
+            result.push(((temp >>> 4) & 0xf) + 0x41);
+            result.push((temp & 0xf) + 0x41);
+        }
+
+        return result;
+    }
+
+}
+
+export default CitrixCTX1Encode;
--- a/src/core/operations/FromBase62.mjs
+++ b/src/core/operations/FromBase62.mjs
@@ -0,0 +1,58 @@
+/**
+ * @author tcode2k16 [tcode2k16@gmail.com]
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import BigNumber from "bignumber.js";
+import Utils from "../Utils";
+
+
+/**
+ * From Base62 operation
+ */
+class FromBase62 extends Operation {
+
+    /**
+     * FromBase62 constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "From Base62";
+        this.module = "Default";
+        this.description = "Base62 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers. The high number base results in shorter strings than with the decimal or hexadecimal system.";
+        this.infoURL = "https://wikipedia.org/wiki/List_of_numeral_systems";
+        this.inputType = "string";
+        this.outputType = "byteArray";
+        this.args = [
+            {
+                name: "Alphabet",
+                type: "string",
+                value: "0-9A-Za-z"
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    run(input, args) {
+        if (input.length < 1) return [];
+        const ALPHABET = Utils.expandAlphRange(args[0]).join("");
+        const BN = BigNumber.clone({ ALPHABET });
+
+        const re = new RegExp("[^" + ALPHABET.replace(/[[\]\\\-^$]/g, "\\$&") + "]", "g");
+        input = input.replace(re, "");
+
+        const number = new BN(input, 62);
+
+        return Utils.convertToByteArray(number.toString(16), "Hex");
+    }
+
+}
+
+export default FromBase62;
--- a/src/core/operations/FromBase64.mjs
+++ b/src/core/operations/FromBase64.mjs
@@ -38,44 +38,44 @@ class FromBase64 extends Operation {
        ];
        this.patterns = [
            {
-                match: "^(?:[A-Z\\d+/]{4})+(?:[A-Z\\d+/]{2}==|[A-Z\\d+/]{3}=)?$",
+                match: "^\\s*(?:[A-Z\\d+/]{4})+(?:[A-Z\\d+/]{2}==|[A-Z\\d+/]{3}=)?\\s*$",
                flags: "i",
-                args: ["A-Za-z0-9+/=", false]
+                args: ["A-Za-z0-9+/=", true]
            },
            {
-                match: "^[A-Z\\d\\-_]{20,}$",
+                match: "^\\s*[A-Z\\d\\-_]{20,}\\s*$",
                flags: "i",
-                args: ["A-Za-z0-9-_", false]
+                args: ["A-Za-z0-9-_", true]
            },
            {
-                match: "^(?:[A-Z\\d+\\-]{4}){5,}(?:[A-Z\\d+\\-]{2}==|[A-Z\\d+\\-]{3}=)?$",
+                match: "^\\s*(?:[A-Z\\d+\\-]{4}){5,}(?:[A-Z\\d+\\-]{2}==|[A-Z\\d+\\-]{3}=)?\\s*$",
                flags: "i",
-                args: ["A-Za-z0-9+\\-=", false]
+                args: ["A-Za-z0-9+\\-=", true]
            },
            {
-                match: "^(?:[A-Z\\d./]{4}){5,}(?:[A-Z\\d./]{2}==|[A-Z\\d./]{3}=)?$",
+                match: "^\\s*(?:[A-Z\\d./]{4}){5,}(?:[A-Z\\d./]{2}==|[A-Z\\d./]{3}=)?\\s*$",
                flags: "i",
-                args: ["./0-9A-Za-z=", false]
+                args: ["./0-9A-Za-z=", true]
            },
            {
-                match: "^[A-Z\\d_.]{20,}$",
+                match: "^\\s*[A-Z\\d_.]{20,}\\s*$",
                flags: "i",
-                args: ["A-Za-z0-9_.", false]
+                args: ["A-Za-z0-9_.", true]
            },
            {
-                match: "^(?:[A-Z\\d._]{4}){5,}(?:[A-Z\\d._]{2}--|[A-Z\\d._]{3}-)?$",
+                match: "^\\s*(?:[A-Z\\d._]{4}){5,}(?:[A-Z\\d._]{2}--|[A-Z\\d._]{3}-)?\\s*$",
                flags: "i",
-                args: ["A-Za-z0-9._-", false]
+                args: ["A-Za-z0-9._-", true]
            },
            {
-                match: "^(?:[A-Z\\d+/]{4}){5,}(?:[A-Z\\d+/]{2}==|[A-Z\\d+/]{3}=)?$",
+                match: "^\\s*(?:[A-Z\\d+/]{4}){5,}(?:[A-Z\\d+/]{2}==|[A-Z\\d+/]{3}=)?\\s*$",
                flags: "i",
-                args: ["0-9a-zA-Z+/=", false]
+                args: ["0-9a-zA-Z+/=", true]
            },
            {
-                match: "^(?:[A-Z\\d+/]{4}){5,}(?:[A-Z\\d+/]{2}==|[A-Z\\d+/]{3}=)?$",
+                match: "^\\s*(?:[A-Z\\d+/]{4}){5,}(?:[A-Z\\d+/]{2}==|[A-Z\\d+/]{3}=)?\\s*$",
                flags: "i",
-                args: ["0-9A-Za-z+/=", false]
+                args: ["0-9A-Za-z+/=", true]
            },
            {
                match: "^[ !\"#$%&'()*+,\\-./\\d:;<=>?@A-Z[\\\\\\]^_]{20,}$",
@@ -83,24 +83,24 @@ class FromBase64 extends Operation {
                args: [" -_", false]
            },
            {
-                match: "^[A-Z\\d+\\-]{20,}$",
+                match: "^\\s*[A-Z\\d+\\-]{20,}\\s*$",
                flags: "i",
-                args: ["+\\-0-9A-Za-z", false]
+                args: ["+\\-0-9A-Za-z", true]
            },
            {
-                match: "^[!\"#$%&'()*+,\\-0-689@A-NP-VX-Z[`a-fh-mp-r]{20,}$",
+                match: "^\\s*[!\"#$%&'()*+,\\-0-689@A-NP-VX-Z[`a-fh-mp-r]{20,}\\s*$",
                flags: "",
-                args: ["!-,-0-689@A-NP-VX-Z[`a-fh-mp-r", false]
+                args: ["!-,-0-689@A-NP-VX-Z[`a-fh-mp-r", true]
            },
            {
-                match: "^(?:[N-ZA-M\\d+/]{4}){5,}(?:[N-ZA-M\\d+/]{2}==|[N-ZA-M\\d+/]{3}=)?$",
+                match: "^\\s*(?:[N-ZA-M\\d+/]{4}){5,}(?:[N-ZA-M\\d+/]{2}==|[N-ZA-M\\d+/]{3}=)?\\s*$",
                flags: "i",
-                args: ["N-ZA-Mn-za-m0-9+/=", false]
+                args: ["N-ZA-Mn-za-m0-9+/=", true]
            },
            {
-                match: "^[A-Z\\d./]{20,}$",
+                match: "^\\s*[A-Z\\d./]{20,}\\s*$",
                flags: "i",
-                args: ["./0-9A-Za-z", false]
+                args: ["./0-9A-Za-z", true]
            },
        ];
    }
--- a/src/core/operations/FromBinary.mjs
+++ b/src/core/operations/FromBinary.mjs
@@ -7,6 +7,7 @@
 import Operation from "../Operation";
 import Utils from "../Utils";
 import {BIN_DELIM_OPTIONS} from "../lib/Delim";
+import {fromBinary} from "../lib/Binary";

 /**
 * From Binary operation
@@ -77,15 +78,7 @@ class FromBinary extends Operation {
     * @returns {byteArray}
     */
    run(input, args) {
-        const delimRegex = Utils.regexRep(args[0] || "Space");
-        input = input.replace(delimRegex, "");
-
-        const output = [];
-        const byteLen = 8;
-        for (let i = 0; i < input.length; i += byteLen) {
-            output.push(parseInt(input.substr(i, byteLen), 2));
-        }
-        return output;
+        return fromBinary(input, args[0]);
    }

    /**
--- a/src/core/operations/FromQuotedPrintable.mjs
+++ b/src/core/operations/FromQuotedPrintable.mjs
@@ -30,7 +30,7 @@ class FromQuotedPrintable extends Operation {
        this.args = [];
        this.patterns = [
            {
-                match: "^[\\x21-\\x3d\\x3f-\\x7e \\t]*(?:=[\\da-f]{2}|=\\r?\\n)(?:[\\x21-\\x3d\\x3f-\\x7e \\t]|=[\\da-f]{2}|=\\r?\\n)*$",
+                match: "^[\\x21-\\x3d\\x3f-\\x7e \\t]{0,76}(?:=[\\da-f]{2}|=\\r?\\n)(?:[\\x21-\\x3d\\x3f-\\x7e \\t]|=[\\da-f]{2}|=\\r?\\n)*$",
                flags: "i",
                args: []
            },
--- a/src/core/operations/HMAC.mjs
+++ b/src/core/operations/HMAC.mjs
@@ -72,7 +72,7 @@ class HMAC extends Operation {
            msg = Utils.arrayBufferToStr(input, false),
            hasher = CryptoApi.getHasher(hashFunc);

-        const mac = CryptoApi.getHmac(CryptoApi.encoder.fromUtf(key), hasher);
+        const mac = CryptoApi.getHmac(key, hasher);
        mac.update(msg);
        return CryptoApi.encoder.toHex(mac.finalize());
    }
--- a/src/core/operations/JSONBeautify.mjs
+++ b/src/core/operations/JSONBeautify.mjs
@@ -1,5 +1,6 @@
 /**
 * @author n1474335 [n1474335@gmail.com]
+ * @author Phillip Nordwall [phillip.nordwall@gmail.com]
 * @copyright Crown Copyright 2016
 * @license Apache-2.0
 */
@@ -27,7 +28,12 @@ class JSONBeautify extends Operation {
            {
                "name": "Indent string",
                "type": "binaryShortString",
-                "value": "\\t"
+                "value": "    "
+            },
+            {
+                "name": "Sort Object Keys",
+                "type": "boolean",
+                "value": false
            }
        ];
    }
@@ -38,11 +44,35 @@ class JSONBeautify extends Operation {
     * @returns {string}
     */
    run(input, args) {
-        const indentStr = args[0];
+        const [indentStr, sortBool] = args;
+
        if (!input) return "";
+        if (sortBool) {
+            input = JSON.stringify(JSONBeautify._sort(JSON.parse(input)));
+        }
        return vkbeautify.json(input, indentStr);
    }

+
+    /**
+     * Sort JSON representation of an object
+     *
+     * @author Phillip Nordwall [phillip.nordwall@gmail.com]
+     * @private
+     * @param {object} o
+     * @returns {object}
+     */
+    static _sort(o) {
+        if (Array.isArray(o)) {
+            return o.map(JSONBeautify._sort);
+        } else if ("[object Object]" === Object.prototype.toString.call(o)) {
+            return Object.keys(o).sort().reduce(function(a, k) {
+                a[k] = JSONBeautify._sort(o[k]);
+                return a;
+            }, {});
+        }
+        return o;
+    }
 }

 export default JSONBeautify;
--- a/src/core/operations/JSONToCSV.mjs
+++ b/src/core/operations/JSONToCSV.mjs
@@ -0,0 +1,111 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+
+/**
+ * JSON to CSV operation
+ */
+class JSONToCSV extends Operation {
+
+    /**
+     * JSONToCSV constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "JSON to CSV";
+        this.module = "Default";
+        this.description = "Converts JSON data to a CSV based on the definition in RFC 4180.";
+        this.infoURL = "https://wikipedia.org/wiki/Comma-separated_values";
+        this.inputType = "JSON";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Cell delimiter",
+                type: "binaryShortString",
+                value: ","
+            },
+            {
+                name: "Row delimiter",
+                type: "binaryShortString",
+                value: "\\r\\n"
+            }
+        ];
+    }
+
+    /**
+     * @param {JSON} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [cellDelim, rowDelim] = args;
+
+        // Record values so they don't have to be passed to other functions explicitly
+        this.cellDelim = cellDelim;
+        this.rowDelim = rowDelim;
+        const self = this;
+
+        try {
+            // If the JSON is an array of arrays, this is easy
+            if (input[0] instanceof Array) {
+                return input
+                    .map(row => row
+                        .map(self.escapeCellContents.bind(self))
+                        .join(cellDelim)
+                    )
+                    .join(rowDelim) +
+                    rowDelim;
+            }
+
+            // If it's an array of dictionaries...
+            const header = Object.keys(input[0]);
+            return header
+                .map(self.escapeCellContents.bind(self))
+                .join(cellDelim) +
+                rowDelim +
+                input
+                    .map(row => header
+                        .map(h => row[h])
+                        .map(self.escapeCellContents.bind(self))
+                        .join(cellDelim)
+                    )
+                    .join(rowDelim) +
+                rowDelim;
+        } catch (err) {
+            throw new OperationError("Unable to parse JSON to CSV: " + err.toString());
+        }
+    }
+
+    /**
+     * Correctly escapes a cell's contents based on the cell and row delimiters.
+     *
+     * @param {string} data
+     * @returns {string}
+     */
+    escapeCellContents(data) {
+        // Double quotes should be doubled up
+        data = data.replace(/"/g, '""');
+
+        // If the cell contains a cell or row delimiter or a double quote, it mut be enclosed in double quotes
+        if (
+            data.indexOf(this.cellDelim) >= 0 ||
+            data.indexOf(this.rowDelim) >= 0 ||
+            data.indexOf("\n") >= 0 ||
+            data.indexOf("\r") >= 0 ||
+            data.indexOf('"') >= 0
+        ) {
+            data = `"${data}"`;
+        }
+
+        return data;
+    }
+
+}
+
+export default JSONToCSV;
--- a/src/core/operations/Magic.mjs
+++ b/src/core/operations/Magic.mjs
@@ -23,7 +23,7 @@ class Magic extends Operation {
        this.name = "Magic";
        this.flowControl = true;
        this.module = "Default";
-        this.description = "The Magic operation attempts to detect various properties of the input data and suggests which operations could help to make more sense of it.<br><br><b>Options</b><br><u>Depth:</u> If an operation appears to match the data, it will be run and the result will be analysed further. This argument controls the maximum number of levels of recursion.<br><br><u>Intensive mode:</u> When this is turned on, various operations like XOR, bit rotates, and character encodings are brute-forced to attempt to detect valid data underneath. To improve performance, only the first 100 bytes of the data is brute-forced.<br><br><u>Extensive language support:</u> At each stage, the relative byte frequencies of the data will be compared to average frequencies for a number of languages. The default set consists of ~40 of the most commonly used languages on the Internet. The extensive list consists of 284 languages and can result in many languages matching the data if their byte frequencies are similar.";
+        this.description = "The Magic operation attempts to detect various properties of the input data and suggests which operations could help to make more sense of it.<br><br><b>Options</b><br><u>Depth:</u> If an operation appears to match the data, it will be run and the result will be analysed further. This argument controls the maximum number of levels of recursion.<br><br><u>Intensive mode:</u> When this is turned on, various operations like XOR, bit rotates, and character encodings are brute-forced to attempt to detect valid data underneath. To improve performance, only the first 100 bytes of the data is brute-forced.<br><br><u>Extensive language support:</u> At each stage, the relative byte frequencies of the data will be compared to average frequencies for a number of languages. The default set consists of ~40 of the most commonly used languages on the Internet. The extensive list consists of 284 languages and can result in many languages matching the data if their byte frequencies are similar.<br><br>Optionally enter a regular expression to match a string you expect to find to filter results (crib).";
        this.infoURL = "https://github.com/gchq/CyberChef/wiki/Automatic-detection-of-encoded-data-using-CyberChef-Magic";
        this.inputType = "ArrayBuffer";
        this.outputType = "JSON";
@@ -43,6 +43,11 @@ class Magic extends Operation {
                "name": "Extensive language support",
                "type": "boolean",
                "value": false
+            },
+            {
+                "name": "Crib (known plaintext string or regex)",
+                "type": "string",
+                "value": ""
            }
        ];
    }
@@ -56,10 +61,16 @@ class Magic extends Operation {
     */
    async run(state) {
        const ings = state.opList[state.progress].ingValues,
-            [depth, intensive, extLang] = ings,
+            [depth, intensive, extLang, crib] = ings,
            dish = state.dish,
            magic = new MagicLib(await dish.get(Dish.ARRAY_BUFFER)),
-            options = await magic.speculativeExecution(depth, extLang, intensive);
+            cribRegex = (crib && crib.length) ? new RegExp(crib, "i") : null;
+        let options = await magic.speculativeExecution(depth, extLang, intensive, [], false, cribRegex);
+
+        // Filter down to results which matched the crib
+        if (cribRegex) {
+            options = options.filter(option => option.matchesCrib);
+        }

        // Record the current state for use when presenting
        this.state = state;
--- a/src/core/operations/OR.mjs
+++ b/src/core/operations/OR.mjs
@@ -6,7 +6,7 @@

 import Operation from "../Operation";
 import Utils from "../Utils";
-import { bitOp, or } from "../lib/BitwiseOp";
+import { bitOp, or, BITWISE_OP_DELIMS } from "../lib/BitwiseOp";

 /**
 * OR operation
@@ -30,7 +30,7 @@ class OR extends Operation {
                "name": "Key",
                "type": "toggleString",
                "value": "",
-                "toggleValues": ["Hex", "Decimal", "Base64", "UTF8", "Latin1"]
+                "toggleValues": BITWISE_OP_DELIMS
            }
        ];
    }
--- a/src/core/operations/RemoveDiacritics.mjs
+++ b/src/core/operations/RemoveDiacritics.mjs
@@ -0,0 +1,41 @@
+/**
+ * @author Klaxon [klaxon@veyr.com]
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+
+/**
+ * Remove Diacritics operation
+ */
+class RemoveDiacritics extends Operation {
+
+    /**
+     * RemoveDiacritics constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Remove Diacritics";
+        this.module = "Default";
+        this.description = "Replaces accented characters with their latin character equivalent.";
+        this.infoURL = "https://wikipedia.org/wiki/Diacritic";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        // reference: https://stackoverflow.com/questions/990904/remove-accents-diacritics-in-a-string-in-javascript/37511463
+        return input.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+    }
+
+}
+
+export default RemoveDiacritics;
--- a/src/core/operations/SUB.mjs
+++ b/src/core/operations/SUB.mjs
@@ -6,7 +6,7 @@

 import Operation from "../Operation";
 import Utils from "../Utils";
-import { bitOp, sub } from "../lib/BitwiseOp";
+import { bitOp, sub, BITWISE_OP_DELIMS } from "../lib/BitwiseOp";

 /**
 * SUB operation
@@ -30,7 +30,7 @@ class SUB extends Operation {
                "name": "Key",
                "type": "toggleString",
                "value": "",
-                "toggleValues": ["Hex", "Decimal", "Base64", "UTF8", "Latin1"]
+                "toggleValues": BITWISE_OP_DELIMS
            }
        ];
    }
--- a/src/core/operations/Sort.mjs
+++ b/src/core/operations/Sort.mjs
@@ -38,7 +38,7 @@ class Sort extends Operation {
            {
                "name": "Order",
                "type": "option",
-                "value": ["Alphabetical (case sensitive)", "Alphabetical (case insensitive)", "IP address", "Numeric"]
+                "value": ["Alphabetical (case sensitive)", "Alphabetical (case insensitive)", "IP address", "Numeric", "Numeric (hexadecimal)"]
            }
        ];
    }
@@ -62,6 +62,8 @@ class Sort extends Operation {
            sorted = sorted.sort(Sort._ipSort);
        } else if (order === "Numeric") {
            sorted = sorted.sort(Sort._numericSort);
+        } else if (order === "Numeric (hexadecimal)") {
+            sorted = sorted.sort(Sort._hexadecimalSort);
        }

        if (sortReverse) sorted.reverse();
@@ -131,6 +133,44 @@ class Sort extends Operation {
        return a.localeCompare(b);
    }

+    /**
+     * Comparison operation for sorting of hexadecimal values.
+     *
+     * @author Chris van Marle
+     * @private
+     * @param {string} a
+     * @param {string} b
+     * @returns {number}
+     */
+    static _hexadecimalSort(a, b) {
+        let a_ = a.split(/([^\da-f]+)/i),
+            b_ = b.split(/([^\da-f]+)/i);
+
+        a_ = a_.map(v => {
+            const t = parseInt(v, 16);
+            return isNaN(t) ? v : t;
+        });
+
+        b_ = b_.map(v => {
+            const t = parseInt(v, 16);
+            return isNaN(t) ? v : t;
+        });
+
+        for (let i = 0; i < a_.length && i < b.length; ++i) {
+            if (isNaN(a_[i]) && !isNaN(b_[i])) return 1; // Numbers after non-numbers
+            if (!isNaN(a_[i]) && isNaN(b_[i])) return -1;
+            if (isNaN(a_[i]) && isNaN(b_[i])) {
+                const ret = a_[i].localeCompare(b_[i]); // Compare strings
+                if (ret !== 0) return ret;
+            }
+            if (!isNaN(a_[i]) && !isNaN(a_[i])) { // Compare numbers
+                if (a_[i] - b_[i] !== 0) return a_[i] - b_[i];
+            }
+        }
+
+        return a.localeCompare(b);
+    }
+
 }

 export default Sort;
--- a/src/core/operations/Substitute.mjs
+++ b/src/core/operations/Substitute.mjs
@@ -20,7 +20,7 @@ class Substitute extends Operation {

        this.name = "Substitute";
        this.module = "Default";
-        this.description = "A substitution cipher allowing you to specify bytes to replace with other byte values. This can be used to create Caesar ciphers but is more powerful as any byte value can be substituted, not just letters, and the substitution values need not be in order.<br><br>Enter the bytes you want to replace in the Plaintext field and the bytes to replace them with in the Ciphertext field.<br><br>Non-printable bytes can be specified using string escape notation. For example, a line feed character can be written as either <code>\n</code> or <code>\x0a</code>.<br><br>Byte ranges can be specified using a hyphen. For example, the sequence <code>0123456789</code> can be written as <code>0-9</code>.";
+        this.description = "A substitution cipher allowing you to specify bytes to replace with other byte values. This can be used to create Caesar ciphers but is more powerful as any byte value can be substituted, not just letters, and the substitution values need not be in order.<br><br>Enter the bytes you want to replace in the Plaintext field and the bytes to replace them with in the Ciphertext field.<br><br>Non-printable bytes can be specified using string escape notation. For example, a line feed character can be written as either <code>\\n</code> or <code>\\x0a</code>.<br><br>Byte ranges can be specified using a hyphen. For example, the sequence <code>0123456789</code> can be written as <code>0-9</code>.<br><br>Note that blackslash characters are used to escape special characters, so will need to be escaped themselves if you want to use them on their own (e.g.<code>\\\\</code>).";
        this.infoURL = "https://wikipedia.org/wiki/Substitution_cipher";
        this.inputType = "string";
        this.outputType = "string";
--- a/src/core/operations/TextEncodingBruteForce.mjs
+++ b/src/core/operations/TextEncodingBruteForce.mjs
@@ -0,0 +1,92 @@
+/**
+ * @author Cynser
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import Utils from "../Utils";
+import cptable from "../vendor/js-codepage/cptable.js";
+import {IO_FORMAT} from "../lib/ChrEnc";
+
+/**
+ * Text Encoding Brute Force operation
+ */
+class TextEncodingBruteForce extends Operation {
+
+    /**
+     * TextEncodingBruteForce constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Text Encoding Brute Force";
+        this.module = "CharEnc";
+        this.description = [
+            "Enumerates all supported text encodings for the input, allowing you to quickly spot the correct one.",
+            "<br><br>",
+            "Supported charsets are:",
+            "<ul>",
+            Object.keys(IO_FORMAT).map(e => `<li>${e}</li>`).join("\n"),
+            "</ul>"
+        ].join("\n");
+        this.infoURL = "https://wikipedia.org/wiki/Character_encoding";
+        this.inputType = "string";
+        this.outputType = "json";
+        this.presentType = "html";
+        this.args = [
+            {
+                name: "Mode",
+                type: "option",
+                value: ["Encode", "Decode"]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {json}
+     */
+    run(input, args) {
+        const output = {},
+            charsets = Object.keys(IO_FORMAT),
+            mode = args[0];
+
+        charsets.forEach(charset => {
+            try {
+                if (mode === "Decode") {
+                    output[charset] = cptable.utils.decode(IO_FORMAT[charset], input);
+                } else {
+                    output[charset] = Utils.arrayBufferToStr(cptable.utils.encode(IO_FORMAT[charset], input));
+                }
+            } catch (err) {
+                output[charset] = "Could not decode.";
+            }
+        });
+
+        return output;
+    }
+
+    /**
+     * Displays the encodings in an HTML table for web apps.
+     *
+     * @param {Object[]} encodings
+     * @returns {html}
+     */
+    present(encodings) {
+        let table = "<table class='table table-hover table-sm table-bordered table-nonfluid'><tr><th>Encoding</th><th>Value</th></tr>";
+
+        for (const enc in encodings) {
+            const value = Utils.printable(encodings[enc], true);
+            table += `<tr><td>${enc}</td><td>${value}</td></tr>`;
+        }
+
+        table += "<table>";
+        return table;
+    }
+
+}
+
+export default TextEncodingBruteForce;
--- a/src/core/operations/ToBase62.mjs
+++ b/src/core/operations/ToBase62.mjs
@@ -0,0 +1,58 @@
+/**
+ * @author tcode2k16 [tcode2k16@gmail.com]
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import BigNumber from "bignumber.js";
+import Utils from "../Utils";
+import {toHexFast} from "../lib/Hex";
+
+/**
+ * To Base62 operation
+ */
+class ToBase62 extends Operation {
+
+    /**
+     * ToBase62 constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "To Base62";
+        this.module = "Default";
+        this.description = "Base62 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers. The high number base results in shorter strings than with the decimal or hexadecimal system.";
+        this.infoURL = "https://wikipedia.org/wiki/List_of_numeral_systems";
+        this.inputType = "byteArray";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Alphabet",
+                type: "string",
+                value: "0-9A-Za-z"
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        if (input.length < 1) return "";
+
+        const ALPHABET = Utils.expandAlphRange(args[0]).join("");
+        const BN = BigNumber.clone({ ALPHABET });
+
+        input = toHexFast(input).toUpperCase();
+
+        const number = new BN(input, 16);
+
+        return number.toString(62);
+    }
+
+}
+
+export default ToBase62;
--- a/src/core/operations/ToBinary.mjs
+++ b/src/core/operations/ToBinary.mjs
@@ -7,6 +7,7 @@
 import Operation from "../Operation";
 import Utils from "../Utils";
 import {BIN_DELIM_OPTIONS} from "../lib/Delim";
+import {toBinary} from "../lib/Binary";

 /**
 * To Binary operation
@@ -40,19 +41,7 @@ class ToBinary extends Operation {
     * @returns {string}
     */
    run(input, args) {
-        const delim = Utils.charRep(args[0] || "Space"),
-            padding = 8;
-        let output = "";
-
-        for (let i = 0; i < input.length; i++) {
-            output += input[i].toString(2).padStart(padding, "0") + delim;
-        }
-
-        if (delim.length) {
-            return output.slice(0, -delim.length);
-        } else {
-            return output;
-        }
+        return toBinary(input, args[0]);
    }

    /**
--- a/src/core/operations/ToTable.mjs
+++ b/src/core/operations/ToTable.mjs
@@ -33,7 +33,7 @@ class ToTable extends Operation {
            {
                "name": "Row delimiters",
                "type": "binaryShortString",
-                "value": "\\n\\r"
+                "value": "\\r\\n"
            },
            {
                "name": "Make first row header",
--- a/src/core/operations/XOR.mjs
+++ b/src/core/operations/XOR.mjs
@@ -6,7 +6,7 @@

 import Operation from "../Operation";
 import Utils from "../Utils";
-import { bitOp, xor } from "../lib/BitwiseOp";
+import { bitOp, xor, BITWISE_OP_DELIMS } from "../lib/BitwiseOp";

 /**
 * XOR operation
@@ -30,7 +30,7 @@ class XOR extends Operation {
                "name": "Key",
                "type": "toggleString",
                "value": "",
-                "toggleValues": ["Hex", "Decimal", "Base64", "UTF8", "Latin1"]
+                "toggleValues": BITWISE_OP_DELIMS
            },
            {
                "name": "Scheme",
--- a/test/index.mjs
+++ b/test/index.mjs
@@ -28,6 +28,7 @@ import "./tests/operations/BCD";
 import "./tests/operations/BSON";
 import "./tests/operations/Base58";
 import "./tests/operations/Base64";
+import "./tests/operations/Base62";
 import "./tests/operations/BitwiseOp";
 import "./tests/operations/ByteRepr";
 import "./tests/operations/CartesianProduct";
@@ -39,6 +40,7 @@ import "./tests/operations/Comment";
 import "./tests/operations/Compress";
 import "./tests/operations/ConditionalJump";
 import "./tests/operations/Crypt";
+import "./tests/operations/CSV";
 import "./tests/operations/DateTime";
 import "./tests/operations/ExtractEmailAddresses";
 import "./tests/operations/Fork";
@@ -49,6 +51,8 @@ import "./tests/operations/HaversineDistance";
 import "./tests/operations/Hexdump";
 import "./tests/operations/Image";
 import "./tests/operations/Jump";
+import "./tests/operations/JSONBeautify";
+import "./tests/operations/JSONMinify";
 import "./tests/operations/JWTDecode";
 import "./tests/operations/JWTSign";
 import "./tests/operations/JWTVerify";
@@ -63,6 +67,7 @@ import "./tests/operations/ParseIPRange";
 import "./tests/operations/PowerSet";
 import "./tests/operations/Regex";
 import "./tests/operations/Register";
+import "./tests/operations/RemoveDiacritics";
 import "./tests/operations/Rotate";
 import "./tests/operations/SeqUtils";
 import "./tests/operations/SetDifference";
@@ -70,6 +75,7 @@ import "./tests/operations/SetIntersection";
 import "./tests/operations/SetUnion";
 import "./tests/operations/StrUtils";
 import "./tests/operations/SymmetricDifference";
+import "./tests/operations/TextEncodingBruteForce";
 import "./tests/operations/ToGeohash.mjs";
 import "./tests/operations/TranslateDateTimeFormat";
 import "./tests/operations/Magic";
@@ -125,12 +131,12 @@ function handleTestResult(testResult) {


 /**
- * Fail if the process takes longer than 10 seconds.
+ * Fail if the process takes longer than 60 seconds.
 */
 setTimeout(function() {
-    console.log("Tests took longer than 10 seconds to run, returning.");
+    console.log("Tests took longer than 60 seconds to run, returning.");
    process.exit(1);
-}, 10 * 1000);
+}, 60 * 1000);


 TestRegister.runTests()
--- a/test/tests/operations/Base62.mjs
+++ b/test/tests/operations/Base62.mjs
@@ -0,0 +1,79 @@
+/**
+ * Base62 tests.
+ *
+ * @author tcode2k16 [tcode2k16@gmail.com]
+ *
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+
+import TestRegister from "../../TestRegister";
+
+TestRegister.addTests([
+    {
+        name: "To Base62: nothing",
+        input: "",
+        expectedOutput: "",
+        recipeConfig: [
+            {
+                op: "To Base62",
+                args: ["0-9A-Za-z"],
+            },
+        ],
+    },
+    {
+        name: "To Base62: Hello, World!",
+        input: "Hello, World!",
+        expectedOutput: "1wJfrzvdbtXUOlUjUf",
+        recipeConfig: [
+            {
+                op: "To Base62",
+                args: ["0-9A-Za-z"],
+            },
+        ],
+    },
+    {
+        name: "To Base62: UTF-8",
+        input: "ნუ პანიკას",
+        expectedOutput: "BPDNbjoGvDCDzHbKT77eWg0vGQrJuWRXltuRVZ",
+        recipeConfig: [
+            {
+                op: "To Base62",
+                args: ["0-9A-Za-z"],
+            },
+        ],
+    },
+    {
+        name: "From Base62: nothing",
+        input: "",
+        expectedOutput: "",
+        recipeConfig: [
+            {
+                op: "From Base62",
+                args: ["0-9A-Za-z"],
+            },
+        ],
+    },
+    {
+        name: "From Base62: Hello, World!",
+        input: "1wJfrzvdbtXUOlUjUf",
+        expectedOutput: "Hello, World!",
+        recipeConfig: [
+            {
+                op: "From Base62",
+                args: ["0-9A-Za-z"],
+            },
+        ],
+    },
+    {
+        name: "From Base62: UTF-8",
+        input: "BPDNbjoGvDCDzHbKT77eWg0vGQrJuWRXltuRVZ",
+        expectedOutput: "ნუ პანიკას",
+        recipeConfig: [
+            {
+                op: "From Base62",
+                args: ["0-9A-Za-z"],
+            },
+        ],
+    }
+]);
--- a/test/tests/operations/CSV.mjs
+++ b/test/tests/operations/CSV.mjs
@@ -0,0 +1,179 @@
+/**
+ * CSV tests.
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ *
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+import TestRegister from "../../TestRegister";
+
+const EXAMPLE_CSV = `A,B,C,D,E,F\r
+1,2,3,4,5,6\r
+",",;,',"""",,\r
+"""hello""","a""1","multi\r
+line",,,end\r
+`;
+
+TestRegister.addTests([
+    {
+        name: "CSV to JSON: Array of dictionaries",
+        input: EXAMPLE_CSV,
+        expectedOutput: JSON.stringify([
+            {
+                "A": "1",
+                "B": "2",
+                "C": "3",
+                "D": "4",
+                "E": "5",
+                "F": "6"
+            },
+            {
+                "A": ",",
+                "B": ";",
+                "C": "'",
+                "D": "\"",
+                "E": "",
+                "F": ""
+            },
+            {
+                "A": "\"hello\"",
+                "B": "a\"1",
+                "C": "multi\r\nline",
+                "D": "",
+                "E": "",
+                "F": "end"
+            }
+        ], null, 4),
+        recipeConfig: [
+            {
+                op: "CSV to JSON",
+                args: [",", "\r\n", "Array of dictionaries"],
+            }
+        ],
+    },
+    {
+        name: "CSV to JSON: Array of arrays",
+        input: EXAMPLE_CSV,
+        expectedOutput: JSON.stringify([
+            [
+                "A",
+                "B",
+                "C",
+                "D",
+                "E",
+                "F"
+            ],
+            [
+                "1",
+                "2",
+                "3",
+                "4",
+                "5",
+                "6"
+            ],
+            [
+                ",",
+                ";",
+                "'",
+                "\"",
+                "",
+                ""
+            ],
+            [
+                "\"hello\"",
+                "a\"1",
+                "multi\r\nline",
+                "",
+                "",
+                "end"
+            ]
+        ], null, 4),
+        recipeConfig: [
+            {
+                op: "CSV to JSON",
+                args: [",", "\r\n", "Array of arrays"],
+            }
+        ],
+    },
+    {
+        name: "JSON to CSV: Array of dictionaries",
+        input: JSON.stringify([
+            {
+                "A": "1",
+                "B": "2",
+                "C": "3",
+                "D": "4",
+                "E": "5",
+                "F": "6"
+            },
+            {
+                "A": ",",
+                "B": ";",
+                "C": "'",
+                "D": "\"",
+                "E": "",
+                "F": ""
+            },
+            {
+                "A": "\"hello\"",
+                "B": "a\"1",
+                "C": "multi\r\nline",
+                "D": "",
+                "E": "",
+                "F": "end"
+            }
+        ]),
+        expectedOutput: EXAMPLE_CSV,
+        recipeConfig: [
+            {
+                op: "JSON to CSV",
+                args: [",", "\r\n"],
+            }
+        ],
+    },
+    {
+        name: "JSON to CSV: Array of arrays",
+        input: JSON.stringify([
+            [
+                "A",
+                "B",
+                "C",
+                "D",
+                "E",
+                "F"
+            ],
+            [
+                "1",
+                "2",
+                "3",
+                "4",
+                "5",
+                "6"
+            ],
+            [
+                ",",
+                ";",
+                "'",
+                "\"",
+                "",
+                ""
+            ],
+            [
+                "\"hello\"",
+                "a\"1",
+                "multi\r\nline",
+                "",
+                "",
+                "end"
+            ]
+        ]),
+        expectedOutput: EXAMPLE_CSV,
+        recipeConfig: [
+            {
+                op: "JSON to CSV",
+                args: [",", "\r\n"],
+            }
+        ],
+    },
+]);
--- a/test/tests/operations/Ciphers.mjs
+++ b/test/tests/operations/Ciphers.mjs
@@ -110,6 +110,39 @@ TestRegister.addTests([
            }
        ],
    },
+    {
+        name: "A1Z26 Encode: normal",
+        input: "This is the test sentence.",
+        expectedOutput: "20 8 9 19 9 19 20 8 5 20 5 19 20 19 5 14 20 5 14 3 5",
+        recipeConfig: [
+            {
+                op: "A1Z26 Cipher Encode",
+                args: ["Space"]
+            }
+        ],
+    },
+    {
+        name: "A1Z26 Decode: normal",
+        input: "20 8 9 19 9 19 20 8 5 20 5 19 20 19 5 14 20 5 14 3 5",
+        expectedOutput: "thisisthetestsentence",
+        recipeConfig: [
+            {
+                op: "A1Z26 Cipher Decode",
+                args: ["Space"]
+            }
+        ],
+    },
+    {
+        name: "A1Z26 Decode: error",
+        input: "20 8 9 27",
+        expectedOutput: "Error: all numbers must be between 1 and 26.",
+        recipeConfig: [
+            {
+                op: "A1Z26 Cipher Decode",
+                args: ["Space"]
+            }
+        ],
+    },
    {
        name: "Atbash: no input",
        input: "",
@@ -220,6 +253,39 @@ TestRegister.addTests([
            }
        ],
    },
+    {
+        name: "Citrix CTX1 Encode",
+        input: "Password1",
+        expectedOutput: "PFFAJEDBOHECJEDBODEGIMCJPOFLJKDPKLAO",
+        recipeConfig: [
+            {
+                "op": "Citrix CTX1 Encode",
+                "args": []
+            }
+        ],
+    },
+    {
+        name: "Citrix CTX1 Decode: normal",
+        input: "PFFAJEDBOHECJEDBODEGIMCJPOFLJKDPKLAO",
+        expectedOutput: "Password1",
+        recipeConfig: [
+            {
+                "op": "Citrix CTX1 Decode",
+                "args": []
+            }
+        ],
+    },
+    {
+        name: "Citrix CTX1 Decode: invalid length",
+        input: "PFFAJEDBOHECJEDBODEGIMCJPOFLJKDPKLA",
+        expectedOutput: "Incorrect hash length",
+        recipeConfig: [
+            {
+                "op": "Citrix CTX1 Decode",
+                "args": []
+            }
+        ],
+    },
    {
        name: "Vigenère Encode: no input",
        input: "",
--- a/test/tests/operations/Hash.mjs
+++ b/test/tests/operations/Hash.mjs
@@ -405,7 +405,7 @@ TestRegister.addTests([
        ]
    },
    {
-        name: "HMAC SHA256",
+        name: "HMAC: SHA256",
        input: "Hello, World!",
        expectedOutput: "52589bd80ccfa4acbb3f9512dfaf4f700fa5195008aae0b77a9e47dcca75beac",
        recipeConfig: [
@@ -415,6 +415,302 @@ TestRegister.addTests([
            }
        ]
    },
+    {
+        name: "HMAC: RFC4231 Test Case 1 SHA-224",
+        input: "Hi There",
+        expectedOutput: "896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22",
+        recipeConfig: [
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"}, "SHA224"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 1 SHA-256",
+        input: "Hi There",
+        expectedOutput: "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7",
+        recipeConfig: [
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"}, "SHA256"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 1 SHA-384",
+        input: "Hi There",
+        expectedOutput: "afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6",
+        recipeConfig: [
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"}, "SHA384"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 1 SHA-512",
+        input: "Hi There",
+        expectedOutput: "87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854",
+        recipeConfig: [
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"}, "SHA512"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 2 SHA-224",
+        input: "what do ya want for nothing?",
+        expectedOutput: "a30e01098bc6dbbf45690f3a7e9e6d0f8bbea2a39e6148008fd05e44",
+        recipeConfig: [
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "4a656665"}, "SHA224"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 2 SHA-256",
+        input: "what do ya want for nothing?",
+        expectedOutput: "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
+        recipeConfig: [
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "4a656665"}, "SHA256"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 2 SHA-384",
+        input: "what do ya want for nothing?",
+        expectedOutput: "af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec3736322445e8e2240ca5e69e2c78b3239ecfab21649",
+        recipeConfig: [
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "4a656665"}, "SHA384"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 2 SHA-512",
+        input: "what do ya want for nothing?",
+        expectedOutput: "164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737",
+        recipeConfig: [
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "4a656665"}, "SHA512"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 3 SHA-224",
+        input: "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
+        expectedOutput: "7fb3cb3588c6c1f6ffa9694d7d6ad2649365b0c1f65d69d1ec8333ea",
+        recipeConfig: [
+            {
+                "op": "From Hex",
+                "args": ["None"]
+            },
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, "SHA224"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 3 SHA-256",
+        input: "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
+        expectedOutput: "773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe",
+        recipeConfig: [
+            {
+                "op": "From Hex",
+                "args": ["None"]
+            },
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, "SHA256"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 3 SHA-384",
+        input: "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
+        expectedOutput: "88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e55966144b2a5ab39dc13814b94e3ab6e101a34f27",
+        recipeConfig: [
+            {
+                "op": "From Hex",
+                "args": ["None"]
+            },
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, "SHA384"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 3 SHA-512",
+        input: "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
+        expectedOutput: "fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb",
+        recipeConfig: [
+            {
+                "op": "From Hex",
+                "args": ["None"]
+            },
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, "SHA512"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 4 SHA-224",
+        input: "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
+        expectedOutput: "6c11506874013cac6a2abc1bb382627cec6a90d86efc012de7afec5a",
+        recipeConfig: [
+            {
+                "op": "From Hex",
+                "args": ["None"]
+            },
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "0102030405060708090a0b0c0d0e0f10111213141516171819"}, "SHA224"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 4 SHA-256",
+        input: "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
+        expectedOutput: "82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b",
+        recipeConfig: [
+            {
+                "op": "From Hex",
+                "args": ["None"]
+            },
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "0102030405060708090a0b0c0d0e0f10111213141516171819"}, "SHA256"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 4 SHA-384",
+        input: "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
+        expectedOutput: "3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e1f573b4e6801dd23c4a7d679ccf8a386c674cffb",
+        recipeConfig: [
+            {
+                "op": "From Hex",
+                "args": ["None"]
+            },
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "0102030405060708090a0b0c0d0e0f10111213141516171819"}, "SHA384"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 4 SHA-512",
+        input: "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
+        expectedOutput: "b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd",
+        recipeConfig: [
+            {
+                "op": "From Hex",
+                "args": ["None"]
+            },
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "0102030405060708090a0b0c0d0e0f10111213141516171819"}, "SHA512"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 6 SHA-224",
+        input: "Test Using Larger Than Block-Size Key - Hash Key First",
+        expectedOutput: "95e9a0db962095adaebe9b2d6f0dbce2d499f112f2d2b7273fa6870e",
+        recipeConfig: [
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, "SHA224"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 6 SHA-256",
+        input: "Test Using Larger Than Block-Size Key - Hash Key First",
+        expectedOutput: "60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54",
+        recipeConfig: [
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, "SHA256"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 6 SHA-384",
+        input: "Test Using Larger Than Block-Size Key - Hash Key First",
+        expectedOutput: "4ece084485813e9088d2c63a041bc5b44f9ef1012a2b588f3cd11f05033ac4c60c2ef6ab4030fe8296248df163f44952",
+        recipeConfig: [
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, "SHA384"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 6 SHA-512",
+        input: "Test Using Larger Than Block-Size Key - Hash Key First",
+        expectedOutput: "80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f3526b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec8b915a985d786598",
+        recipeConfig: [
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, "SHA512"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 7 SHA-224",
+        input: "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.",
+        expectedOutput: "3a854166ac5d9f023f54d517d0b39dbd946770db9c2b95c9f6f565d1",
+        recipeConfig: [
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, "SHA224"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 7 SHA-256",
+        input: "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.",
+        expectedOutput: "9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2",
+        recipeConfig: [
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, "SHA256"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 7 SHA-384",
+        input: "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.",
+        expectedOutput: "6617178e941f020d351e2f254e8fd32c602420feb0b8fb9adccebb82461e99c5a678cc31e799176d3860e6110c46523e",
+        recipeConfig: [
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, "SHA384"]
+            }
+        ]
+    },
+    {
+        name: "HMAC: RFC4231 Test Case 7 SHA-512",
+        input: "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.",
+        expectedOutput: "e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc944b6022cac3c4982b10d5eeb55c3e4de15134676fb6de0446065c97440fa8c6a58",
+        recipeConfig: [
+            {
+                "op": "HMAC",
+                "args": [{"option": "Hex", "string": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, "SHA512"]
+            }
+        ]
+    },
    {
        name: "MD5: Complex bytes",
        input: "10dc10e32010de10d010dc10d810d910d010e12e",
--- a/test/tests/operations/JSONBeautify.mjs
+++ b/test/tests/operations/JSONBeautify.mjs
@@ -0,0 +1,122 @@
+/**
+ * JSONBeautify tests.
+ *
+ * @author Phillip Nordwall [Phillip.Nordwall@gmail.com]
+ *
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+import TestRegister from "../../TestRegister";
+
+TestRegister.addTests([
+    {
+        name: "JSON Beautify: space, ''",
+        input: "",
+        expectedOutput: "",
+        recipeConfig: [
+            {
+                op: "JSON Beautify",
+                args: [" ", false],
+            },
+        ],
+    },
+    {
+        name: "JSON Beautify: space, number",
+        input: "42",
+        expectedOutput: "42",
+        recipeConfig: [
+            {
+                op: "JSON Beautify",
+                args: [" ", false],
+            },
+        ],
+    },
+    {
+        name: "JSON Beautify: space, string",
+        input: "\"string\"",
+        expectedOutput: "\"string\"",
+        recipeConfig: [
+            {
+                op: "JSON Beautify",
+                args: [" ", false],
+            },
+        ],
+    },
+    {
+        name: "JSON Beautify: space, boolean",
+        input: "false",
+        expectedOutput: "false",
+        recipeConfig: [
+            {
+                op: "JSON Beautify",
+                args: [" ", false],
+            },
+        ],
+    },
+    {
+        name: "JSON Beautify: space, emptyList",
+        input: "[]",
+        expectedOutput: "[]",
+        recipeConfig: [
+            {
+                op: "JSON Beautify",
+                args: [" ", false],
+            },
+        ],
+    },
+    {
+        name: "JSON Beautify: space, list",
+        input: "[2,1]",
+        expectedOutput: "[\n 2,\n 1\n]",
+        recipeConfig: [
+            {
+                op: "JSON Beautify",
+                args: [" ", false],
+            },
+        ],
+    },
+    {
+        name: "JSON Beautify: tab, list",
+        input: "[2,1]",
+        expectedOutput: "[\n\t2,\n\t1\n]",
+        recipeConfig: [
+            {
+                op: "JSON Beautify",
+                args: ["\t", false],
+            },
+        ],
+    },
+    {
+        name: "JSON Beautify: space, object",
+        input: "{\"second\":2,\"first\":3}",
+        expectedOutput: "{\n \"second\": 2,\n \"first\": 3\n}",
+        recipeConfig: [
+            {
+                op: "JSON Beautify",
+                args: [" ", false],
+            },
+        ],
+    },
+    {
+        name: "JSON Beautify: tab, nested",
+        input: "[2,{\"second\":2,\"first\":3,\"beginning\":{\"j\":\"3\",\"i\":[2,3,false]}},1,2,3]",
+        expectedOutput: "[\n\t2,\n\t{\n\t\t\"second\": 2,\n\t\t\"first\": 3,\n\t\t\"beginning\": {\n\t\t\t\"j\": \"3\",\n\t\t\t\"i\": [\n\t\t\t\t2,\n\t\t\t\t3,\n\t\t\t\tfalse\n\t\t\t]\n\t\t}\n\t},\n\t1,\n\t2,\n\t3\n]",
+        recipeConfig: [
+            {
+                op: "JSON Beautify",
+                args: ["\t", false],
+            },
+        ],
+    },
+    {
+        name: "JSON Beautify: tab, nested, sorted",
+        input: "[2,{\"second\":2,\"first\":3,\"beginning\":{\"j\":\"3\",\"i\":[2,3,false]}},1,2,3]",
+        expectedOutput: "[\n\t2,\n\t{\n\t\t\"beginning\": {\n\t\t\t\"i\": [\n\t\t\t\t2,\n\t\t\t\t3,\n\t\t\t\tfalse\n\t\t\t],\n\t\t\t\"j\": \"3\"\n\t\t},\n\t\t\"first\": 3,\n\t\t\"second\": 2\n\t},\n\t1,\n\t2,\n\t3\n]",
+        recipeConfig: [
+            {
+                op: "JSON Beautify",
+                args: ["\t", true],
+            },
+        ],
+    },
+]);
--- a/test/tests/operations/JSONMinify.mjs
+++ b/test/tests/operations/JSONMinify.mjs
@@ -0,0 +1,111 @@
+/**
+ * JSONMinify tests.
+ *
+ * @author Phillip Nordwall [Phillip.Nordwall@gmail.com]
+ *
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+import TestRegister from "../../TestRegister";
+
+TestRegister.addTests([
+    {
+        name: "JSON Minify: ''",
+        input: "",
+        expectedOutput: "",
+        recipeConfig: [
+            {
+                op: "JSON Minify",
+                args: [],
+            },
+        ],
+    },
+    {
+        name: "JSON Minify: number",
+        input: "42",
+        expectedOutput: "42",
+        recipeConfig: [
+            {
+                op: "JSON Minify",
+                args: [],
+            },
+        ],
+    },
+    {
+        name: "JSON Minify: number",
+        input: "4.2",
+        expectedOutput: "4.2",
+        recipeConfig: [
+            {
+                op: "JSON Minify",
+                args: [],
+            },
+        ],
+    },
+    {
+        name: "JSON Minify: string",
+        input: "\"string\"",
+        expectedOutput: "\"string\"",
+        recipeConfig: [
+            {
+                op: "JSON Minify",
+                args: [],
+            },
+        ],
+    },
+    {
+        name: "JSON Minify: boolean",
+        input: "false",
+        expectedOutput: "false",
+        recipeConfig: [
+            {
+                op: "JSON Minify",
+                args: [],
+            },
+        ],
+    },
+    {
+        name: "JSON Minify: emptyList",
+        input: "[\n \n  \t]",
+        expectedOutput: "[]",
+        recipeConfig: [
+            {
+                op: "JSON Minify",
+                args: [],
+            },
+        ],
+    },
+    {
+        name: "JSON Minify: list",
+        input: "[2,\n  \t1]",
+        expectedOutput: "[2,1]",
+        recipeConfig: [
+            {
+                op: "JSON Minify",
+                args: [],
+            },
+        ],
+    },
+    {
+        name: "JSON Minify: object",
+        input: "{\n \"second\": 2,\n \"first\": 3\n}",
+        expectedOutput: "{\"second\":2,\"first\":3}",
+        recipeConfig: [
+            {
+                op: "JSON Minify",
+                args: [],
+            },
+        ],
+    },
+    {
+        name: "JSON Minify: tab, nested",
+        input: "[\n\t2,\n\t{\n\t\t\"second\": 2,\n\t\t\"first\": 3,\n\t\t\"beginning\": {\n\t\t\t\"j\": \"3\",\n\t\t\t\"i\": [\n\t\t\t\t2,\n\t\t\t\t3,\n\t\t\t\tfalse\n\t\t\t]\n\t\t}\n\t},\n\t1,\n\t2,\n\t3\n]",
+        expectedOutput: "[2,{\"second\":2,\"first\":3,\"beginning\":{\"j\":\"3\",\"i\":[2,3,false]}},1,2,3]",
+        recipeConfig: [
+            {
+                op: "JSON Minify",
+                args: [],
+            },
+        ],
+    },
+]);
--- a/test/tests/operations/RemoveDiacritics.mjs
+++ b/test/tests/operations/RemoveDiacritics.mjs
@@ -0,0 +1,22 @@
+/**
+ * Remove Diacritics tests.
+ *
+ * @author Klaxon [klaxon@veyr.com]
+ * @copyright Crown Copyright 2017
+ * @license Apache-2.0
+ */
+import TestRegister from "../../TestRegister";
+
+TestRegister.addTests([
+    {
+        name: "Remove Diacritics",
+        input: "\xe0, \xe8, \xec, \xf2, \xf9  \xc0, \xc8, \xcc, \xd2, \xd9\n\xe1, \xe9, \xed, \xf3, \xfa, \xfd \xc1, \xc9, \xcd, \xd3, \xda, \xdd\n\xe2, \xea, \xee, \xf4, \xfb \xc2, \xca, \xce, \xd4, \xdb\n\xe3, \xf1, \xf5 \xc3, \xd1, \xd5\n\xe4, \xeb, \xef, \xf6, \xfc, \xff \xc4, \xcb, \xcf, \xd6, \xdc, \u0178\n\xe5, \xc5",
+        expectedOutput: "a, e, i, o, u  A, E, I, O, U\na, e, i, o, u, y A, E, I, O, U, Y\na, e, i, o, u A, E, I, O, U\na, n, o A, N, O\na, e, i, o, u, y A, E, I, O, U, Y\na, A",
+        recipeConfig: [
+            {
+                "op": "Remove Diacritics",
+                "args": []
+            },
+        ],
+    },
+]);
--- a/test/tests/operations/SeqUtils.mjs
+++ b/test/tests/operations/SeqUtils.mjs
@@ -30,4 +30,15 @@ TestRegister.addTests([
            }
        ],
    },
+    {
+        name: "SeqUtils - Hexadecimal sort",
+        input: "06,08,0a,0d,0f,1,10,11,12,13,14,15,16,17,18,19,1a,1b,1c,1d,1e,1f,2,3,4,5,7,9,b,c,e",
+        expectedOutput: "1,2,3,4,5,06,7,08,9,0a,b,c,0d,e,0f,10,11,12,13,14,15,16,17,18,19,1a,1b,1c,1d,1e,1f",
+        recipeConfig: [
+            {
+                "op": "Sort",
+                "args": ["Comma", false, "Numeric (hexadecimal)"]
+            }
+        ],
+    },
 ]);
--- a/test/tests/operations/TextEncodingBruteForce.mjs
+++ b/test/tests/operations/TextEncodingBruteForce.mjs
@@ -0,0 +1,35 @@
+/**
+ * Text Encoding Brute Force tests.
+ *
+ * @author Cynser
+ *
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+import TestRegister from "../../TestRegister";
+
+TestRegister.addTests([
+    {
+        name: "Text Encoding Brute Force - Encode",
+        input: "Р‘СѓР»РєС– РїСЂР°Р· Р»СЏРЅС–РІР° СЃР°Р±Р°РєСѓ.",
+        expectedMatch: /Windows-1251 Cyrillic \(1251\).{1,10}Булкі праз ляніва сабаку\./,
+        recipeConfig: [
+            {
+                op: "Text Encoding Brute Force",
+                args: ["Encode"],
+            },
+        ],
+    },
+    {
+        name: "Text Encoding Brute Force - Decode",
+        input: "Áóëê³ ïðàç ëÿí³âà ñàáàêó.",
+        expectedMatch: /Windows-1251 Cyrillic \(1251\).{1,10}Булкі праз ляніва сабаку\./,
+        recipeConfig: [
+            {
+                op: "Text Encoding Brute Force",
+                args: ["Decode"],
+            },
+        ],
+    }
+]);
+
--- a/webpack.config.js
+++ b/webpack.config.js
@@ -1,5 +1,6 @@
 const webpack = require("webpack");
 const ExtractTextPlugin = require("extract-text-webpack-plugin");
+const path = require("path");

 /**
 * Webpack configuration details for use with Grunt.
@@ -58,8 +59,13 @@ module.exports = {
            {
                test: /\.m?js$/,
                exclude: /node_modules\/(?!jsesc|crypto-api)/,
+                options: {
+                    configFile: path.resolve(__dirname, "babel.config.js"),
+                    cacheDirectory: true,
+                    compact: false
+                },
                type: "javascript/auto",
-                loader: "babel-loader?compact=false"
+                loader: "babel-loader"
            },
            {
                test: /forge.min.js$/,
Author	SHA1	Message	Date
n1474335	f367c1f78b	8.15.1	2018-12-19 17:25:05 +00:00
n1474335	13d87d397d	Merge branch 'j433866-master'	2018-12-19 17:24:52 +00:00
n1474335	ed2c886359	Magic crib now only applies after all branches have been explored.	2018-12-19 17:24:38 +00:00
n1474335	6337e84708	Merge branch 'master' of https://github.com/j433866/CyberChef into j433866-master	2018-12-19 16:38:34 +00:00
j433866	f600571c6d	Fix to make the filter work when intensive mode was turned on.	2018-12-19 09:42:09 +00:00
j433866	5d4c7244e1	Add note about crib to operation description	2018-12-18 16:52:09 +00:00
j433866	b6bdcaa71f	Rename output filter argument to Crib	2018-12-18 14:19:52 +00:00
j433866	c8eab5d218	Commenting	2018-12-18 14:06:39 +00:00
n1474335	8ab56a29ac	8.15.0	2018-12-18 13:50:30 +00:00
n1474335	973b5f3f5c	Merge branch 'Cynser-text-brute-force'	2018-12-18 13:50:23 +00:00
n1474335	076a1f97c2	Tidied up 'Text Encoding Brute Force' operations and updated CHANGELOG	2018-12-18 13:50:10 +00:00
n1474335	d96ef37d81	Merge branch 'text-brute-force' of https://github.com/Cynser/CyberChef into Cynser-text-brute-force	2018-12-18 12:28:27 +00:00
n1474335	56f8302402	8.14.0	2018-12-18 12:20:03 +00:00
n1474335	97e6a7cbd8	Merge branch 'tcode2k16-master'	2018-12-18 12:19:56 +00:00
n1474335	d89d79116c	Cleaned up Base62 ops and updated CHANGELOG	2018-12-18 12:19:42 +00:00
j433866	367d79e820	Fix filtering to work on all the data and not just the result snippet	2018-12-18 11:55:49 +00:00
j433866	283d7f2159	Add Output Filter option to Magic operation	2018-12-18 10:40:18 +00:00
Cynser	dacb3ef6c3	Added decode option	2018-12-17 19:39:12 +00:00
tcode2k16	22454ae842	Add "To Base62" and "From Base62" operations	2018-12-17 12:37:00 +08:00
n1474335	79b9b63982	8.13.0	2018-12-15 00:26:41 +00:00
n1474335	2f68bf30a4	Merge branch 'jarmovanlenthe-master'	2018-12-15 00:26:31 +00:00
n1474335	50f078cc45	Updated CHANGELOG	2018-12-15 00:26:15 +00:00
n1474335	47a410d6ab	Merge branch 'master' of https://github.com/jarmovanlenthe/CyberChef into jarmovanlenthe-master	2018-12-15 00:19:16 +00:00
n1474335	31cbf8cccc	8.12.4	2018-12-15 00:16:23 +00:00
n1474335	88bd321e3e	Merge branch 'imhotepisinvisible-master'	2018-12-15 00:16:13 +00:00
Jarmo van Lenthe	b4a586c0b9	Some lets to consts and removing of trailing spaces from grunt lint	2018-12-14 22:35:43 +01:00
Oliver Grubin	63593f1b6c	Fix HMAC operation when hex key has bytes >= 0x80 (#437 ) Add test vectors from RFC4231	2018-12-14 21:32:44 +00:00
Jarmo van Lenthe	dcff8971e8	Added simple A1Z26 'cipher'	2018-12-14 22:29:51 +01:00
Cynser	3f7059a235	Remove unnecessary escape character	2018-12-12 17:49:11 +00:00
Cynser	71c743ff5a	Add Text Encoding Brute Force operation	2018-12-12 17:34:45 +00:00
n1474335	15fbe5a459	8.12.3	2018-11-23 16:07:30 +00:00
n1474335	cd47394709	Merge branch 'PhillipNordwall-JSON_Object_Sort'	2018-11-23 16:07:21 +00:00
n1474335	6f4ee8b7b6	Tidied JSON Beautify op. Changed default indent to 4 spaces instead of a tab.	2018-11-23 16:05:51 +00:00
n1474335	8c5d05b611	Merge branch 'JSON_Object_Sort' of https://github.com/PhillipNordwall/CyberChef into PhillipNordwall-JSON_Object_Sort	2018-11-23 15:56:59 +00:00
n1474335	3bdcf4d851	8.12.2	2018-11-23 14:58:38 +00:00
n1474335	1d1c69ca51	Updated magic pattern matches for QP and B64 encodings to handle whitespace better	2018-11-23 14:58:30 +00:00
Phillip Nordwall	c4c679021d	Adding Sort Object Keys, and tests for it.	2018-11-22 11:10:10 -08:00
Phillip Nordwall	c16d13e2c9	Adding test cases for JSON Minify	2018-11-22 11:07:48 -08:00
Phillip Nordwall	97613eb3c7	Adding test cases for JSON Beautify	2018-11-22 10:31:22 -08:00
n1474335	a946d04a72	8.12.1	2018-11-21 17:48:03 +00:00
n1474335	cc35ec82eb	Fixed babel transpilation of jsesc and crypto-api	2018-11-21 17:47:56 +00:00
n1474335	d6604e0008	Updated CHANGELOG	2018-11-21 12:48:27 +00:00
n1474335	b9e63efc37	Fixed version links in CHANGELOG	2018-11-21 12:40:55 +00:00
n1474335	b458707921	8.12.0	2018-11-21 12:29:25 +00:00
n1474335	6ec52c6cd2	Merge branch 'bwhitn-citrix'	2018-11-21 12:28:36 +00:00
n1474335	79d7a5dd87	Tidied up Citrix CTX1 operations and updated CHANGELOG	2018-11-21 12:28:19 +00:00
n1474335	1653d0212a	Merge branch 'citrix' of https://github.com/bwhitn/CyberChef into bwhitn-citrix	2018-11-21 10:23:39 +00:00
Brian Whitney	c378bcb00b	Fixed lint issues	2018-11-20 11:24:50 -05:00
Brian Whitney	215e7a5f5d	Citrix CTX1 encoding/decoding	2018-11-20 11:09:52 -05:00
bwhitn	6b686681d5	Encoding ctx1	2018-11-19 23:48:33 -05:00
n1474335	20ea050728	Updated description for 'Substitute' to include note about escaping backslashes.	2018-11-19 14:54:37 +00:00
n1474335	4b6132a2d7	8.11.2	2018-11-19 14:34:56 +00:00
n1474335	4cf80e3ebb	Added RFC numbers to relevant Base64 alphabets. Closes #410	2018-11-19 14:34:52 +00:00
n1474335	045747f543	8.11.1	2018-11-14 12:27:55 +00:00
n1474335	b10c5e3256	Fixed faulty package-lock.json	2018-11-14 12:27:47 +00:00
n1474335	69df2e4183	Updated comments	2018-11-13 18:05:52 +00:00
n1474335	12ebd35c4d	8.11.0	2018-11-13 17:56:46 +00:00
n1474335	30c5f76cf0	Updated changelog	2018-11-13 17:56:40 +00:00
n1474335	3a979b6cda	'JSON to CSV' operation now escapes characters correctly. Added tests for CSV/JSON operations.	2018-11-13 17:54:43 +00:00
n1474335	863bdffa84	Added 'CSV to JSON' and 'JSON to CSV' operations. Closes #277	2018-11-09 17:40:19 +00:00
n1474335	42b956e402	Fixed JSDoc comment	2018-11-09 15:28:47 +00:00
n1474335	4acf7b4e4f	8.10.2	2018-11-09 15:25:22 +00:00
n1474335	42e881326f	Added 'Binary' key option to all bitwise operations. Closes #398	2018-11-09 15:25:16 +00:00
n1474335	3c4893d7c7	8.10.1	2018-11-07 15:20:51 +00:00
n1474335	027aca4ab2	Merge branch 'qistoph-NumSortHex'	2018-11-07 15:20:43 +00:00
n1474335	2d471f551f	Lint	2018-11-07 15:20:09 +00:00
n1474335	5c598b69b0	Merge branch 'NumSortHex' of https://github.com/qistoph/CyberChef into qistoph-NumSortHex	2018-11-07 15:15:39 +00:00
n1474335	037300de79	8.10.0	2018-11-07 15:10:57 +00:00
n1474335	6990dcae89	Updated changelog	2018-11-07 15:10:25 +00:00
n1474335	6e81d6dfcd	Merge branch 'klaxon1-feature/remove-letter-accents'	2018-11-07 15:08:09 +00:00
n1474335	cea30465d8	Changed 'Remove Letter Accents' to 'Remove Diacritics'	2018-11-07 15:07:54 +00:00
n1474335	b301d16cb2	Merge branch 'feature/remove-letter-accents' of https://github.com/klaxon1/CyberChef into klaxon1-feature/remove-letter-accents	2018-11-07 14:57:05 +00:00
Chris van Marle	ba24e12454	Update hexadecimal sort after review - Use Array.map instead of for-loop - Add test case	2018-10-12 15:39:06 +02:00
Chris van Marle	3b3c27072f	Fix lint errors	2018-10-11 15:50:58 +02:00
Klaxon	3089c39369	add test	2018-10-11 22:26:44 +10:00
Chris van Marle	0cbb17f7ce	Support hexadecimal and other bases in numeric sorting	2018-10-11 14:23:05 +02:00
Klaxon	54793f2b78	update operation	2018-10-11 21:52:49 +10:00
Klaxon	f1ffe19ec8	Merge branch 'master' into feature/remove-letter-accents	2018-10-11 21:28:04 +10:00
Klaxon	04ee2fb3e4	add function to replace accent chars with latin chars	2018-10-03 13:26:01 +10:00
Klaxon	ac2466a304	create operation from npm run newop	2018-10-03 13:11:22 +10:00