[Message Mixer] Problem decoding message with caesarCipher when using a negative number

Exercise: Message Mixer

Hi everyone,

I am having issues decoding the message while using the caesarCipher() when the second argument is a negative integer.

const {caesarCipher, symbolCipher, reverseCipher} = require('./encryptors.js');

const encodeMessage = (str) => {
  // Use the encryptor functions here.
  return caesarCipher(str, amount=1);

}

const decodeMessage = (str) => {
  // Use the encryptor functions here.
  
  return caesarCipher(str, (-1));
  //return reverseCipher(symbolCipher(str));

}

The encodeMessage() and decodeMessage() work fine while using the other methods: symbolCipher() and reverseCipher(), which would suggest that the modules were correctly imported, so this “ReferenceError: caesarCipher is not defined” is puzzling me.

Any hints would be much appreciated,
Cheers

p.s : this is my first time posting here, so please thank you for your understanding in case of any formatting flaws

$ node super-encoder.js encode
Enter the message you would like to encrypt...
> hello world
ifmmp xpsme
$ node super-encoder.js decode
Enter the message you would like to encrypt...
> ifmmp xpsme
/home/ccuser/workspace/modules-message-mixer/encryptors.js:7
    return caesarCipher(str, amount + 26);
           

ReferenceError: caesarCipher is not defined
    at module.exports.caesarCipher (/home/ccuser/workspace/modules-message-mixer/encryptors.js:7:12)
    at decodeMessage (/home/ccuser/workspace/modules-message-mixer/super-encoder.js:13:10)
    at ReadStream.handleInput (/home/ccuser/workspace/modules-message-mixer/super-encoder.js:27:14)
    at emitOne (events.js:96:13)
    at ReadStream.emit (events.js:191:7)
    at readableAddChunk (_stream_readable.js:178:18)
    at ReadStream.Readable.push (_stream_readable.js:136:10)
    at TTY.onread (net.js:561:20)
$

This is how the three different files look like:

encryptor.js

// Declare and export the functions here.

// Encryption Functions
/////////////////////////////////////////////
module.exports.caesarCipher = (str, amount = 0) => {
  if (amount < 0) {
    return caesarCipher(str, amount + 26);
  }
  let output = '';
  for (let i = 0; i < str.length; i++) {
    let char = str[i];
    if (char.match(/[a-z]/i)) {
      let code = str.charCodeAt(i);
      if (code >= 65 && code <= 90) {
        char = String.fromCharCode(((code - 65 + amount) % 26) + 65);
      } else if (code >= 97 && code <= 122) {
        char = String.fromCharCode(((code - 97 + amount) % 26) + 97);
      }
    }
    output += char;
  }
  return output;
};

module.exports.symbolCipher = (str) => {
  const symbols = {
    'i': '!',
    '!': 'i',
    'l': '1',
    '1': 'l',
    's': '$',
    '$': 's',
    'o': '0',
    '0': 'o',
    'a': '@',
    '@': 'a',
    'e': '3',
    '3': 'e',
    'b': '6',
    '6': 'b'
  }

  let output = '';
  for (let i = 0; i < str.length; i++) {
    let char = str.toLowerCase()[i];

    if (symbols[char]) {
      output += symbols[char]
    } else {
      output += char;
    }
  }
  return output;
}

module.exports.reverseCipher = (sentence) => {
  let words = sentence.split(' ');
  for (let i = 0; i < words.length; i++) {
    words[i] = words[i].split('').reverse().join('');
  }
   return words.join(' ');
};```


**message-mixer.js**

// Import the functions from encryptors.js here.

const encryptors = require(’./encryptors.js’);

const {caesarCipher, symbolCipher, reverseCipher} = encryptors;
// User Input / Output Logic
/////////////////////////////////////////////

const encryptionMethod = getEncryptionMethod();
process.stdin.on(‘data’, (userInput) => {
displayEncryptedMessage(encryptionMethod, userInput);
});

/* Helper function for determining which cipher method
the user chose when they ran the program. */
function getEncryptionMethod() {
let encryptionMethod;

const encryptionType = process.argv[2];
if (encryptionType === ‘symbol’) {
encryptionMethod = symbolCipher;
} else if (encryptionType === ‘reverse’) {
encryptionMethod = reverseCipher;
} else if (encryptionType === ‘caesar’) {
let amount = Number(process.argv[3]);
if (Number.isNaN(amount)) {
process.stdout.write(Try again with a valid amount argument. \n)
process.exit();
}
encryptionMethod = (str) => caesarCipher(str, amount);
}
else {
process.stdout.write(Try again with a valid encryption type. \n)
process.exit();
}

process.stdout.write('Enter the message you would like to encrypt…\n> ');
return encryptionMethod;
}

/* Helper function for displaying the encrypted message to the user. */
function displayEncryptedMessage(encryptionMethod, userInput) {
let str = userInput.toString().trim();
let output = encryptionMethod(str);
process.stdout.write(\nHere is your encrypted message:\n> ${output}\n)
process.exit();
}


**super-encoder.js**

// Import the encryptors functions here.
const {caesarCipher, symbolCipher, reverseCipher} = require(’./encryptors.js’);

const encodeMessage = (str) => {
// Use the encryptor functions here.
return caesarCipher(str, amount=1);

}

const decodeMessage = (str) => {
// Use the encryptor functions here.

return caesarCipher(str, (-1));
//return reverseCipher(symbolCipher(str));

}

// User input / output.

const handleInput = (userInput) => {
const str = userInput.toString().trim();
let output;
if (process.argv[2] === ‘encode’) {
output = encodeMessage(str);
}
if (process.argv[2] === ‘decode’) {
output = decodeMessage(str);
}

process.stdout.write(output + ‘\n’);
process.exit();
}

// Run the program.
process.stdout.write('Enter the message you would like to encrypt…\n> ');
process.stdin.on(‘data’, handleInput);