Fixed conflicts.

src/js/config/Categories.js

@@ -84,6 +84,9 @@ var Categories = [
             "Vigenère Decode",
             "To Morse Code",
             "From Morse Code",
+            "Affine Cipher Encode",
+            "Affine Cipher Decode",
+            "Atbash Cipher",
             "Substitute",
             "Derive PBKDF2 key",
             "Derive EVP key",

src/js/config/OperationConfig.js

@@ -1360,6 +1360,55 @@ var OperationConfig = {
             }
         ]
     },
+    "Affine Cipher Encode": {
+        description: "The Affine cipher is a type of monoalphabetic substitution cipher, wherein each letter in an alphabet is mapped to its numeric equivalent, encrypted using simple mathematical function, <code>(ax + b) % 26</code>, and converted back to a letter.",
+        run: Cipher.runAffineEnc,
+        highlight: true,
+        highlightReverse: true,
+        inputType: "string",
+        outputType: "string",
+        args: [
+            {
+                name: "a",
+                type: "number",
+                value: Cipher.AFFINE_A
+            },
+            {
+                name: "b",
+                type: "number",
+                value: Cipher.AFFINE_B
+            }
+        ]
+    },
+    "Affine Cipher Decode": {
+        description: "The Affine cipher is a type of monoalphabetic substitution cipher. To decrypt, each letter in an alphabet is mapped to its numeric equivalent, decrypted by a mathematical function, and converted back to a letter.",
+        run: Cipher.runAffineDec,
+        highlight: true,
+        highlightReverse: true,
+        inputType: "string",
+        outputType: "string",
+        args: [
+            {
+                name: "a",
+                type: "number",
+                value: Cipher.AFFINE_A
+            },
+            {
+                name: "b",
+                type: "number",
+                value: Cipher.AFFINE_B
+            }
+        ]
+    },
+    "Atbash Cipher": {
+        description: "Atbash is a mono-alphabetic substitution cipher originally used to encode the Hebrew alphabet. It has been modified here for use with the Latin alphabet.",
+        run: Cipher.runAtbash,
+        highlight: true,
+        highlightReverse: true,
+        inputType: "string",
+        outputType: "string",
+        args: []
+    },
     "Rotate right": {
         description: "Rotates each byte to the right by the number of bits specified. Currently only supports 8-bit values.",
         run: Rotate.runRotr,

src/js/core/Utils.js

@@ -929,6 +929,53 @@ var Utils = {
     },
 
 
+    /**
+     * Actual modulo function, since % is actually the remainder function in JS.
+     *
+     * @author Matt C [matt@artemisbot.pw]
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    mod: function (x, y) {
+        return ((x % y) + y) % y;
+    },
+
+
+    /**
+     * Finds the greatest common divisor of two numbers.
+     *
+     * @author Matt C [matt@artemisbot.pw]
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    gcd: function(x, y) {
+        if (!y) {
+            return x;
+        }
+        return Utils.gcd(y, x % y);
+    },
+
+
+    /**
+     * Finds the modular inverse of two values.
+     *
+     * @author Matt C [matt@artemisbot.pw]
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    modInv: function(x, y) {
+        x %= y;
+        for (var i = 1; i < y; i++) {
+            if ((x * i) % 26 === 1) {
+                return i;
+            }
+        }
+    },
+
+
     /**
      * A mapping of names of delimiter characters to their symbols.
      * @constant

src/js/operations/Cipher.js

@@ -476,6 +476,106 @@ var Cipher = {
     },
 
 
+    /**
+     * @constant
+     * @default
+     */
+    AFFINE_A: 1,
+    /**
+     * @constant
+     * @default
+     */
+    AFFINE_B: 0,
+
+    /**
+     * Affine Cipher Encode operation.
+     *
+     * @author Matt C [matt@artemisbot.pw]
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    runAffineEnc: function (input, args) {
+        var alphabet = "abcdefghijklmnopqrstuvwxyz",
+            a = args[0],
+            b = args[1],
+            output = "";
+
+        if (!/^\+?(0|[1-9]\d*)$/.test(a) || !/^\+?(0|[1-9]\d*)$/.test(b)) {
+            return "The values of a and b can only be integers.";
+        }
+
+        for (var i = 0; i < input.length; i++) {
+            if (alphabet.indexOf(input[i]) >= 0) {
+                // Uses the affine function ax+b % m = y (where m is length of the alphabet)
+                output += alphabet[((a * alphabet.indexOf(input[i])) + b) % 26];
+            } else if (alphabet.indexOf(input[i].toLowerCase()) >= 0) {
+                // Same as above, accounting for uppercase
+                output += alphabet[((a * alphabet.indexOf(input[i].toLowerCase())) + b) % 26].toUpperCase();
+            } else {
+                // Non-alphabetic characters
+                output += input[i];
+            }
+        }
+        return output;
+    },
+
+
+    /**
+     * Affine Cipher Encode operation.
+     *
+     * @author Matt C [matt@artemisbot.pw]
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    runAffineDec: function (input, args) {
+        var alphabet = "abcdefghijklmnopqrstuvwxyz",
+            a = args[0],
+            b = args[1],
+            output = "",
+            aModInv;
+
+        if (!/^\+?(0|[1-9]\d*)$/.test(a) || !/^\+?(0|[1-9]\d*)$/.test(b)) {
+            return "The values of a and b can only be integers.";
+        }
+
+        if (Utils.gcd(a, 26) !== 1) {
+            return "The value of a must be coprime to 26.";
+        }
+
+        // Calculates modular inverse of a
+        aModInv = Utils.modInv(a, 26);
+        
+        for (var i = 0; i < input.length; i++) {
+            if (alphabet.indexOf(input[i]) >= 0) {
+                // Uses the affine decode function (y-b * A') % m = x (where m is length of the alphabet and A' is modular inverse)
+                output += alphabet[Utils.mod((alphabet.indexOf(input[i]) - b) * aModInv, 26)];
+            } else if (alphabet.indexOf(input[i].toLowerCase()) >= 0) {
+                // Same as above, accounting for uppercase
+                output += alphabet[Utils.mod((alphabet.indexOf(input[i].toLowerCase()) - b) * aModInv, 26)].toUpperCase();
+            } else {
+                // Non-alphabetic characters
+                output += input[i];
+            }
+        }
+        return output;
+    },
+
+
+    /**
+     * Atbash Cipher Encode operation.
+     *
+     * @author Matt C [matt@artemisbot.pw]
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    runAtbash: function (input, args) {
+        return Cipher.runAffineEnc(input, [25, 25]);
+    },
+
+
     /**
      * @constant
      * @default

src/static/stats.txt

@@ -1,9 +1,9 @@
 212	source files
-115106	lines
+115305	lines
 4.3M	size
 
 142	JavaScript source files
-105926	lines
+106125	lines
 3.8M	size
 
 83	third party JavaScript source files
@@ -11,11 +11,11 @@
 3.0M	size
 
 59	first party JavaScript source files
-19668	lines
-740K	size
+19867	lines
+748K	size
 
 3.5M	uncompressed JavaScript size
 1.9M	compressed JavaScript size
 
 15	categories
-167	operations
+170	operations