[Question]
  [
# Introduction
Try to convert words to two different unicode fonts.
# Challenge
Your task is to transform your input string into the 𝖬𝖺𝗍𝗁 𝖲𝖺𝗇𝗌 and 𝗠𝗮𝘁𝗵 𝗦𝗮𝗻𝘀 𝗕𝗼𝗹𝗱 unicode characters.
All uppercase words should become lowercase 𝗠𝗮𝘁𝗵 𝗦𝗮𝗻𝘀 𝗕𝗼𝗹𝗱 words.
* For Example: `WORD` -> `𝘄𝗼𝗿𝗱`
All lowercase words should become 𝖬𝖺𝗍𝗁 𝖲𝖺𝗇𝗌 words
* For example: `other words` -> `𝗈𝗍𝗁𝖾𝗋 𝗐𝗈𝗋𝖽𝗌`
All mixed case words should remain unchanged
* For example: `Mixed Case Words` -> `Mixed Case Words`
Periods and spaces should remain unchanged.
Words are separated by spaces or periods
* For example (highlighted things are words):
> 
> `Hello`. `This` `is` `a` `word`. `S`.`O`. `are` `these`
> 
> 
> 
* Inputs: A string containing letters, spaces, and periods (`[A-Za-z .]+`)
* Output: The formatted string
As this is a golfing challenge, the lowest number of bytes wins
# Example Input and Output
Input:
> 
> This is an example STRING that c.o.U.L.d. be INPUTTED. It can CONTAIN multiple sentences.
> 
> 
> 
Output:
> 
> This 𝗂𝗌 𝖺𝗇 𝖾𝗑𝖺𝗆𝗉𝗅𝖾 𝘀𝘁𝗿𝗶𝗻𝗴 𝗍𝗁𝖺𝗍 𝖼.𝗈.𝘂.𝗹.𝖽. 𝖻𝖾 𝗶𝗻𝗽𝘂𝘁𝘁𝗲𝗱. It 𝖼𝖺𝗇 𝗰𝗼𝗻𝘁𝗮𝗶𝗻 𝗆𝗎𝗅𝗍𝗂𝗉𝗅𝖾 𝗌𝖾𝗇𝗍𝖾𝗇𝖼𝖾𝗌.
> 
> 
> 
# Reference
Math Sans Bold: 𝗮𝗯𝗰𝗱𝗲𝗳𝗴𝗵𝗶𝗷𝗸𝗹𝗺𝗻𝗼𝗽𝗾𝗿𝘀𝘁𝘂𝘃𝘄𝘅𝘆𝘇 (characters 120302 through 120327)
Math Sans: 𝖺𝖻𝖼𝖽𝖾𝖿𝗀𝗁𝗂𝗃𝗄𝗅𝗆𝗇𝗈𝗉𝗊𝗋𝗌𝗍𝗎𝗏𝗐𝗑𝗒𝗓 (characters 120250 through 120275)
  
[Answer]
# [QuadR](https://github.com/abrudz/QuadRS), ~~45~~ 43 bytes
-2 thanks to ngn.
```
\w+
⎕UCS a+(2>≢b)×120153+84×⊃b←∪96>a←⎕UCS⍵M
```
Since TIO scrambles Unicode output from QuadR, here is a screenshot of using QuadR as an APL library in an interactive session:
[![interactive session transcript](https://i.snag.gy/V9kd4v.jpg)](https://i.snag.gy/V9kd4v.jpg)
---
`\w+` replace words with the result of applying the following code to them:
`⍵M` the found word
  
`⎕UCS` the **U**niversal **C**haracter **S**et code points of that
  
`a←` store that in `a`
  
`96>` 0 or 1 for whether 96 is greater than each of those
  
`∪` take just the unique; `[0]` or `[1]` or `[0,1]` or `[1,0]`
  
`b←` store that in `b`
  
`⊃` pick the first from that
  
`84×` multiply 84 with that
  
`120153+` add 120153 to that
  
`(`…`)×` multiply the following with that:
  
 `≢b` the tally (length) of `b` (`1` if single-case, `2` if mixed-case)
  
 `2>` 0 or 1 for whether two is greater than that (`1` if single-case, `0` if mixed-case)
  
`a+` the original code points added to that
  
`⎕UCS` convert the resulting code points back to characters
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~63~~ ~~57~~ 53 bytes
-6 thanks to Erik the Outgolfer. -4 thanks to ngn.
Anonymous tacit prefix function.
```
'\w+'⎕R{⎕UCS a+(2>≢b)×120153+84×⊃b←∪96>a←⎕UCS⍵.Match}
```
Since TIO scrambles Unicode output from Dyalog APL, here is a screenshot of the code in action: 
[![code in action](https://i.snag.gy/IRsVgm.jpg)](https://i.snag.gy/IRsVgm.jpg)
  
---
`'\w+'⎕R` PCRE **R**eplace words with the result of applying the following…
`{`...`}` anonymous lambda:
 `⍵.Match` the found word
 `⎕UCS` the **U**niversal **C**haracter **S**et code points of that
 `a←` store that in `a`
 `96>` 0 or 1 for whether 96 is greater than each of those
 `∪` take just the unique; `[0]` or `[1]` or `[0,1]` or `[1,0]`
 `b←` store that in `b`
 `⊃` pick the first from that
 `84×` multiply 84 with that
 `120153+` add 120153 to that
 `(`…`)×` multiply the following with that:
  `≢b` the tally (length) of `b` (`1` if single-case, `2` if mixed-case)
  `2>` 0 or 1 for whether two is greater than that (`1` if single-case, `0` if mixed-case)
 `a+` the original code points added to that
 `⎕UCS` convert the resulting code points back to characters
[Answer]
# [Clean](https://clean.cs.ru.nl), ~~268~~ ~~265~~ ~~232~~ 224 bytes
As a neat bonus, this works with strings containing *any* character. [Including nulls.](https://tio.run/##bVPbbtswDH3XVxBdgMao47i7AEUR994OAYKsWJynOkAUWa61yZIn0V0M7NuXyZesLdoHXchDnkOKNpOcql2h00pyKKhQO1GU2iAsMJ2Jje@OqcLmuNJa@jHfYrBUgumUvzKC5XVODakiYZdlyQ2R7nYpy5ySAfsjgUWZ0YWjGqJ2O7Cj44/h8ZdPRyIbVsC8k88QehEj5w@5b09xFT20QD45E3amf3MD1hsOmMeShE1GfdCqCXehg3xFLmz0UCfJdjJ6NLoqr@phQmETSaCR2zae9evJCM63q32Dr6q/Ve4Q6tEGy/juhIzHQDf6iUNWKYZCKwupVocIhv@qhOGAubDQEfkg8NDCj8oiVJangBqwMgoorBdoHOkahHJOZzfk8MbZO1pV5fLzZ10ojX4SqWPVStagOE/tc0Ybvm5ffu2D0tgprEnz1s0E7xxNXyboht@KQkhqZO33Ldj/NRf0J2@1U2FLSWsnAJxa4WZJstPTYac5OmsUPJK18@x8hKDDG//orPN4BCPUe3SB1CD5ALa1IYKD2GknYbOoSkK@pUUpeRIu4u/T@dckxJxiErJAB8tgFqRBEm4cOp3fL@P49saZ0wZuUq@/zePL6TwJi0qiaEksV8gV4zY4eKnpvrt@2KAh8/aAe5O2cYHQwy@TLvrra6KGwDXfx79HVToH0o3kJNozjMdvU501cOvdynZ/WSbpo92NprPdTa1oIVhn3EuKmTZFa3S/6T8 "Clean – Try It Online")
```
import StdLib,StdInt,StdBool,Text.Unicode,Text.Unicode.UChar
u=isUpper
l=isAlpha
$c|l c=fromInt(toInt c+120153+if(u c)84 0)=c
?[h,s:t]=[if(u h<>isLower s)($c)c\\c<-[h,s:t]]
?[h]=[$h]
@s=[y\\x<-groupBy(\a b=l a&&l b)s,y<- ?x]
```
[Try it online!](https://tio.run/##bVNtb9owEP7uX3HqUEvUENq9SBUi9L0TEmLVCJ8ACeM4jTfHzmynI9J@@9jlhbWo/ZDY99zd89z5bCY5VbtMx4XkkFGhdiLLtXEwc/FEbHxcxspVy43W0o/41gVzJZiO@YERzG9TakgRCjvPc26IxN21zFNKOuyPBBYmRmdI1XUa/8BOzz@enX/5dCqSbgHMu/gMZ17IyOUi9e3ArcJF7UiHI2En@jc3YL1uh3lsuWTDXhu0qsIxtJOuyJUNF@VyuR32nowu8puyu6SwCSXQ42MJG8/65bAHl9vVvsGD6u8VLkI92WAePVyQfh/oRj9zSArFnNDKQqzViQPDfxXCcHCpsNAQ@SDciYUfhXVQWB6D0@AKo4DCeuYMkq5BKATRrsjhDdgCtarC/PRFF3Kjn0WMrFrJEhTnsX3JqMPX9cmvfVDaNQprUp11NcEHpGnLBF3xW5EJSY0s/bYF@7/mjP7ktXYsbC5piQLAqRU4S5IMBt1GszeqFDyS1PNsMEIc@iu8N2oQj7jQ6b135qhx5APY2oYQjqJWmyrgW5rlePdm0ffx9CsWQPFyBDqYB5MgDmDDYTx9nEfR/V0AY3Rhyu23aXQ9nkJWSCeqXMuV44pxGxy9lsGr1s4XNCTe3oHHUPcqHLTu10lX7faQqCLAftv496hyBBzdSE7CPUO//zYVrQ5@71a2@8sSSZ/srjee7O5KRTPBGuNRUpdok9VG8zL/AQ "Clean – Try It Online")
Defines the function `@`, taking a `UString` and returning a `UString`
[Answer]
# C, 292 characters, 448 bytes (in UTF-8)
```
char*t;s,i,k;p(l){for(l=s=*t/96,i=k=strlen(t);i--;)t[i]/96-s&&++l;for(l=l-s&&write(1,t,k);!l&++i<k;)write(1,s?"𝖺𝖻𝖼𝖽𝖾𝖿𝗀𝗁𝗂𝗃𝗄𝗅𝗆𝗇𝗈𝗉𝗊𝗋𝗌𝗍𝗎𝗏𝗐𝗑𝗒𝗓"+t[i]*4-388:"𝗮𝗯𝗰𝗱𝗲𝗳𝗴𝗵𝗶𝗷𝗸𝗹𝗺𝗻𝗼𝗽𝗾𝗿𝘀𝘁𝘂𝘃𝘄𝘅𝘆𝘇"+t[i]*4-260,4);}f(char*s){char b[strlen(s)];for(t=b;*s;++s)*s<47?(*t=0),p(t=b),putchar(*s):(*t++=*s);*t=0;p(t=b);}
```
[Try it online!](https://tio.run/##PdDLTttAFAbgfZ5i8CKa8Q1oI0gzsRACVEVCoWqdVZSF4zrNyI6JMoNAiiK1QKH3llbC3uQVKJRLW@jllXiD8DsBLH8a2@ccz6/xrRe@Pxr5ba@nKy5NYYa8SyPWb633aORIR1fTj@ZM4YSOVL0oiKliXFgWZ6ouGihZMp83jIhP@qPsdbMnVEBnTWWGjE9FKItyyNndZ7mgXQ8PL@EK/sBf@Af/r4fJS3gF27ADu/Aa9mAf3sBbeAfv4QN8hE/wGb7AAXyFb5qRpdQL1sNisYRdkyP4DsdwAj/gFM7gHC7gJ/yC34CUCVImSJkgZYKUCVKmSJkiZYqUKVKmSJkiZYqU6f79rg/mZswC44MWHZ@vZP1sJc367VFK1hifm3KaXJfcMCTTZbkwv0B15cwws5tVsGyobI7iByVUDMPBE89a@KSDD0YiVqTjiZiyXD9HcLWo5raFJLi9mARbXqcbBeSZ@7RSfUxU21PEt9ftmr1qP7dJMyCV6pOa664s26SCEkaW1qruYqVKOhuREtmsDGIVxH4gbY3x3GB0Aw)
**Unrolled:**
```
char*t;
s,i,k;
p(l)
{
    for (l=s=*t/96, i=k=strlen(t); i--;)
        t[i]/96-s && ++l;
    for (l=l-s&&write(1, t, k); !l&++i<k;)
        write(1, s ? "𝖺𝖻𝖼𝖽𝖾𝖿𝗀𝗁𝗂𝗃𝗄𝗅𝗆𝗇𝗈𝗉𝗊𝗋𝗌𝗍𝗎𝗏𝗐𝗑𝗒𝗓"+t[i]*4-388
                   : "𝗮𝗯𝗰𝗱𝗲𝗳𝗴𝗵𝗶𝗷𝗸𝗹𝗺𝗻𝗼𝗽𝗾𝗿𝘀𝘁𝘂𝘃𝘄𝘅𝘆𝘇"+t[i]*4-260, 4);
}
f(char*s)
{
    char b[strlen(s)];
    for (t=b; *s; ++s)
        *s<47 ? (*t=0), p(t=b), putchar(*s) : (*t++=*s);
    *t = 0;
    p(t=b);
}
```
[Answer]
# Java 8, ~~221~~ ~~219~~ ~~203~~ 201 bytes
```
s->{StringBuffer r=new StringBuffer();for(String x:s.split("(?<=[\\. ])|(?=[\\. ])"))x.codePoints().forEach(c->r.appendCodePoint(c+(x.matches("[A-Z]+")?120237:x.matches("[a-z]+")?120153:0)));return r;}
```
I have to use a `StringBuffer` instead of a regular `String` to use `.appendCodePoint`, unfortunately..
**Explanation:**
[Try it online.](https://tio.run/##jZJvS8MwEMbf71McfZUgDZtDhNVt6CYy0Dq0MnDbiyzNbGablCTV@qefvWbYgnujQgg5fvfc3XNkR1@or3Iud/FzzVJqDNxQIT86AEJarreUcQj3IcC91UI@XRTbLdfA0HcIBgeOVh13GUutYBCChCHUxh99HEj0UPLXgyoIB1ul20rlwBCTp8IiD43PhsvVisAaf6Jx@/QwLglTMZ8rN5xBmDj1JWUJYv5IE5o7H/Gk5YgdoZJk1LKEG@Qtz/3H9ZGHx73j7nH/dPATUf@9Rb2T/qCLMQ40t4WWoIOqDvbm8mKTOnONxxclYsjcpprhl2uKmy29GcszogpLckdsKpEkDHmL27upMxD8mqRs4hb1qnRs/sy9ESWPYUINh8W/BFEiDLhDJfCSZnnK4T66m4VXYBNqgRFFHsg1iQlsOMzC@UMUXU4JzBxyksltGJ3PQsiK1Iq91nD3QSTjhjSdq05VfwE)
```
s->{                           // Method with String parameter and StringBuffer return-type
  StringBuffer r=new StringBuffer();
                               //  Resulting StringBuffer
  for(String x:s.split("(?<=[\\. ])|(?=[\\. ])"))
                               //  Split by space or dot, and keep them as separate items,
                               //  and loop over all those substrings
   x.codePoints().forEach(c->  //   Inner loop over the codepoints of that substring
      r.appendCodePoint(       //    Convert int to char, and append it to the result:
        c                      //     The next codepoint of the substring
        +(x.matches("[A-Z]+")? //     If the word is fully uppercase:
           120237              //      Add 120237 to convert it to Math Sans Bold
          :x.matches("[a-z]+")?//     Else-if the word is fully lowercase:
           120153              //      Add 120153 to convert it to Math Sans
          :                    //     Else (mixed case, or a dot/space)
           0)));               //      Leave the codepoint (and thus the character) as is
  return r;}                   //  Return the resulting StringBuffer
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~172~~ 170 bytes
```
(s#w)r=[x|all(`elem`s)w,c<-w,(x,k)<-zip r s,c==k]
t[]=[]
t w=filter(>[])[['A'..'Z']#w$['𝗮'..],['a'..'z']#w$['𝖺'..],w]!!0
f s|(a,b:c)<-span(>'.')s=t a++b:f c|1>0=t s
```
[Try it online!](https://tio.run/##PY1LasMwGIT3OcWfB8gmiki3ITKEthRDcEvjbCoEkVUZG8uusRRkgs/RrnqFHqCn6g1cpYvCwDDfMEwhTKW0HsfAzF3YUdYPQuvgpLSqTyZ0WG5XDgc9rsLt6lK20IHBktKKTyzjlHkDR/NSW9UFEeMhY2iHCEEviM/dgqGfz48vnzlmSFz55Z@/f/9xx6fT9SQHMwQCZxvpf0wrmiBCBIWGWhDLZbbJQQ430dpHM9aibIBCe7YH2@0bWEAOs7QoDXiJBlQv6lYrOKTPcfIAthAWJHkjR7InrwQyBXHydEzT@zsCsa/85PYxSXdxAvVZ2/K6NaqxqpHKkNn4Cw "Haskell – Try It Online")
Fairly straightforward. The `#` operator takes the set `s` of charcters (upper or lower case) the word `w`, and the math sans set `r`. It returns the word in the math sans font if all the characters in the word are in `s` or the empty list otherwise. The `t` function takes a word and tries all three possiblities (all upper, all lower, or mixed), returning the first one that isn't empty. The `f` function finds the first word by using `span`, transforming it with `t` and concatenating it with the separator (either `.` or space) and recurring on the rest of the string. The alternate case is for if span can't find a separator; we just transform the string.
Edit: Thanks to @Laikoni for taking off 2 bytes! I'm not used to the whole "operator that takes three arguments" thing
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 34 bytes
```
e€ØBŒg
ṁÇµŒl,Œuiị“¡ẓƬ“¡ẓġ“’×Ç+OỌµ€
```
[Try it online!](https://tio.run/##y0rNyan8/z/1UdOawzOcjk5K53q4s/Fw@6GtRyfl6BydVJr5cHf3o4Y5hxY@3DX52BoY68hCIOtRw8zD0w@3a/s/3N1zaCvQgP///4dkZBYrAFFinkJqRWJuQU6qQnBIkKefu0JJRmKJQrJevl6ono9eip5CUqqCp19AaEiIq4uegidQCqjF2d8vxNHTTyG3NKckE6S3ODWvJDUvObVYDwA "Jelly – Try It Online")
Full program.
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 84 bytes
```
/\b[A-Z]+\b/_(`.
ĵ$&
)T`L`ۮ-܇
/\b[a-z]+\b/_(`.
ĵ$&
)T`l`ں-ۓ
T`ÿ-߿`퟿-
```
[Try it online!](https://tio.run/##K0otycxLNPz/Xz8mKdpRNypWOyZJP14jQY/ryFYVNS7NkASfhNvrdO@0c4EUJOpWYSrISbi1S/f2ZK6QhMP7de/vT3g7f7/uu4aG//9DMjKLFYAoMU8htSIxtyAnVSE4JMjTz12hJCOxRCFZL18vVM9HL0VPISlVwdMvIDQkxNVFT8ETKAXU4uzvF@Lo6aeQW5pTkgnSW5yaV5Kal5xarAcA "Retina – Try It Online") Explanation: Retina is a .NET application and therefore works in UTF-16 internally. Unfortunately as the Math Sans characters aren't in the BMP I can't directly transliterate them because the number of code points differs. Worse, I can't use unpaired surrogates at all. Instead, I shift the appropriate words into characters in the range `0xFF-0x7FF` which conveniently only take two bytes to encode, plus I also prefix them with the `0x135` character. Finally I map that range onto the a range that overlaps the unpaired surrogates, creating valid BMP pairs.
[Answer]
# Python 3, ~~173~~ ~~122~~ 120 bytes
```
lambda s:''.join(chr(ord(c)+120153*t.islower()+120237*t.isupper())for t in re.split(r'\b(\w+)\b',s)for c in t)
import re
```
-51 bytes from ShreevatsaR
-2 bytes from abccd
[Try it online!](https://tio.run/##Hc4xa8MwEIbhOfoVt1lqimhiSiDQwaUuHZqmYI9eZFnGKrIkTmec/HrX8XgvDx8X7zQEny/9W7M4NbadgnTOMvkXrOd6QB6w41rsD8eXw2v@RNImF2aDfEvH/LSlKcZHEn1AILAe0MgUnSWOWdPyZt6Lps2e0wb0A5BgdowBaaUL4f3MdvNgnYEaJ7Meu4jWE@@59XGidVowc9MmEpTXzxIx4IqiSmnZ3tEqGRgVDZCUT@z9@v0Bl6L@gqr4qdjF3kwHm6nLqma/k9c0KbLBSygqCbNxTv4D "Python 3 – Try It Online")
Splits on word boundaries (`re.split(r'\b(\w+)\b',s)`), then maps lowercase words to 𝗅𝗈𝗐𝖾𝗋𝖼𝖺𝗌𝖾 𝗆𝖺𝗍𝗁 𝗌𝖺𝗇𝗌 (`+120153*t.islower()`), and uppercase words to 𝗯𝗼𝗹𝗱 𝗺𝗮𝘁𝗵 𝘀𝗮𝗻𝘀 (`+120237*t.isupper()`), and leaves mixed-case words alone, then `join`s the words back up.
Ungolfed and un-lambda-ed:
```
def f(s):
    words = re.split(r'\b(\w+)\b', s)
    ret = ''
    for word in words:
        for char in word:
            if word.isupper():
                ret += chr(ord(c) + 120237)
            elif word.islower():
                ret += chr(ord(c) + 120153)
            else:
                ret += c
    return ret
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt/), ~~34~~ ~~33~~ ~~32~~ 31 bytes
Includes an unprintable (charcode 153) after the last `#`.
```
rV="%b%A+%b"Èc+#x#í
rVv Èc+#x#
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=clY9IiViJUErJWIiyGMrI3gj7QpyVnYgyGMrI3gjmQ==&input=IlRoaXMgaXMgYW4gZXhhbXBsZSBTVFJJTkcgdGhhdCBjLm8uVS5MLmQuIGJlIElOUFVUVEVELiBJdCBjYW4gQ09OVEFJTiBtdWx0aXBsZSBzZW50ZW5jZXMuIg==)
---
## Explanation
```
                        :Implicit input of string U
r                       :Replace
   "%b%A+%b"            :/\b[A-Z]+\b/g
 V=                     :Assign ^that to variable V
            È           :Run each match through a function
             c          :Map over the codepoints of the current match
              +#x#í     :  Add 120237
\n                      :Assign the result of that replacement to variable U
rVv                     :Another replacement, this time with V lowercased to give us the RegEx /\b[a-z]+\b/g
    Èc+#x#              :And, again, map over the codepoints of each match, this time adding 120153 to each
```
---
## Original 32 Byte Japt v2 Solution
```
r/\b(\A+|\a+)\b/Èc_+#x#+#T*(X¶u
```
[Try it](https://ethproductions.github.io/japt/?v=2.0a0&code=ci9cYihcQSt8XGErKVxiL8hjXysjeCOZKyNUKihYtnU=&input=IlRoaXMgaXMgYW4gZXhhbXBsZSBTVFJJTkcgdGhhdCBjLm8uVS5MLmQuIGJlIElOUFVUVEVELiBJdCBjYW4gQ09OVEFJTiBtdWx0aXBsZSBzZW50ZW5jZXMuIg==)
```
r                                     :Replace
 /\b(\A+|\a+)\b/                      :...all matches of this RegEx (\A=[A-Z], \a=[a-z])
                È                     :Pass each match through a function, with X being the current match
                 c_                   :Pass the codepoints of X through a function
                   +                  :Add to the current codepoint
                    #x#               :120153 (there's an unprintable after the second #)
                        +#T           :Plus 84
                           *          :  Multiplied by
                            (X¶u      :  Is X equal to its uppercase self
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 33 bytes
```
€aγ€g£εÐ.u•1Ù„•*s.l•1Ùm•*+sÇ+çJ}J
```
[Try it online!](https://tio.run/##MzBNTDJM/f//UdOaxHObgWT6ocXnth6eoFf6qGGR4eGZjxrmARlaxXo5EH4uiKddfLhd@/Byr1qv//9DMjKLFYAoMU8htSIxtyAnVSE4JMjTz12hJCOxRCFZL18vVM9HL0VPISlVwdMvIDQkxNVFT8ETKAXU4uzvF@Lo6aeQW5pTkgnSW5yaV5Kal5xarAcA "05AB1E – Try It Online")
[Answer]
# JavaScript (ES6), ~~99~~ ~~114~~ 113 bytes
```
s=>s.replace(/\b([A-Z]+|[a-z]+)\b/g,e=>e.replace(/./g,f=>String.fromCodePoint(f.charCodeAt()+120153+(f<'a')*84)))
```
(Thanks to @pfg for pointing out an important flaw in my first solution.)
-1 bytes thanks to @Neil.
**Snippet:**
```
let f = 
s=>s.replace(/\b([A-Z]+|[a-z]+)\b/g,e=>e.replace(/./g,f=>String.fromCodePoint(f.charCodeAt()+120153+(f<'a')*84)))
d.innerHTML=f('This is an example STRING that c.o.U.L.d. be INPUTTED. It can CONTAIN multiple sentences.');
```
```
<p id="d">
```
]