A function which translates a sentence to title-case
I find this code quite reasonable on the whole, but you might consider the following suggestions relating to consistency, succinctness and semantics.



Move and rename the inner helper function

translateWord is reusable as a general utility function and seems better-placed in the global scope and renamed to titleCase. This meshes with similarly-named Ruby, Python and PHP builtins (titlecase, title, ucfirst, respectively). When I see "translate", I think of linguistics or mathematics before I think of strings or casing.

Avoid excessive calls to toLowerCase

.toLowerCase() is more efficient called once on the entire sentence before splitting rather than incurring the overhead of calling it multiple times per word. With this in mind, you can skip calling the titleCase function described above if you wish.

Improve "ignore" list

if (!["of", "and", "the", "to"].includes(words[i].toLowerCase())) {


is problematic for a few reasons:


It creates a new array object for every word. Move initialization to the top of the function and create it once.
Hardcoding restricts your function's reusability. Making this ignore list a default parameter allows the client to adjust the list as needed.
Giving this array a variable name makes its purpose more obvious.
Although the array is small, it needs to be traversed linearly to perform a lookup; using a set improves semantics, readability and time complexity all at once and is the ideal structure for testing membership.


Avoid the loop

This task is a map operation: each word has a function applied to it. You can roll split, map (your for loop) and join into one call to replace, which takes a regular expression that splits on non-word characters and applies the titleCase function to each one that passes the ignore test.

Minor points


sWord.slice(0, 1) can be sWord[0]. 
sWord is an okay variable name, but str (matching your outer function) or word seems more consistent.
Unless there is a good hoisting or context reason, I'd make the outer function also use an arrow function for consistency with your inner function.


A rewrite



const titleCaseWords = (words, ignore=["of", "and", "the", "to"]) =&gt; {
  ignore = new Set(ignore);
  
  return words.replace(/\w+/g, (word, i) =&gt; {
    word = word.toLowerCase();
    
    if (i &amp;&amp; ignore.has(word)) {
      return word;
    }
    
    return word[0].toUpperCase() + word.slice(1);
  });
};

[
  "Into unmerciful the entreating stronger to of word guessing.",
  "the OLD MAN aND THE sEa"
].forEach(test =&gt; console.log(titleCaseWords(test)));