const diad = (char, operation) => input =>  {

   // If the operator doesnt exist, don't evaluate

   if(!input.includes(char))

     return input;

   return input.split(char)

     .map(evaluate) // deep first

     .reduce(operation); // left to right

 };

​

 const bracketsFirst = input => {

   const opening = input.lastIndexOf("("); // the most inner one

   const closing = input.indexOf(")", opening);

​

   if(opening === -1 || closing === -1) // no brackets, don't evaluate here

     return input;

​

   const before = input.slice(0, opening);

   const after = input.slice(closing + 1);

   const middle = input.slice(opening + 1, closing);

​

   return before + evaluate(middle) + after; // just evaluate the thing in the brackets 

};

​

 let context = {};

 const evaluate = input => [

   bracketsFirst,

   // Boolean algebra

   diad("||", (a, b) => a || b), // lowest operator predescendence

   diad("&&", (a, b) => a && b),

   // Comparison:

   diad("==", (a, b) => a === b),

   diad("!=", (a, b) => a != b),

   diad("<=", (a, b) => a <= b),

   diad(">=", (a, b) => a >= b),

   diad("<", (a, b) => a < b),

   diad(">", (a, b) => a > b),

   // Math:

   diad("+", (a, b) => a + b),

   diad("-", (a, b) => a - b),

   diad("*", (a, b) => a * b),

   diad("/", (a, b) => a / b),

   // The custom operator:

   diad("E", (a, b) => b.includes(a)),

   // Booleans

   a => a.trim() === "true" ? true : a,

   a => a.trim() === "false" ? false : a,

   // Number literals & Identifiers

   a => +a || context[a.trim()] || a,

   a => { throw Error("Unknown:" + a) }

 ].reduce((out, fn) => typeof out === "string" ? fn(out) : out, input);

​

//So you can do:

​

 context.a = [1,2,3];

 context.one = 1;

 console.log( evaluate("1 E a || 5 E a"),

  // evaluate("one == (2 - 1) b")

);