update other pages with the new exception API

Author: tsnobip

pages/docs/manual/v12.0.0/async-await.mdx

@@ -130,15 +130,15 @@ You may use `try / catch` or `switch` to handle exceptions during async executio
 ```res
 // For simulation purposes
 let authenticate = async () => {
-  raise(Exn.raiseRangeError("Authentication failed."))
+  JsError.RangeError.throwWithMessage("Authentication failed.")
 }
 
 let checkAuth = async () => {
   try {
     await authenticate()
   } catch {
-  | Exn.Error(e) =>
-    switch Exn.message(e) {
+  | JsExn(e) =>
+    switch JsExn.message(e) {
     | Some(msg) => Console.log("JS error thrown: " ++ msg)
     | None => Console.log("Some other exception has been thrown")
     }
@@ -152,14 +152,14 @@ You may unify error and value handling in a single switch as well:
 
 ```res
 let authenticate = async () => {
-  raise(Exn.raiseRangeError("Authentication failed."))
+  JsError.RangeError.throwWithMessage("Authentication failed.")
 }
 
 let checkAuth = async () => {
   switch await authenticate() {
   | _ => Console.log("ok")
-  | exception Exn.Error(e) => 
-    switch Exn.message(e) {
+  | exception JsExn(e) => 
+    switch JsExn.message(e) {
     | Some(msg) => Console.log("JS error thrown: " ++ msg)
     | None => Console.log("Some other exception has been thrown")
     }

pages/docs/manual/v12.0.0/function.mdx

@@ -446,7 +446,7 @@ Both JS exceptions and exceptions defined in ReScript can be caught. The compile
 ```res example
 exception SomeReScriptException
 
-let somethingThatMightThrow = async () => raise(SomeReScriptException)
+let somethingThatMightThrow = async () => throw(SomeReScriptException)
 
 let someAsyncFn = async () => {
   switch await somethingThatMightThrow() {

pages/docs/manual/v12.0.0/lazy-values.mdx

@@ -62,7 +62,7 @@ The first time `Lazy.get` is called, the expensive computation happens and the r
 
 ## Exception Handling
 
-For completeness' sake, our files read example might raise an exception because of `readdirSync`. Here's how you'd handle it:
+For completeness' sake, our files read example might throw an exception because of `readdirSync`. Here's how you'd handle it:
 
 <CodeTab labels={["ReScript", "JS Output"]}>
 

pages/docs/manual/v12.0.0/overview.mdx

@@ -187,8 +187,8 @@ canonical: "/docs/manual/v12.0.0/overview"
 
 | JavaScript                                | ReScript                                     |
 | ----------------------------------------- | -------------------------------------------- |
-| `throw new SomeError(...)`                | `raise(SomeError(...))`                      |
-| `try {a} catch (err) {...} finally {...}` | `try a catch { \| SomeError(err) => ...}` \* |
+| `throw new SomeError(...)`                | `throw(SomeException(...))`                      |
+| `try {a} catch (err) {...} finally {...}` | `try a catch { \| SomeException(err) => ...}` \* |
 
 \* No finally.
 

pages/docs/manual/v12.0.0/scoped-polymorphic-types.mdx

@@ -92,9 +92,9 @@ Scoped polymorphic types work only when they are directly applied to let-binding
 ```res
 exception Abort
 
-let testExn: 'a. unit => 'a = () => raise(Abort) // Works!
+let testExn: 'a. unit => 'a = () => throw(Abort) // Works!
 
-let testExn2 = (): 'a. 'a = raise(Abort) // Syntax error!
+let testExn2 = (): 'a. 'a = throw(Abort) // Syntax error!
 type fn = 'a. 'a => unit // Syntax error!
 ```