diff --git a/.gitignore b/.gitignore
index 79ff8c108..bcf45e895 100644
--- a/.gitignore
+++ b/.gitignore
@@ -37,3 +37,8 @@ pages/docs/**/**/llms.mdx
 
 public/playground-bundles/
 public/_redirects
+
+
+dist
+build
+.react-router
\ No newline at end of file
diff --git a/app/layouts/BlogArticleLayout.mjs b/app/layouts/BlogArticleLayout.mjs
new file mode 100644
index 000000000..3a9010037
--- /dev/null
+++ b/app/layouts/BlogArticleLayout.mjs
@@ -0,0 +1,299 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Fs from "fs";
+import * as Blog from "../../src/Blog.mjs";
+import * as Icon from "../../src/components/Icon.mjs";
+import * as Meta from "../../src/components/Meta.mjs";
+import * as Util from "../../src/common/Util.mjs";
+import * as Path from "path";
+import * as BlogApi from "../../src/common/BlogApi.mjs";
+import * as DateStr from "../../src/common/DateStr.mjs";
+import * as Markdown from "../../src/components/Markdown.mjs";
+import * as MdxRemote from "../../src/bindings/MdxRemote.mjs";
+import Link from "next/link";
+import * as MainLayout from "../../src/layouts/MainLayout.mjs";
+import * as Stdlib_Option from "rescript/lib/es6/Stdlib_Option.js";
+import * as BlogFrontmatter from "../../src/common/BlogFrontmatter.mjs";
+import * as NextMdxRemote from "next-mdx-remote";
+import * as Primitive_option from "rescript/lib/es6/Primitive_option.js";
+import * as JsxRuntime from "react/jsx-runtime";
+import * as MarkdownComponents from "../../src/components/MarkdownComponents.mjs";
+import * as Serialize from "next-mdx-remote/serialize";
+
+let middleDotSpacer = " " + (String.fromCharCode(183) + " ");
+
+let Params = {};
+
+function BlogArticleLayout$Line(props) {
+  return JsxRuntime.jsx("div", {
+    className: "block border-t border-gray-20"
+  });
+}
+
+let Line = {
+  make: BlogArticleLayout$Line
+};
+
+function BlogArticleLayout$AuthorBox(props) {
+  let author = props.author;
+  let authorImg = JsxRuntime.jsx("img", {
+    className: "h-full w-full rounded-full",
+    src: author.imgUrl
+  });
+  let handle = author.social;
+  let tmp;
+  tmp = handle.TAG === "X" ? "https://x.com/" + handle._0 : "https://bsky.app/profile/" + handle._0;
+  return JsxRuntime.jsxs("div", {
+    children: [
+      JsxRuntime.jsx("div", {
+        children: authorImg,
+        className: "w-10 h-10 bg-berry-40 block rounded-full mr-3"
+      }),
+      JsxRuntime.jsxs("div", {
+        children: [
+          JsxRuntime.jsx("a", {
+            children: author.fullname,
+            className: "hover:text-gray-80",
+            href: tmp,
+            rel: "noopener noreferrer"
+          }),
+          JsxRuntime.jsx("div", {
+            children: author.role,
+            className: "text-gray-60"
+          })
+        ],
+        className: "body-sm"
+      })
+    ],
+    className: "flex items-center"
+  });
+}
+
+let AuthorBox = {
+  make: BlogArticleLayout$AuthorBox
+};
+
+function BlogArticleLayout$BlogHeader(props) {
+  let articleImg = props.articleImg;
+  let category = props.category;
+  let date = DateStr.toDate(props.date);
+  let authors = [props.author].concat(props.co_authors);
+  return JsxRuntime.jsxs("div", {
+    children: [
+      JsxRuntime.jsxs("div", {
+        children: [
+          JsxRuntime.jsxs("div", {
+            children: [
+              category !== undefined ? JsxRuntime.jsxs(JsxRuntime.Fragment, {
+                  children: [
+                    category,
+                    middleDotSpacer
+                  ]
+                }) : null,
+              Util.$$Date.toDayMonthYear(date)
+            ],
+            className: "text-gray-60 body-sm mb-5"
+          }),
+          JsxRuntime.jsx("h1", {
+            children: props.title,
+            className: "hl-title"
+          }),
+          Stdlib_Option.mapOr(props.description, null, desc => {
+            if (desc === "") {
+              return JsxRuntime.jsx("div", {
+                className: "mb-8"
+              });
+            } else {
+              return JsxRuntime.jsx("div", {
+                children: JsxRuntime.jsx("p", {
+                  children: desc,
+                  className: "body-lg"
+                }),
+                className: "text-gray-80 mt-1 mb-8"
+              });
+            }
+          }),
+          JsxRuntime.jsx("div", {
+            children: authors.map(author => JsxRuntime.jsx("div", {
+              children: JsxRuntime.jsx(BlogArticleLayout$AuthorBox, {
+                author: author
+              }),
+              className: "mt-4 md:mt-0 md:ml-8 first:ml-0 min-w-[8.1875rem]"
+            }, author.username)),
+            className: "flex flex-col md:flex-row mb-12"
+          })
+        ],
+        className: "w-full max-w-740"
+      }),
+      articleImg !== undefined ? JsxRuntime.jsx("div", {
+          children: JsxRuntime.jsx("img", {
+            className: "h-full w-full object-cover max-h-[33.625rem]",
+            src: articleImg
+          }),
+          className: "-mx-8 sm:mx-0 sm:w-full bg-gray-5-tr md:mt-24"
+        }) : JsxRuntime.jsx("div", {
+          children: JsxRuntime.jsx(BlogArticleLayout$Line, {}),
+          className: "max-w-740 w-full"
+        })
+    ],
+    className: "flex flex-col items-center"
+  });
+}
+
+let BlogHeader = {
+  make: BlogArticleLayout$BlogHeader
+};
+
+function $$default(props) {
+  let mdxSource = props.mdxSource;
+  let children = JsxRuntime.jsx(NextMdxRemote.MDXRemote, {
+    frontmatter: mdxSource.frontmatter,
+    compiledSource: mdxSource.compiledSource,
+    scope: mdxSource.scope,
+    components: MarkdownComponents.default
+  });
+  let fm = BlogFrontmatter.decode(mdxSource.frontmatter);
+  let archivedNote = props.isArchived ? JsxRuntime.jsx("div", {
+      children: JsxRuntime.jsx(Markdown.Warn.make, {
+        children: JsxRuntime.jsxs(Markdown.P.make, {
+          children: [
+            JsxRuntime.jsx("span", {
+              children: "Important: ",
+              className: "font-bold"
+            }),
+            "This is an archived blog post, kept for historical reasons. Please note that this information might be outdated."
+          ]
+        })
+      }),
+      className: "mb-10"
+    }) : null;
+  let content;
+  if (fm.TAG === "Ok") {
+    let match = fm._0;
+    let description = match.description;
+    let title = match.title;
+    content = JsxRuntime.jsxs("div", {
+      children: [
+        JsxRuntime.jsx(Meta.make, {
+          siteName: "ReScript Blog",
+          description: description === null ? undefined : Primitive_option.some(description),
+          title: title + " | ReScript Blog",
+          ogImage: Stdlib_Option.getOr(Primitive_option.fromNull(match.previewImg), Blog.defaultPreviewImg)
+        }),
+        JsxRuntime.jsx("div", {
+          children: JsxRuntime.jsx(BlogArticleLayout$BlogHeader, {
+            date: match.date,
+            author: match.author,
+            co_authors: match.co_authors,
+            title: title,
+            description: description === null ? undefined : Primitive_option.some(description),
+            articleImg: Primitive_option.fromNull(match.articleImg)
+          }),
+          className: "mb-10 md:mb-20"
+        }),
+        JsxRuntime.jsx("div", {
+          children: JsxRuntime.jsxs("div", {
+            children: [
+              archivedNote,
+              children,
+              JsxRuntime.jsxs("div", {
+                children: [
+                  JsxRuntime.jsx(BlogArticleLayout$Line, {}),
+                  JsxRuntime.jsxs("div", {
+                    children: [
+                      JsxRuntime.jsx("div", {
+                        children: "Want to read more?",
+                        className: "text-24 sm:text-32 text-center text-gray-80 font-medium"
+                      }),
+                      JsxRuntime.jsxs(Link, {
+                        href: "/blog",
+                        children: [
+                          "Back to Overview",
+                          JsxRuntime.jsx(Icon.ArrowRight.make, {
+                            className: "ml-2 inline-block"
+                          })
+                        ],
+                        className: "text-fire hover:text-fire-70"
+                      })
+                    ],
+                    className: "pt-20 flex flex-col items-center"
+                  })
+                ],
+                className: "mt-12"
+              })
+            ],
+            className: "max-w-740 w-full"
+          }),
+          className: "flex justify-center"
+        })
+      ],
+      className: "w-full"
+    });
+  } else {
+    content = JsxRuntime.jsx("div", {
+      children: JsxRuntime.jsxs(Markdown.Warn.make, {
+        children: [
+          JsxRuntime.jsx("h2", {
+            children: "Could not parse file '_blogposts/" + (props.path + ".mdx'"),
+            className: "font-bold text-gray-80 text-24 mb-2"
+          }),
+          JsxRuntime.jsx("p", {
+            children: "The content of this blog post will be displayed as soon as all\n            required frontmatter data has been added."
+          }),
+          JsxRuntime.jsx("p", {
+            children: "Errors:",
+            className: "font-bold mt-4"
+          }),
+          fm._0
+        ]
+      })
+    });
+  }
+  return JsxRuntime.jsx(MainLayout.make, {
+    children: content
+  });
+}
+
+async function getStaticProps(ctx) {
+  let params = ctx.params;
+  let match = BlogApi.getAllPosts().find(param => BlogApi.blogPathToSlug(param.path) === params.slug);
+  let path = match !== undefined ? match.path : params.slug;
+  let filePath = Path.resolve("_blogposts", path);
+  let isArchived = path.startsWith("archive/");
+  let source = Fs.readFileSync(filePath);
+  let mdxSource = await Serialize.serialize(source, {
+    parseFrontmatter: true,
+    mdxOptions: MdxRemote.defaultMdxOptions
+  });
+  return {
+    props: {
+      mdxSource: mdxSource,
+      isArchived: isArchived,
+      path: path
+    }
+  };
+}
+
+async function getStaticPaths() {
+  let paths = BlogApi.getAllPosts().map(postData => ({
+    params: {
+      slug: BlogApi.blogPathToSlug(postData.path)
+    }
+  }));
+  return {
+    paths: paths,
+    fallback: false
+  };
+}
+
+export {
+  middleDotSpacer,
+  Params,
+  Line,
+  AuthorBox,
+  BlogHeader,
+  $$default as default,
+  getStaticProps,
+  getStaticPaths,
+}
+/* middleDotSpacer Not a pure module */
diff --git a/app/layouts/BlogArticleLayout.res b/app/layouts/BlogArticleLayout.res
new file mode 100644
index 000000000..513bff29a
--- /dev/null
+++ b/app/layouts/BlogArticleLayout.res
@@ -0,0 +1,239 @@
+/*
+      This module is responsible for statically prerendering each individual blog post.
+ General concepts:
+      -----------------------
+      - We use webpack's "require" mechanic to reuse the MDX pipeline for rendering
+      - Frontmatter is being parsed and attached as an attribute to the resulting component function via plugins/mdx-loader
+      - We generate a list of static paths for each blog post via the BlogApi module (using fs)
+      - The contents of this file is being reexported by /pages/blog/[slug].js
+
+
+      A Note on Performance:
+      -----------------------
+      Luckily, since pages are prerendered, we don't need to worry about
+      increased bundle sizes due to the `require` with path interpolation. It
+      might cause longer builds though, so we might need to refactor as soon as
+      builds are taking too long.  I think we will be fine for now.
+  Link to NextJS discussion: https://github.com/zeit/next.js/discussions/11728#discussioncomment-3501
+ */
+
+let middleDotSpacer = " " ++ (String.fromCharCode(183) ++ " ")
+
+module Params = {
+  type t = {slug: string}
+}
+
+type props = {mdxSource: MdxRemote.output, isArchived: bool, path: string}
+
+module Line = {
+  @react.component
+  let make = () => <div className="block border-t border-gray-20" />
+}
+
+module AuthorBox = {
+  @react.component
+  let make = (~author: BlogFrontmatter.author) => {
+    let authorImg = <img className="h-full w-full rounded-full" src=author.imgUrl />
+
+    <div className="flex items-center">
+      <div className="w-10 h-10 bg-berry-40 block rounded-full mr-3"> authorImg </div>
+      <div className="body-sm">
+        <a
+          href={switch author.social {
+          | X(handle) => "https://x.com/" ++ handle
+          | Bluesky(handle) => "https://bsky.app/profile/" ++ handle
+          }}
+          className="hover:text-gray-80"
+          rel="noopener noreferrer">
+          {React.string(author.fullname)}
+        </a>
+        <div className="text-gray-60"> {React.string(author.role)} </div>
+      </div>
+    </div>
+  }
+}
+
+module BlogHeader = {
+  @react.component
+  let make = (
+    ~date: DateStr.t,
+    ~author: BlogFrontmatter.author,
+    ~co_authors: array<BlogFrontmatter.author>,
+    ~title: string,
+    ~category: option<string>=?,
+    ~description: option<string>,
+    ~articleImg: option<string>,
+  ) => {
+    let date = DateStr.toDate(date)
+
+    let authors = Array.concat([author], co_authors)
+
+    <div className="flex flex-col items-center">
+      <div className="w-full max-w-740">
+        <div className="text-gray-60 body-sm mb-5">
+          {switch category {
+          | Some(category) =>
+            <>
+              {React.string(category)}
+              {React.string(middleDotSpacer)}
+            </>
+          | None => React.null
+          }}
+          {React.string(Util.Date.toDayMonthYear(date))}
+        </div>
+        <h1 className="hl-title"> {React.string(title)} </h1>
+        {description->Option.mapOr(React.null, desc =>
+          switch desc {
+          | "" => <div className="mb-8" />
+          | desc =>
+            <div className="text-gray-80 mt-1 mb-8">
+              <p className="body-lg"> {React.string(desc)} </p>
+            </div>
+          }
+        )}
+        <div className="flex flex-col md:flex-row mb-12">
+          {Array.map(authors, author =>
+            <div key=author.username className="mt-4 md:mt-0 md:ml-8 first:ml-0 min-w-[8.1875rem]">
+              <AuthorBox author />
+            </div>
+          )->React.array}
+        </div>
+      </div>
+      {switch articleImg {
+      | Some(articleImg) =>
+        <div className="-mx-8 sm:mx-0 sm:w-full bg-gray-5-tr md:mt-24">
+          <img className="h-full w-full object-cover max-h-[33.625rem]" src=articleImg />
+        </div>
+      | None =>
+        <div className="max-w-740 w-full">
+          <Line />
+        </div>
+      }}
+    </div>
+  }
+}
+
+let default = (props: props) => {
+  let {mdxSource, isArchived, path} = props
+
+  let children =
+    <MdxRemote
+      frontmatter={mdxSource.frontmatter}
+      compiledSource={mdxSource.compiledSource}
+      scope={mdxSource.scope}
+      components={MarkdownComponents.default}
+    />
+
+  let fm = mdxSource.frontmatter->BlogFrontmatter.decode
+
+  let archivedNote = isArchived
+    ? {
+        open Markdown
+        <div className="mb-10">
+          <Warn>
+            <P>
+              <span className="font-bold"> {React.string("Important: ")} </span>
+              {React.string(
+                "This is an archived blog post, kept for historical reasons. Please note that this information might be outdated.",
+              )}
+            </P>
+          </Warn>
+        </div>
+      }
+    : React.null
+
+  let content = switch fm {
+  | Ok({date, author, co_authors, title, description, articleImg, previewImg}) =>
+    <div className="w-full">
+      <Meta
+        siteName="ReScript Blog"
+        title={title ++ " | ReScript Blog"}
+        description=?{description->Null.toOption}
+        ogImage={previewImg->Null.toOption->Option.getOr(Blog.defaultPreviewImg)}
+      />
+      <div className="mb-10 md:mb-20">
+        <BlogHeader
+          date
+          author
+          co_authors
+          title
+          description={description->Null.toOption}
+          articleImg={articleImg->Null.toOption}
+        />
+      </div>
+      <div className="flex justify-center">
+        <div className="max-w-740 w-full">
+          archivedNote
+          children
+          <div className="mt-12">
+            <Line />
+            <div className="pt-20 flex flex-col items-center">
+              <div className="text-24 sm:text-32 text-center text-gray-80 font-medium">
+                {React.string("Want to read more?")}
+              </div>
+              <Next.Link href="/blog" className="text-fire hover:text-fire-70">
+                {React.string("Back to Overview")}
+                <Icon.ArrowRight className="ml-2 inline-block" />
+              </Next.Link>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+  | Error(msg) =>
+    <div>
+      <Markdown.Warn>
+        <h2 className="font-bold text-gray-80 text-24 mb-2">
+          {React.string("Could not parse file '_blogposts/" ++ (path ++ ".mdx'"))}
+        </h2>
+        <p>
+          {React.string("The content of this blog post will be displayed as soon as all
+            required frontmatter data has been added.")}
+        </p>
+        <p className="font-bold mt-4"> {React.string("Errors:")} </p>
+        {React.string(msg)}
+      </Markdown.Warn>
+    </div>
+  }
+  <MainLayout> content </MainLayout>
+}
+
+let getStaticProps: Next.GetStaticProps.t<props, Params.t> = async ctx => {
+  open Next.GetStaticProps
+  let {params} = ctx
+
+  let path = switch BlogApi.getAllPosts()->Array.find(({path}) =>
+    BlogApi.blogPathToSlug(path) == params.slug
+  ) {
+  | None => params.slug
+  | Some({path}) => path
+  }
+
+  let filePath = Node.Path.resolve("_blogposts", path)
+
+  let isArchived = String.startsWith(path, "archive/")
+
+  let source = filePath->Node.Fs.readFileSync
+
+  let mdxSource = await MdxRemote.serialize(
+    source,
+    {parseFrontmatter: true, mdxOptions: MdxRemote.defaultMdxOptions},
+  )
+
+  let props = {mdxSource, isArchived, path}
+
+  {"props": props}
+}
+
+let getStaticPaths: Next.GetStaticPaths.t<Params.t> = async () => {
+  open Next.GetStaticPaths
+
+  let paths = BlogApi.getAllPosts()->Array.map(postData => {
+    params: {
+      Params.slug: BlogApi.blogPathToSlug(postData.path),
+    },
+  })
+
+  {paths, fallback: false}
+}
diff --git a/app/layouts/RedLayout.jsx b/app/layouts/RedLayout.jsx
new file mode 100644
index 000000000..5486fca19
--- /dev/null
+++ b/app/layouts/RedLayout.jsx
@@ -0,0 +1,9 @@
+import { Outlet } from "react-router";
+
+export default function App() {
+    return (
+        <div style={{ background: "red" }}>
+            <Outlet />
+        </div>
+    );
+}
\ No newline at end of file
diff --git a/app/root.jsx b/app/root.jsx
new file mode 100644
index 000000000..342730d9e
--- /dev/null
+++ b/app/root.jsx
@@ -0,0 +1,18 @@
+import { Outlet, Scripts } from "react-router";
+
+export default function App() {
+  return (
+    <html>
+      <head>
+        <link
+          rel="icon"
+          href="data:image/x-icon;base64,AA"
+        />
+      </head>
+      <body>
+        <Outlet />
+        <Scripts />
+      </body>
+    </html>
+  );
+}
\ No newline at end of file
diff --git a/app/routes.mjs b/app/routes.mjs
new file mode 100644
index 000000000..e3a8afa0f
--- /dev/null
+++ b/app/routes.mjs
@@ -0,0 +1,18 @@
+import { index, layout, prefix, route } from '@react-router/dev/routes';
+import { routes } from 'react-router-mdx/server';
+
+const mdxRoutes = routes("./routes/mdx.jsx")
+
+export default [
+  route("/", "./routes/home.jsx"),
+
+  ...prefix("blog", [
+    layout("./layouts/RedLayout.jsx",
+      [
+        index("./routes/blog.jsx"),
+        ...mdxRoutes.filter(route => route.path.includes("blog/")).map(route => ({
+          ...route,
+          path: route.path.replace("blog/", "")
+        }))
+      ])])
+]
\ No newline at end of file
diff --git a/app/routes/blog.jsx b/app/routes/blog.jsx
new file mode 100644
index 000000000..d456709ce
--- /dev/null
+++ b/app/routes/blog.jsx
@@ -0,0 +1,3 @@
+export default function Blog() {
+    return <h1>Welcome to the Blog!</h1>
+}
\ No newline at end of file
diff --git a/app/routes/home.jsx b/app/routes/home.jsx
new file mode 100644
index 000000000..07b04ef65
--- /dev/null
+++ b/app/routes/home.jsx
@@ -0,0 +1,3 @@
+export default function Home() {
+    return <h1>Welcome to ReScript!</h1>
+}
\ No newline at end of file
diff --git a/app/routes/mdx.jsx b/app/routes/mdx.jsx
new file mode 100644
index 000000000..0796f1e09
--- /dev/null
+++ b/app/routes/mdx.jsx
@@ -0,0 +1,22 @@
+import { useMdxAttributes, useMdxComponent } from 'react-router-mdx/client'
+import { loadMdx } from 'react-router-mdx/server'
+
+export async function loader({ request, ...rest }) {
+    const res = loadMdx(request)
+    console.log(await res)
+    console.log(rest)
+    return res
+}
+
+export default function Route() {
+    const Component = useMdxComponent()
+    const attributes = useMdxAttributes()
+
+    return (
+        <section>
+            <h1>{attributes.title}</h1>
+            <Component />
+        </section>
+    )
+
+}
\ No newline at end of file
diff --git a/_blogposts/2020-08-10-bucklescript-is-rebranding.mdx b/blogs/2020-08-10-bucklescript-is-rebranding.mdx
similarity index 100%
rename from _blogposts/2020-08-10-bucklescript-is-rebranding.mdx
rename to blogs/2020-08-10-bucklescript-is-rebranding.mdx
diff --git a/_blogposts/2020-08-28-new-rescript-logo.mdx b/blogs/2020-08-28-new-rescript-logo.mdx
similarity index 100%
rename from _blogposts/2020-08-28-new-rescript-logo.mdx
rename to blogs/2020-08-28-new-rescript-logo.mdx
diff --git a/_blogposts/2020-09-25-release-8-3-2.mdx b/blogs/2020-09-25-release-8-3-2.mdx
similarity index 100%
rename from _blogposts/2020-09-25-release-8-3-2.mdx
rename to blogs/2020-09-25-release-8-3-2.mdx
diff --git a/_blogposts/2020-09-25-release-8-3.mdx b/blogs/2020-09-25-release-8-3.mdx
similarity index 100%
rename from _blogposts/2020-09-25-release-8-3.mdx
rename to blogs/2020-09-25-release-8-3.mdx
diff --git a/_blogposts/2020-11-17-editor-support-custom-operators-and-more.mdx b/blogs/2020-11-17-editor-support-custom-operators-and-more.mdx
similarity index 100%
rename from _blogposts/2020-11-17-editor-support-custom-operators-and-more.mdx
rename to blogs/2020-11-17-editor-support-custom-operators-and-more.mdx
diff --git a/_blogposts/2020-11-26-editor-support-release-1-0.mdx b/blogs/2020-11-26-editor-support-release-1-0.mdx
similarity index 100%
rename from _blogposts/2020-11-26-editor-support-release-1-0.mdx
rename to blogs/2020-11-26-editor-support-release-1-0.mdx
diff --git a/_blogposts/2020-12-07-release-8-4.mdx b/blogs/2020-12-07-release-8-4.mdx
similarity index 100%
rename from _blogposts/2020-12-07-release-8-4.mdx
rename to blogs/2020-12-07-release-8-4.mdx
diff --git a/_blogposts/2021-02-09-release-9-0.mdx b/blogs/2021-02-09-release-9-0.mdx
similarity index 100%
rename from _blogposts/2021-02-09-release-9-0.mdx
rename to blogs/2021-02-09-release-9-0.mdx
diff --git a/_blogposts/2021-03-03-rescript-association-rebranding.mdx b/blogs/2021-03-03-rescript-association-rebranding.mdx
similarity index 100%
rename from _blogposts/2021-03-03-rescript-association-rebranding.mdx
rename to blogs/2021-03-03-rescript-association-rebranding.mdx
diff --git a/_blogposts/2021-05-07-release-9-1.mdx b/blogs/2021-05-07-release-9-1.mdx
similarity index 100%
rename from _blogposts/2021-05-07-release-9-1.mdx
rename to blogs/2021-05-07-release-9-1.mdx
diff --git a/_blogposts/2021-06-25-roadmap-2021-and-new-landing-page.mdx b/blogs/2021-06-25-roadmap-2021-and-new-landing-page.mdx
similarity index 100%
rename from _blogposts/2021-06-25-roadmap-2021-and-new-landing-page.mdx
rename to blogs/2021-06-25-roadmap-2021-and-new-landing-page.mdx
diff --git a/_blogposts/2022-08-25-release-10-0-0.mdx b/blogs/2022-08-25-release-10-0-0.mdx
similarity index 100%
rename from _blogposts/2022-08-25-release-10-0-0.mdx
rename to blogs/2022-08-25-release-10-0-0.mdx
diff --git a/_blogposts/2023-02-02-release-10-1.mdx b/blogs/2023-02-02-release-10-1.mdx
similarity index 100%
rename from _blogposts/2023-02-02-release-10-1.mdx
rename to blogs/2023-02-02-release-10-1.mdx
diff --git a/_blogposts/2023-04-17-improving-interop.mdx b/blogs/2023-04-17-improving-interop.mdx
similarity index 100%
rename from _blogposts/2023-04-17-improving-interop.mdx
rename to blogs/2023-04-17-improving-interop.mdx
diff --git a/_blogposts/2023-05-17-enhanced-ergonomics-for-record-types.mdx b/blogs/2023-05-17-enhanced-ergonomics-for-record-types.mdx
similarity index 100%
rename from _blogposts/2023-05-17-enhanced-ergonomics-for-record-types.mdx
rename to blogs/2023-05-17-enhanced-ergonomics-for-record-types.mdx
diff --git a/_blogposts/2023-06-05-first-class-dynamic-import-support.mdx b/blogs/2023-06-05-first-class-dynamic-import-support.mdx
similarity index 100%
rename from _blogposts/2023-06-05-first-class-dynamic-import-support.mdx
rename to blogs/2023-06-05-first-class-dynamic-import-support.mdx
diff --git a/_blogposts/2023-09-18-uncurried-mode.mdx b/blogs/2023-09-18-uncurried-mode.mdx
similarity index 100%
rename from _blogposts/2023-09-18-uncurried-mode.mdx
rename to blogs/2023-09-18-uncurried-mode.mdx
diff --git a/_blogposts/2024-01-11-release-11-0-0.mdx b/blogs/2024-01-11-release-11-0-0.mdx
similarity index 100%
rename from _blogposts/2024-01-11-release-11-0-0.mdx
rename to blogs/2024-01-11-release-11-0-0.mdx
diff --git a/_blogposts/2024-02-01-release-11-1-0.mdx b/blogs/2024-02-01-release-11-1-0.mdx
similarity index 100%
rename from _blogposts/2024-02-01-release-11-1-0.mdx
rename to blogs/2024-02-01-release-11-1-0.mdx
diff --git a/_blogposts/2025-03-05-what-can-i-do-with-rescript.mdx b/blogs/2025-03-05-what-can-i-do-with-rescript.mdx
similarity index 100%
rename from _blogposts/2025-03-05-what-can-i-do-with-rescript.mdx
rename to blogs/2025-03-05-what-can-i-do-with-rescript.mdx
diff --git a/_blogposts/2025-03-17-retreats.mdx b/blogs/2025-03-17-retreats.mdx
similarity index 100%
rename from _blogposts/2025-03-17-retreats.mdx
rename to blogs/2025-03-17-retreats.mdx
diff --git a/_blogposts/2025-04-11-introducing-unified-operators.mdx b/blogs/2025-04-11-introducing-unified-operators.mdx
similarity index 100%
rename from _blogposts/2025-04-11-introducing-unified-operators.mdx
rename to blogs/2025-04-11-introducing-unified-operators.mdx
diff --git a/blogs/another.mdx b/blogs/another.mdx
new file mode 100644
index 000000000..0d9d638e6
--- /dev/null
+++ b/blogs/another.mdx
@@ -0,0 +1,12 @@
+---
+author: rescript-team
+date: "2021-05-07"
+previewImg: /static/blog/compiler_release_9_1.jpg
+title: ReScript 9.1
+badge: release
+description: |
+  Featuring a new npm package, a CLI revamp, polymorphic variant interop and object cleanup.
+---
+
+# Hello!
+Hello
\ No newline at end of file
diff --git a/_blogposts/archive/2017-10-01-bucklescript-release-1-0.mdx b/blogs/archive/2017-10-01-bucklescript-release-1-0.mdx
similarity index 100%
rename from _blogposts/archive/2017-10-01-bucklescript-release-1-0.mdx
rename to blogs/archive/2017-10-01-bucklescript-release-1-0.mdx
diff --git a/_blogposts/archive/2017-10-02-bucklescript-release-1-4-2.mdx b/blogs/archive/2017-10-02-bucklescript-release-1-4-2.mdx
similarity index 100%
rename from _blogposts/archive/2017-10-02-bucklescript-release-1-4-2.mdx
rename to blogs/archive/2017-10-02-bucklescript-release-1-4-2.mdx
diff --git a/_blogposts/archive/2017-10-03-bucklescript-release-1-4-3.mdx b/blogs/archive/2017-10-03-bucklescript-release-1-4-3.mdx
similarity index 100%
rename from _blogposts/archive/2017-10-03-bucklescript-release-1-4-3.mdx
rename to blogs/archive/2017-10-03-bucklescript-release-1-4-3.mdx
diff --git a/_blogposts/archive/2017-10-04-bucklescript-release-1-5-0.mdx b/blogs/archive/2017-10-04-bucklescript-release-1-5-0.mdx
similarity index 100%
rename from _blogposts/archive/2017-10-04-bucklescript-release-1-5-0.mdx
rename to blogs/archive/2017-10-04-bucklescript-release-1-5-0.mdx
diff --git a/_blogposts/archive/2017-10-05-bucklescript-release-1-5-1.mdx b/blogs/archive/2017-10-05-bucklescript-release-1-5-1.mdx
similarity index 100%
rename from _blogposts/archive/2017-10-05-bucklescript-release-1-5-1.mdx
rename to blogs/archive/2017-10-05-bucklescript-release-1-5-1.mdx
diff --git a/_blogposts/archive/2017-10-06-bucklescript-release-1-5-2.mdx b/blogs/archive/2017-10-06-bucklescript-release-1-5-2.mdx
similarity index 100%
rename from _blogposts/archive/2017-10-06-bucklescript-release-1-5-2.mdx
rename to blogs/archive/2017-10-06-bucklescript-release-1-5-2.mdx
diff --git a/_blogposts/archive/2017-10-07-bucklescript-release-1-7-0.mdx b/blogs/archive/2017-10-07-bucklescript-release-1-7-0.mdx
similarity index 100%
rename from _blogposts/archive/2017-10-07-bucklescript-release-1-7-0.mdx
rename to blogs/archive/2017-10-07-bucklescript-release-1-7-0.mdx
diff --git a/_blogposts/archive/2017-10-08-bucklescript-release-1-7-4.mdx b/blogs/archive/2017-10-08-bucklescript-release-1-7-4.mdx
similarity index 100%
rename from _blogposts/archive/2017-10-08-bucklescript-release-1-7-4.mdx
rename to blogs/archive/2017-10-08-bucklescript-release-1-7-4.mdx
diff --git a/_blogposts/archive/2017-10-09-bucklescript-release-1-7-5.mdx b/blogs/archive/2017-10-09-bucklescript-release-1-7-5.mdx
similarity index 100%
rename from _blogposts/archive/2017-10-09-bucklescript-release-1-7-5.mdx
rename to blogs/archive/2017-10-09-bucklescript-release-1-7-5.mdx
diff --git a/_blogposts/archive/2018-03-13-a-small-step-for-bucklescript.mdx b/blogs/archive/2018-03-13-a-small-step-for-bucklescript.mdx
similarity index 100%
rename from _blogposts/archive/2018-03-13-a-small-step-for-bucklescript.mdx
rename to blogs/archive/2018-03-13-a-small-step-for-bucklescript.mdx
diff --git a/_blogposts/archive/2018-04-16-bucklescript-release-3-0-0.mdx b/blogs/archive/2018-04-16-bucklescript-release-3-0-0.mdx
similarity index 100%
rename from _blogposts/archive/2018-04-16-bucklescript-release-3-0-0.mdx
rename to blogs/archive/2018-04-16-bucklescript-release-3-0-0.mdx
diff --git a/_blogposts/archive/2018-05-21-bucklescript-release-3-1-0.mdx b/blogs/archive/2018-05-21-bucklescript-release-3-1-0.mdx
similarity index 100%
rename from _blogposts/archive/2018-05-21-bucklescript-release-3-1-0.mdx
rename to blogs/archive/2018-05-21-bucklescript-release-3-1-0.mdx
diff --git a/_blogposts/archive/2018-05-23-bucklescript-release-3-1-4.mdx b/blogs/archive/2018-05-23-bucklescript-release-3-1-4.mdx
similarity index 100%
rename from _blogposts/archive/2018-05-23-bucklescript-release-3-1-4.mdx
rename to blogs/archive/2018-05-23-bucklescript-release-3-1-4.mdx
diff --git a/_blogposts/archive/2018-07-17-bucklescript-release-4-0-0-pt1.mdx b/blogs/archive/2018-07-17-bucklescript-release-4-0-0-pt1.mdx
similarity index 100%
rename from _blogposts/archive/2018-07-17-bucklescript-release-4-0-0-pt1.mdx
rename to blogs/archive/2018-07-17-bucklescript-release-4-0-0-pt1.mdx
diff --git a/_blogposts/archive/2018-07-17-bucklescript-release-4-0-0-pt2.mdx b/blogs/archive/2018-07-17-bucklescript-release-4-0-0-pt2.mdx
similarity index 100%
rename from _blogposts/archive/2018-07-17-bucklescript-release-4-0-0-pt2.mdx
rename to blogs/archive/2018-07-17-bucklescript-release-4-0-0-pt2.mdx
diff --git a/_blogposts/archive/2018-11-13-arity-zero.mdx b/blogs/archive/2018-11-13-arity-zero.mdx
similarity index 100%
rename from _blogposts/archive/2018-11-13-arity-zero.mdx
rename to blogs/archive/2018-11-13-arity-zero.mdx
diff --git a/_blogposts/archive/2018-11-19-bucklescript-roadmap-q3-4-2018.mdx b/blogs/archive/2018-11-19-bucklescript-roadmap-q3-4-2018.mdx
similarity index 100%
rename from _blogposts/archive/2018-11-19-bucklescript-roadmap-q3-4-2018.mdx
rename to blogs/archive/2018-11-19-bucklescript-roadmap-q3-4-2018.mdx
diff --git a/_blogposts/archive/2018-12-05-bucklescript-release-4-0-8.mdx b/blogs/archive/2018-12-05-bucklescript-release-4-0-8.mdx
similarity index 100%
rename from _blogposts/archive/2018-12-05-bucklescript-release-4-0-8.mdx
rename to blogs/archive/2018-12-05-bucklescript-release-4-0-8.mdx
diff --git a/_blogposts/archive/2019-01-07-bucklescript-release-4-0-17.mdx b/blogs/archive/2019-01-07-bucklescript-release-4-0-17.mdx
similarity index 100%
rename from _blogposts/archive/2019-01-07-bucklescript-release-4-0-17.mdx
rename to blogs/archive/2019-01-07-bucklescript-release-4-0-17.mdx
diff --git a/_blogposts/archive/2019-01-11-scalable.mdx b/blogs/archive/2019-01-11-scalable.mdx
similarity index 100%
rename from _blogposts/archive/2019-01-11-scalable.mdx
rename to blogs/archive/2019-01-11-scalable.mdx
diff --git a/_blogposts/archive/2019-03-01-feature-preview-variadic.mdx b/blogs/archive/2019-03-01-feature-preview-variadic.mdx
similarity index 100%
rename from _blogposts/archive/2019-03-01-feature-preview-variadic.mdx
rename to blogs/archive/2019-03-01-feature-preview-variadic.mdx
diff --git a/_blogposts/archive/2019-03-21-bucklescript-release-5-0.mdx b/blogs/archive/2019-03-21-bucklescript-release-5-0.mdx
similarity index 100%
rename from _blogposts/archive/2019-03-21-bucklescript-release-5-0.mdx
rename to blogs/archive/2019-03-21-bucklescript-release-5-0.mdx
diff --git a/_blogposts/archive/2019-03-31-bucklescript-release-6-0.mdx b/blogs/archive/2019-03-31-bucklescript-release-6-0.mdx
similarity index 100%
rename from _blogposts/archive/2019-03-31-bucklescript-release-6-0.mdx
rename to blogs/archive/2019-03-31-bucklescript-release-6-0.mdx
diff --git a/_blogposts/archive/2019-04-09-bucklescript-release-5-0-1.mdx b/blogs/archive/2019-04-09-bucklescript-release-5-0-1.mdx
similarity index 100%
rename from _blogposts/archive/2019-04-09-bucklescript-release-5-0-1.mdx
rename to blogs/archive/2019-04-09-bucklescript-release-5-0-1.mdx
diff --git a/_blogposts/archive/2019-04-22-bucklescript-release-5-0-4.mdx b/blogs/archive/2019-04-22-bucklescript-release-5-0-4.mdx
similarity index 100%
rename from _blogposts/archive/2019-04-22-bucklescript-release-5-0-4.mdx
rename to blogs/archive/2019-04-22-bucklescript-release-5-0-4.mdx
diff --git a/_blogposts/archive/2019-05-21-ffi-overview.mdx b/blogs/archive/2019-05-21-ffi-overview.mdx
similarity index 100%
rename from _blogposts/archive/2019-05-21-ffi-overview.mdx
rename to blogs/archive/2019-05-21-ffi-overview.mdx
diff --git a/_blogposts/archive/2019-06-26-bucklescript-release-5-0-5.mdx b/blogs/archive/2019-06-26-bucklescript-release-5-0-5.mdx
similarity index 100%
rename from _blogposts/archive/2019-06-26-bucklescript-release-5-0-5.mdx
rename to blogs/archive/2019-06-26-bucklescript-release-5-0-5.mdx
diff --git a/_blogposts/archive/2019-08-12-bucklescript-release-5-1-0.mdx b/blogs/archive/2019-08-12-bucklescript-release-5-1-0.mdx
similarity index 100%
rename from _blogposts/archive/2019-08-12-bucklescript-release-5-1-0.mdx
rename to blogs/archive/2019-08-12-bucklescript-release-5-1-0.mdx
diff --git a/_blogposts/archive/2019-09-23-bucklescript-release-5-2-0.mdx b/blogs/archive/2019-09-23-bucklescript-release-5-2-0.mdx
similarity index 100%
rename from _blogposts/archive/2019-09-23-bucklescript-release-5-2-0.mdx
rename to blogs/archive/2019-09-23-bucklescript-release-5-2-0.mdx
diff --git a/_blogposts/archive/2019-10-16-another-encoding.mdx b/blogs/archive/2019-10-16-another-encoding.mdx
similarity index 100%
rename from _blogposts/archive/2019-10-16-another-encoding.mdx
rename to blogs/archive/2019-10-16-another-encoding.mdx
diff --git a/_blogposts/archive/2019-11-18-whats-new-in-7-pt1.mdx b/blogs/archive/2019-11-18-whats-new-in-7-pt1.mdx
similarity index 100%
rename from _blogposts/archive/2019-11-18-whats-new-in-7-pt1.mdx
rename to blogs/archive/2019-11-18-whats-new-in-7-pt1.mdx
diff --git a/_blogposts/archive/2019-11-28-whats-new-in-7-pt2.mdx b/blogs/archive/2019-11-28-whats-new-in-7-pt2.mdx
similarity index 100%
rename from _blogposts/archive/2019-11-28-whats-new-in-7-pt2.mdx
rename to blogs/archive/2019-11-28-whats-new-in-7-pt2.mdx
diff --git a/_blogposts/archive/2019-12-20-bucklescript-release-7-0-2.mdx b/blogs/archive/2019-12-20-bucklescript-release-7-0-2.mdx
similarity index 100%
rename from _blogposts/archive/2019-12-20-bucklescript-release-7-0-2.mdx
rename to blogs/archive/2019-12-20-bucklescript-release-7-0-2.mdx
diff --git a/_blogposts/archive/2020-02-04-bucklescript-release-7-1-0.mdx b/blogs/archive/2020-02-04-bucklescript-release-7-1-0.mdx
similarity index 100%
rename from _blogposts/archive/2020-02-04-bucklescript-release-7-1-0.mdx
rename to blogs/archive/2020-02-04-bucklescript-release-7-1-0.mdx
diff --git a/_blogposts/archive/2020-02-07-union-types-in-bucklescript.mdx b/blogs/archive/2020-02-07-union-types-in-bucklescript.mdx
similarity index 100%
rename from _blogposts/archive/2020-02-07-union-types-in-bucklescript.mdx
rename to blogs/archive/2020-02-07-union-types-in-bucklescript.mdx
diff --git a/_blogposts/archive/2020-02-20-loading-stdlib-in-memory.mdx b/blogs/archive/2020-02-20-loading-stdlib-in-memory.mdx
similarity index 100%
rename from _blogposts/archive/2020-02-20-loading-stdlib-in-memory.mdx
rename to blogs/archive/2020-02-20-loading-stdlib-in-memory.mdx
diff --git a/_blogposts/archive/2020-03-12-bucklescript-release-7-2.mdx b/blogs/archive/2020-03-12-bucklescript-release-7-2.mdx
similarity index 100%
rename from _blogposts/archive/2020-03-12-bucklescript-release-7-2.mdx
rename to blogs/archive/2020-03-12-bucklescript-release-7-2.mdx
diff --git a/_blogposts/archive/2020-03-26-generalize-uncurry.mdx b/blogs/archive/2020-03-26-generalize-uncurry.mdx
similarity index 100%
rename from _blogposts/archive/2020-03-26-generalize-uncurry.mdx
rename to blogs/archive/2020-03-26-generalize-uncurry.mdx
diff --git a/_blogposts/archive/2020-04-13-bucklescript-release-7-3.mdx b/blogs/archive/2020-04-13-bucklescript-release-7-3.mdx
similarity index 100%
rename from _blogposts/archive/2020-04-13-bucklescript-release-7-3.mdx
rename to blogs/archive/2020-04-13-bucklescript-release-7-3.mdx
diff --git a/_blogposts/archive/2020-05-06-a-story-of-exception-encoding.mdx b/blogs/archive/2020-05-06-a-story-of-exception-encoding.mdx
similarity index 100%
rename from _blogposts/archive/2020-05-06-a-story-of-exception-encoding.mdx
rename to blogs/archive/2020-05-06-a-story-of-exception-encoding.mdx
diff --git a/_blogposts/archive/2020-05-06-state-of-reasonml-org-2020-q2-pt1.mdx b/blogs/archive/2020-05-06-state-of-reasonml-org-2020-q2-pt1.mdx
similarity index 100%
rename from _blogposts/archive/2020-05-06-state-of-reasonml-org-2020-q2-pt1.mdx
rename to blogs/archive/2020-05-06-state-of-reasonml-org-2020-q2-pt1.mdx
diff --git a/_blogposts/archive/2020-05-11-state-of-reasonml-org-2020-q2-pt2.mdx b/blogs/archive/2020-05-11-state-of-reasonml-org-2020-q2-pt2.mdx
similarity index 100%
rename from _blogposts/archive/2020-05-11-state-of-reasonml-org-2020-q2-pt2.mdx
rename to blogs/archive/2020-05-11-state-of-reasonml-org-2020-q2-pt2.mdx
diff --git a/_blogposts/archive/2020-05-12-state-of-reasonml-org-2020-q2-pt3.mdx b/blogs/archive/2020-05-12-state-of-reasonml-org-2020-q2-pt3.mdx
similarity index 100%
rename from _blogposts/archive/2020-05-12-state-of-reasonml-org-2020-q2-pt3.mdx
rename to blogs/archive/2020-05-12-state-of-reasonml-org-2020-q2-pt3.mdx
diff --git a/_blogposts/archive/2020-05-15-a-story-of-lazy-encoding.mdx b/blogs/archive/2020-05-15-a-story-of-lazy-encoding.mdx
similarity index 100%
rename from _blogposts/archive/2020-05-15-a-story-of-lazy-encoding.mdx
rename to blogs/archive/2020-05-15-a-story-of-lazy-encoding.mdx
diff --git a/_blogposts/archive/2020-05-15-state-of-reasonml-org-2020-q2-pt4.mdx b/blogs/archive/2020-05-15-state-of-reasonml-org-2020-q2-pt4.mdx
similarity index 100%
rename from _blogposts/archive/2020-05-15-state-of-reasonml-org-2020-q2-pt4.mdx
rename to blogs/archive/2020-05-15-state-of-reasonml-org-2020-q2-pt4.mdx
diff --git a/_blogposts/archive/2020-06-22-overview-of-new_encoding.mdx b/blogs/archive/2020-06-22-overview-of-new_encoding.mdx
similarity index 100%
rename from _blogposts/archive/2020-06-22-overview-of-new_encoding.mdx
rename to blogs/archive/2020-06-22-overview-of-new_encoding.mdx
diff --git a/_blogposts/archive/2020-07-01-bucklescript-8-1-new-syntax.mdx b/blogs/archive/2020-07-01-bucklescript-8-1-new-syntax.mdx
similarity index 100%
rename from _blogposts/archive/2020-07-01-bucklescript-8-1-new-syntax.mdx
rename to blogs/archive/2020-07-01-bucklescript-8-1-new-syntax.mdx
diff --git a/_blogposts/archive/2020-07-06-a-note-on-bucklescripts-future-commitments.mdx b/blogs/archive/2020-07-06-a-note-on-bucklescripts-future-commitments.mdx
similarity index 100%
rename from _blogposts/archive/2020-07-06-a-note-on-bucklescripts-future-commitments.mdx
rename to blogs/archive/2020-07-06-a-note-on-bucklescripts-future-commitments.mdx
diff --git a/_blogposts/archive/2020-07-17-bucklescript-release-8-1-1.mdx b/blogs/archive/2020-07-17-bucklescript-release-8-1-1.mdx
similarity index 100%
rename from _blogposts/archive/2020-07-17-bucklescript-release-8-1-1.mdx
rename to blogs/archive/2020-07-17-bucklescript-release-8-1-1.mdx
diff --git a/_blogposts/archive/2020-07-28-string-literal-types-in-reason.mdx b/blogs/archive/2020-07-28-string-literal-types-in-reason.mdx
similarity index 100%
rename from _blogposts/archive/2020-07-28-string-literal-types-in-reason.mdx
rename to blogs/archive/2020-07-28-string-literal-types-in-reason.mdx
diff --git a/_blogposts/archive/2020-08-03-bucklescript-release-8-2.mdx b/blogs/archive/2020-08-03-bucklescript-release-8-2.mdx
similarity index 100%
rename from _blogposts/archive/2020-08-03-bucklescript-release-8-2.mdx
rename to blogs/archive/2020-08-03-bucklescript-release-8-2.mdx
diff --git a/blogs/testing.mdx b/blogs/testing.mdx
new file mode 100644
index 000000000..d00e1487d
--- /dev/null
+++ b/blogs/testing.mdx
@@ -0,0 +1,6 @@
+---
+title: Hello
+category: blog
+---
+# Hello!
+Hello
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index 39df72a89..1e3f99140 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -15,6 +15,7 @@
         "@docsearch/react": "^3.9.0",
         "@headlessui/react": "^2.2.4",
         "@mdx-js/loader": "^3.1.0",
+        "@react-router/node": "^7.7.1",
         "@rescript/react": "^0.14.0-rc.1",
         "@rescript/webapi": "^0.1.0-experimental-03eae8b",
         "codemirror": "^5.54.0",
@@ -26,13 +27,18 @@
         "glob": "^7.1.4",
         "highlight.js": "^11.9.0",
         "highlightjs-rescript": "^0.2.2",
+        "install": "^0.13.0",
+        "isbot": "^5",
         "lz-string": "^1.4.4",
         "next": "^15.0.0",
         "next-mdx-remote": "^5.0.0",
+        "npm": "^11.5.2",
         "prettier": "^1.18.2",
         "react": "^19.1.0",
         "react-dom": "^19.1.0",
         "react-markdown": "^10.1.0",
+        "react-router": "^7.7.1",
+        "react-router-mdx": "^1.0.6",
         "rehype-slug": "^6.0.0",
         "rehype-stringify": "^10.0.1",
         "remark-comment": "^1.0.0",
@@ -50,6 +56,10 @@
       },
       "devDependencies": {
         "@mdx-js/react": "^2.3.0",
+        "@mdx-js/rollup": "^3.1.0",
+        "@react-router/dev": "^7.7.1",
+        "@vitejs/plugin-react": "^4.7.0",
+        "@vitejs/plugin-rsc": "^0.4.16",
         "autoprefixer": "^10.4.14",
         "cssnano": "^6.0.1",
         "dotenv": "^16.4.7",
@@ -60,7 +70,8 @@
         "postcss-nesting": "^12.1.1",
         "reanalyze": "^2.16.0",
         "simple-functional-loader": "^1.2.1",
-        "tailwindcss": "^3.3.3"
+        "tailwindcss": "^3.3.3",
+        "vite": "^7.0.6"
       },
       "engines": {
         "node": ">=20"
@@ -303,6 +314,19 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/@ampproject/remapping": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz",
+      "integrity": "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
     "node_modules/@asamuzakjp/css-color": {
       "version": "3.2.0",
       "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-3.2.0.tgz",
@@ -318,174 +342,327 @@
       }
     },
     "node_modules/@babel/code-frame": {
-      "version": "7.24.7",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.24.7.tgz",
-      "integrity": "sha512-BcYH1CVJBO9tvyIZ2jVeXgSIMvGZ2FDRvDdOIVQyuklNKSsx+eppDEBq/g47Ayw+RqNFE+URvOShmf+f/qwAlA==",
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
+      "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
+      "license": "MIT",
       "dependencies": {
-        "@babel/highlight": "^7.24.7",
-        "picocolors": "^1.0.0"
+        "@babel/helper-validator-identifier": "^7.27.1",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
-    "node_modules/@babel/generator": {
-      "version": "7.24.7",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.24.7.tgz",
-      "integrity": "sha512-oipXieGC3i45Y1A41t4tAqpnEZWgB/lC6Ehh6+rOviR5XWpTtMmLN+fGjz9vOiNRt0p6RtO6DtD0pdU3vpqdSA==",
+    "node_modules/@babel/compat-data": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.28.0.tgz",
+      "integrity": "sha512-60X7qkglvrap8mn1lh2ebxXdZYtUcpd7gsmy9kLaBJ4i/WdY8PqTSdxyA8qraikqKQK5C1KRBKXqznrVapyNaw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.0.tgz",
+      "integrity": "sha512-UlLAnTPrFdNGoFtbSXwcGFQBtQZJCNjaN6hQNP3UPvuNXT1i82N26KL3dZeIpNalWywr9IuQuncaAfUaS1g6sQ==",
+      "license": "MIT",
       "dependencies": {
-        "@babel/types": "^7.24.7",
-        "@jridgewell/gen-mapping": "^0.3.5",
-        "@jridgewell/trace-mapping": "^0.3.25",
-        "jsesc": "^2.5.1"
+        "@ampproject/remapping": "^2.2.0",
+        "@babel/code-frame": "^7.27.1",
+        "@babel/generator": "^7.28.0",
+        "@babel/helper-compilation-targets": "^7.27.2",
+        "@babel/helper-module-transforms": "^7.27.3",
+        "@babel/helpers": "^7.27.6",
+        "@babel/parser": "^7.28.0",
+        "@babel/template": "^7.27.2",
+        "@babel/traverse": "^7.28.0",
+        "@babel/types": "^7.28.0",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
       },
       "engines": {
         "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/core/node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@babel/core/node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
       }
     },
-    "node_modules/@babel/helper-environment-visitor": {
-      "version": "7.24.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.24.7.tgz",
-      "integrity": "sha512-DoiN84+4Gnd0ncbBOM9AZENV4a5ZiL39HYMyZJGZ/AZEykHYdJw0wW3kdcsh9/Kn+BRXHLkkklZ51ecPKmI1CQ==",
+    "node_modules/@babel/generator": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.0.tgz",
+      "integrity": "sha512-lJjzvrbEeWrhB4P3QBsH7tey117PjLZnDbLiQEKjQ/fNJTjuq4HSqgFA+UNSwZT8D7dxxbnuSBMsa1lrWzKlQg==",
+      "license": "MIT",
       "dependencies": {
-        "@babel/types": "^7.24.7"
+        "@babel/parser": "^7.28.0",
+        "@babel/types": "^7.28.0",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
-    "node_modules/@babel/helper-function-name": {
-      "version": "7.24.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.24.7.tgz",
-      "integrity": "sha512-FyoJTsj/PEUWu1/TYRiXTIHc8lbw+TDYkZuoE43opPS5TrI7MyONBE1oNvfguEXAD9yhQRrVBnXdXzSLQl9XnA==",
+    "node_modules/@babel/helper-annotate-as-pure": {
+      "version": "7.27.3",
+      "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.27.3.tgz",
+      "integrity": "sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg==",
+      "license": "MIT",
       "dependencies": {
-        "@babel/template": "^7.24.7",
-        "@babel/types": "^7.24.7"
+        "@babel/types": "^7.27.3"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
-    "node_modules/@babel/helper-hoist-variables": {
-      "version": "7.24.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.24.7.tgz",
-      "integrity": "sha512-MJJwhkoGy5c4ehfoRyrJ/owKeMl19U54h27YYftT0o2teQ3FJ3nQUf/I3LlJsX4l3qlw7WRXUmiyajvHXoTubQ==",
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.27.2",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz",
+      "integrity": "sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==",
+      "license": "MIT",
       "dependencies": {
-        "@babel/types": "^7.24.7"
+        "@babel/compat-data": "^7.27.2",
+        "@babel/helper-validator-option": "^7.27.1",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
-    "node_modules/@babel/helper-split-export-declaration": {
-      "version": "7.24.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.24.7.tgz",
-      "integrity": "sha512-oy5V7pD+UvfkEATUKvIjvIAH/xCzfsFVw7ygW2SI6NClZzquT+mwdTfgfdbUiceh6iQO0CHtCPsyze/MZ2YbAA==",
+    "node_modules/@babel/helper-compilation-targets/node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets/node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/@babel/helper-create-class-features-plugin": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.27.1.tgz",
+      "integrity": "sha512-QwGAmuvM17btKU5VqXfb+Giw4JcN0hjuufz3DYnpeVDvZLAObloM77bhMXiqry3Iio+Ai4phVRDwl6WU10+r5A==",
+      "license": "MIT",
       "dependencies": {
-        "@babel/types": "^7.24.7"
+        "@babel/helper-annotate-as-pure": "^7.27.1",
+        "@babel/helper-member-expression-to-functions": "^7.27.1",
+        "@babel/helper-optimise-call-expression": "^7.27.1",
+        "@babel/helper-replace-supers": "^7.27.1",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1",
+        "@babel/traverse": "^7.27.1",
+        "semver": "^6.3.1"
       },
       "engines": {
         "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
       }
     },
-    "node_modules/@babel/helper-string-parser": {
-      "version": "7.24.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.24.7.tgz",
-      "integrity": "sha512-7MbVt6xrwFQbunH2DNQsAP5sTGxfqQtErvBIvIMi6EQnbgUOuVYanvREcmFrOPhoXBrTtjhhP+lW+o5UfK+tDg==",
+    "node_modules/@babel/helper-create-class-features-plugin/node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
+      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+      "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
-    "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.24.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.24.7.tgz",
-      "integrity": "sha512-rR+PBcQ1SMQDDyF6X0wxtG8QyLCgUB0eRAGguqRLfkCA87l7yAP7ehq8SNj96OOGTO8OBV70KhuFYcIkHXOg0w==",
+    "node_modules/@babel/helper-member-expression-to-functions": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.27.1.tgz",
+      "integrity": "sha512-E5chM8eWjTp/aNoVpcbfM7mLxu9XGLWYise2eBKGQomAk/Mb4XoxyqXTZbuTohbsl8EKqdlMhnDI2CCLfcs9wA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.27.1",
+        "@babel/types": "^7.27.1"
+      },
       "engines": {
         "node": ">=6.9.0"
       }
     },
-    "node_modules/@babel/highlight": {
-      "version": "7.24.7",
-      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.24.7.tgz",
-      "integrity": "sha512-EStJpq4OuY8xYfhGVXngigBJRWxftKX9ksiGDnmlY3o7B/V7KIAc9X4oiK87uPJSc/vs5L869bem5fhZa8caZw==",
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz",
+      "integrity": "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==",
+      "license": "MIT",
       "dependencies": {
-        "@babel/helper-validator-identifier": "^7.24.7",
-        "chalk": "^2.4.2",
-        "js-tokens": "^4.0.0",
-        "picocolors": "^1.0.0"
+        "@babel/traverse": "^7.27.1",
+        "@babel/types": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
-    "node_modules/@babel/highlight/node_modules/ansi-styles": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
-      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.27.3",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.27.3.tgz",
+      "integrity": "sha512-dSOvYwvyLsWBeIRyOeHXp5vPj5l1I011r52FM1+r1jCERv+aFXYk4whgQccYEGYxK2H3ZAIA8nuPkQ0HaUo3qg==",
+      "license": "MIT",
       "dependencies": {
-        "color-convert": "^1.9.0"
+        "@babel/helper-module-imports": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.27.1",
+        "@babel/traverse": "^7.27.3"
       },
       "engines": {
-        "node": ">=4"
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
       }
     },
-    "node_modules/@babel/highlight/node_modules/chalk": {
-      "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
-      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+    "node_modules/@babel/helper-optimise-call-expression": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.27.1.tgz",
+      "integrity": "sha512-URMGH08NzYFhubNSGJrpUEphGKQwMQYBySzat5cAByY1/YgIRkULnIy3tAMeszlL/so2HbeilYloUmSpd7GdVw==",
+      "license": "MIT",
       "dependencies": {
-        "ansi-styles": "^3.2.1",
-        "escape-string-regexp": "^1.0.5",
-        "supports-color": "^5.3.0"
+        "@babel/types": "^7.27.1"
       },
       "engines": {
-        "node": ">=4"
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz",
+      "integrity": "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
       }
     },
-    "node_modules/@babel/highlight/node_modules/color-convert": {
-      "version": "1.9.3",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
-      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+    "node_modules/@babel/helper-replace-supers": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.27.1.tgz",
+      "integrity": "sha512-7EHz6qDZc8RYS5ElPoShMheWvEgERonFCs7IAonWLLUTXW59DP14bCZt89/GKyreYn8g3S83m21FelHKbeDCKA==",
+      "license": "MIT",
       "dependencies": {
-        "color-name": "1.1.3"
+        "@babel/helper-member-expression-to-functions": "^7.27.1",
+        "@babel/helper-optimise-call-expression": "^7.27.1",
+        "@babel/traverse": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
       }
     },
-    "node_modules/@babel/highlight/node_modules/color-name": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
-      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw=="
+    "node_modules/@babel/helper-skip-transparent-expression-wrappers": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.27.1.tgz",
+      "integrity": "sha512-Tub4ZKEXqbPjXgWLl2+3JpQAYBJ8+ikpQ2Ocj/q/r0LwE3UhENh7EUabyHjz2kCEsrRY83ew2DQdHluuiDQFzg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.27.1",
+        "@babel/types": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
     },
-    "node_modules/@babel/highlight/node_modules/escape-string-regexp": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "license": "MIT",
       "engines": {
-        "node": ">=0.8.0"
+        "node": ">=6.9.0"
       }
     },
-    "node_modules/@babel/highlight/node_modules/has-flag": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz",
+      "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==",
+      "license": "MIT",
       "engines": {
-        "node": ">=4"
+        "node": ">=6.9.0"
       }
     },
-    "node_modules/@babel/highlight/node_modules/supports-color": {
-      "version": "5.5.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
-      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
+      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.28.2",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.2.tgz",
+      "integrity": "sha512-/V9771t+EgXz62aCcyofnQhGM8DQACbRhvzKFsXKC9QM+5MadF8ZmIm0crDMaz3+o0h0zXfJnd4EhbYbxsrcFw==",
+      "license": "MIT",
       "dependencies": {
-        "has-flag": "^3.0.0"
+        "@babel/template": "^7.27.2",
+        "@babel/types": "^7.28.2"
       },
       "engines": {
-        "node": ">=4"
+        "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/parser": {
-      "version": "7.24.7",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.24.7.tgz",
-      "integrity": "sha512-9uUYRm6OqQrCqQdG1iCBwBPZgN8ciDBro2nIOFaiRz1/BCxaI7CNvQbDHvsArAC7Tw9Hda/B3U+6ui9u4HWXPw==",
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.0.tgz",
+      "integrity": "sha512-jVZGvOxOuNSsuQuLRTh13nU0AogFlw32w/MT+LV6D3sP5WdbW61E77RnkbaO2dUvmPAYrBDJXGn5gGS6tH4j8g==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.0"
+      },
       "bin": {
         "parser": "bin/babel-parser.js"
       },
@@ -493,6 +670,122 @@
         "node": ">=6.0.0"
       }
     },
+    "node_modules/@babel/plugin-syntax-jsx": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.27.1.tgz",
+      "integrity": "sha512-y8YTNIeKoyhGd9O0Jiyzyyqk8gdjnumGTQPsz0xOZOQ2RmkVJeZ1vmmfIvFEKqucBG6axJGBZDE/7iI5suUI/w==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-typescript": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.27.1.tgz",
+      "integrity": "sha512-xfYCBMxveHrRMnAWl1ZlPXOZjzkN82THFvLhQhFXFt81Z5HnN+EtUkZhv/zcKpmT3fzmWZB0ywiBrbC3vogbwQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-modules-commonjs": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.27.1.tgz",
+      "integrity": "sha512-OJguuwlTYlN0gBZFRPqwOGNWssZjfIUdS7HMYtN8c1KmwpwHFBwTeFZrg9XZa+DFTitWOW5iTAG7tyCUPsCCyw==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-transforms": "^7.27.1",
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-self": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz",
+      "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-source": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz",
+      "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-typescript": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.28.0.tgz",
+      "integrity": "sha512-4AEiDEBPIZvLQaWlc9liCavE0xRM0dNca41WtBeM3jgFptfUOSG9z0uteLhq6+3rq+WB6jIvUwKDTpXEHPJ2Vg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-annotate-as-pure": "^7.27.3",
+        "@babel/helper-create-class-features-plugin": "^7.27.1",
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1",
+        "@babel/plugin-syntax-typescript": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/preset-typescript": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/preset-typescript/-/preset-typescript-7.27.1.tgz",
+      "integrity": "sha512-l7WfQfX0WK4M0v2RudjuQK4u99BS6yLHYEmdtVPP7lKV013zr9DygFuWNlnbvQ9LR+LS0Egz/XAvGx5U9MX0fQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1",
+        "@babel/helper-validator-option": "^7.27.1",
+        "@babel/plugin-syntax-jsx": "^7.27.1",
+        "@babel/plugin-transform-modules-commonjs": "^7.27.1",
+        "@babel/plugin-transform-typescript": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
     "node_modules/@babel/runtime": {
       "version": "7.26.10",
       "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.26.10.tgz",
@@ -506,33 +799,32 @@
       }
     },
     "node_modules/@babel/template": {
-      "version": "7.24.7",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.24.7.tgz",
-      "integrity": "sha512-jYqfPrU9JTF0PmPy1tLYHW4Mp4KlgxJD9l2nP9fD6yT/ICi554DmrWBAEYpIelzjHf1msDP3PxJIRt/nFNfBig==",
+      "version": "7.27.2",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.2.tgz",
+      "integrity": "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==",
+      "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.24.7",
-        "@babel/parser": "^7.24.7",
-        "@babel/types": "^7.24.7"
+        "@babel/code-frame": "^7.27.1",
+        "@babel/parser": "^7.27.2",
+        "@babel/types": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/traverse": {
-      "version": "7.24.7",
-      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.24.7.tgz",
-      "integrity": "sha512-yb65Ed5S/QAcewNPh0nZczy9JdYXkkAbIsEo+P7BE7yO3txAY30Y/oPa3QkQ5It3xVG2kpKMg9MsdxZaO31uKA==",
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.0.tgz",
+      "integrity": "sha512-mGe7UK5wWyh0bKRfupsUchrQGqvDbZDbKJw+kcRGSmdHVYrv+ltd0pnpDTVpiTqnaBru9iEvA8pz8W46v0Amwg==",
+      "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.24.7",
-        "@babel/generator": "^7.24.7",
-        "@babel/helper-environment-visitor": "^7.24.7",
-        "@babel/helper-function-name": "^7.24.7",
-        "@babel/helper-hoist-variables": "^7.24.7",
-        "@babel/helper-split-export-declaration": "^7.24.7",
-        "@babel/parser": "^7.24.7",
-        "@babel/types": "^7.24.7",
-        "debug": "^4.3.1",
-        "globals": "^11.1.0"
+        "@babel/code-frame": "^7.27.1",
+        "@babel/generator": "^7.28.0",
+        "@babel/helper-globals": "^7.28.0",
+        "@babel/parser": "^7.28.0",
+        "@babel/template": "^7.27.2",
+        "@babel/types": "^7.28.0",
+        "debug": "^4.3.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -554,27 +846,19 @@
         }
       }
     },
-    "node_modules/@babel/traverse/node_modules/globals": {
-      "version": "11.12.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz",
-      "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==",
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/@babel/traverse/node_modules/ms": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
       "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
     },
     "node_modules/@babel/types": {
-      "version": "7.24.7",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.24.7.tgz",
-      "integrity": "sha512-XEFXSlxiG5td2EJRe8vOmRbaXVgfcBlszKujvVmWIK/UpywWljQCfzAv3RQCGujWQ1RD4YYWEAqDXfuJiy8f5Q==",
+      "version": "7.28.2",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.2.tgz",
+      "integrity": "sha512-ruv7Ae4J5dUYULmeXw1gmb7rYRz57OWCPM57pHojnLq/3Z1CK2lNSLTCVjxVk1F/TZHwOZZrOWi0ur95BbLxNQ==",
+      "license": "MIT",
       "dependencies": {
-        "@babel/helper-string-parser": "^7.24.7",
-        "@babel/helper-validator-identifier": "^7.24.7",
-        "to-fast-properties": "^2.0.0"
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.27.1"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -794,7 +1078,6 @@
       "cpu": [
         "x64"
       ],
-      "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
@@ -1408,11 +1691,31 @@
         "url": "https://opencollective.com/libvips"
       }
     },
+    "node_modules/@isaacs/balanced-match": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/@isaacs/balanced-match/-/balanced-match-4.0.1.tgz",
+      "integrity": "sha512-yzMTt9lEb8Gv7zRioUilSglI0c0smZ9k5D65677DLWLtWJaXIS3CqcGyUFByYKlnUj6TkjLVs54fBl6+TiGQDQ==",
+      "license": "MIT",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/@isaacs/brace-expansion": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/@isaacs/brace-expansion/-/brace-expansion-5.0.0.tgz",
+      "integrity": "sha512-ZT55BDLV0yv0RBm2czMiZ+SqCGO7AvmOM3G/w2xhVPH+te0aKgFjmBvGlL1dH+ql2tgGO3MVrbb3jCKyvpgnxA==",
+      "license": "MIT",
+      "dependencies": {
+        "@isaacs/balanced-match": "^4.0.1"
+      },
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
     "node_modules/@isaacs/cliui": {
       "version": "8.0.2",
       "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
       "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==",
-      "dev": true,
       "license": "ISC",
       "dependencies": {
         "string-width": "^5.1.2",
@@ -1430,7 +1733,6 @@
       "version": "6.1.0",
       "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
       "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=12"
@@ -1443,7 +1745,6 @@
       "version": "6.2.1",
       "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz",
       "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=12"
@@ -1456,7 +1757,6 @@
       "version": "5.1.2",
       "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
       "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "eastasianwidth": "^0.2.0",
@@ -1474,7 +1774,6 @@
       "version": "7.1.0",
       "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
       "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "ansi-regex": "^6.0.1"
@@ -1490,7 +1789,6 @@
       "version": "8.1.0",
       "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
       "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "ansi-styles": "^6.1.0",
@@ -1505,16 +1803,13 @@
       }
     },
     "node_modules/@jridgewell/gen-mapping": {
-      "version": "0.3.5",
-      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.5.tgz",
-      "integrity": "sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==",
+      "version": "0.3.12",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.12.tgz",
+      "integrity": "sha512-OuLGC46TjB5BbN1dH8JULVVZY4WTdkF7tV9Ys6wLL1rubZnCMstOhNHueU5bLCrnRuDhKPDM4g6sw4Bel5Gzqg==",
+      "license": "MIT",
       "dependencies": {
-        "@jridgewell/set-array": "^1.2.1",
-        "@jridgewell/sourcemap-codec": "^1.4.10",
+        "@jridgewell/sourcemap-codec": "^1.5.0",
         "@jridgewell/trace-mapping": "^0.3.24"
-      },
-      "engines": {
-        "node": ">=6.0.0"
       }
     },
     "node_modules/@jridgewell/resolve-uri": {
@@ -1525,14 +1820,6 @@
         "node": ">=6.0.0"
       }
     },
-    "node_modules/@jridgewell/set-array": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz",
-      "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==",
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
     "node_modules/@jridgewell/source-map": {
       "version": "0.3.6",
       "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.6.tgz",
@@ -1545,14 +1832,16 @@
       }
     },
     "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.4.15",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz",
-      "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg=="
+      "version": "1.5.4",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.4.tgz",
+      "integrity": "sha512-VT2+G1VQs/9oz078bLrYbecdZKs912zQlkelYpuf+SXF+QvZDYJlbx/LSx+meSAwdDFnF8FVXW92AVjjkVmgFw==",
+      "license": "MIT"
     },
     "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.25",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz",
-      "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==",
+      "version": "0.3.29",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.29.tgz",
+      "integrity": "sha512-uw6guiW/gcAGPDhLmd77/6lW8QLeiV5RUTsAX46Db6oLhGaVj4lhnPwb184s1bkc8kdVg/+h988dro8GRDpmYQ==",
+      "license": "MIT",
       "dependencies": {
         "@jridgewell/resolve-uri": "^3.1.0",
         "@jridgewell/sourcemap-codec": "^1.4.14"
@@ -1700,19 +1989,46 @@
         "react": ">=16"
       }
     },
-    "node_modules/@next/env": {
-      "version": "15.3.4",
-      "resolved": "https://registry.npmjs.org/@next/env/-/env-15.3.4.tgz",
-      "integrity": "sha512-ZkdYzBseS6UjYzz6ylVKPOK+//zLWvD6Ta+vpoye8cW11AjiQjGYVibF0xuvT4L0iJfAPfZLFidaEzAOywyOAQ==",
-      "license": "MIT"
-    },
-    "node_modules/@next/eslint-plugin-next": {
-      "version": "13.4.12",
-      "resolved": "https://registry.npmjs.org/@next/eslint-plugin-next/-/eslint-plugin-next-13.4.12.tgz",
-      "integrity": "sha512-6rhK9CdxEgj/j1qvXIyLTWEaeFv7zOK8yJMulz3Owel0uek0U9MJCGzmKgYxM3aAUBo3gKeywCZKyQnJKto60A==",
+    "node_modules/@mdx-js/rollup": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@mdx-js/rollup/-/rollup-3.1.0.tgz",
+      "integrity": "sha512-q4xOtUXpCzeouE8GaJ8StT4rDxm/U5j6lkMHL2srb2Q3Y7cobE0aXyPzXVVlbeIMBi+5R5MpbiaVE5/vJUdnHg==",
+      "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "glob": "7.1.7"
-      }
+        "@mdx-js/mdx": "^3.0.0",
+        "@rollup/pluginutils": "^5.0.0",
+        "source-map": "^0.7.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      },
+      "peerDependencies": {
+        "rollup": ">=2"
+      }
+    },
+    "node_modules/@mjackson/node-fetch-server": {
+      "version": "0.7.0",
+      "resolved": "https://registry.npmjs.org/@mjackson/node-fetch-server/-/node-fetch-server-0.7.0.tgz",
+      "integrity": "sha512-un8diyEBKU3BTVj3GzlTPA1kIjCkGdD+AMYQy31Gf9JCkfoZzwgJ79GUtHrF2BN3XPNMLpubbzPcxys+a3uZEw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@next/env": {
+      "version": "15.3.4",
+      "resolved": "https://registry.npmjs.org/@next/env/-/env-15.3.4.tgz",
+      "integrity": "sha512-ZkdYzBseS6UjYzz6ylVKPOK+//zLWvD6Ta+vpoye8cW11AjiQjGYVibF0xuvT4L0iJfAPfZLFidaEzAOywyOAQ==",
+      "license": "MIT"
+    },
+    "node_modules/@next/eslint-plugin-next": {
+      "version": "13.4.12",
+      "resolved": "https://registry.npmjs.org/@next/eslint-plugin-next/-/eslint-plugin-next-13.4.12.tgz",
+      "integrity": "sha512-6rhK9CdxEgj/j1qvXIyLTWEaeFv7zOK8yJMulz3Owel0uek0U9MJCGzmKgYxM3aAUBo3gKeywCZKyQnJKto60A==",
+      "dependencies": {
+        "glob": "7.1.7"
+      }
     },
     "node_modules/@next/eslint-plugin-next/node_modules/glob": {
       "version": "7.1.7",
@@ -1893,11 +2209,151 @@
         "node": ">= 8"
       }
     },
+    "node_modules/@npmcli/git": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@npmcli/git/-/git-4.1.0.tgz",
+      "integrity": "sha512-9hwoB3gStVfa0N31ymBmrX+GuDGdVA/QWShZVqE0HK2Af+7QGGrCTbZia/SW0ImUTjTne7SP91qxDmtXvDHRPQ==",
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/promise-spawn": "^6.0.0",
+        "lru-cache": "^7.4.4",
+        "npm-pick-manifest": "^8.0.0",
+        "proc-log": "^3.0.0",
+        "promise-inflight": "^1.0.1",
+        "promise-retry": "^2.0.1",
+        "semver": "^7.3.5",
+        "which": "^3.0.0"
+      },
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
+    "node_modules/@npmcli/git/node_modules/lru-cache": {
+      "version": "7.18.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz",
+      "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@npmcli/git/node_modules/which": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/which/-/which-3.0.1.tgz",
+      "integrity": "sha512-XA1b62dzQzLfaEOSQFTCOd5KFf/1VSzZo7/7TUjnya6u0vGGKzU96UQBZTAThCb2j4/xjBAyii1OhRLJEivHvg==",
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/which.js"
+      },
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
+    "node_modules/@npmcli/package-json": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/@npmcli/package-json/-/package-json-4.0.1.tgz",
+      "integrity": "sha512-lRCEGdHZomFsURroh522YvA/2cVb9oPIJrjHanCJZkiasz1BzcnLr3tBJhlV7S86MBJBuAQ33is2D60YitZL2Q==",
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/git": "^4.1.0",
+        "glob": "^10.2.2",
+        "hosted-git-info": "^6.1.1",
+        "json-parse-even-better-errors": "^3.0.0",
+        "normalize-package-data": "^5.0.0",
+        "proc-log": "^3.0.0",
+        "semver": "^7.5.3"
+      },
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
+    "node_modules/@npmcli/package-json/node_modules/brace-expansion": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/@npmcli/package-json/node_modules/glob": {
+      "version": "10.4.5",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
+      "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
+      "license": "ISC",
+      "dependencies": {
+        "foreground-child": "^3.1.0",
+        "jackspeak": "^3.1.2",
+        "minimatch": "^9.0.4",
+        "minipass": "^7.1.2",
+        "package-json-from-dist": "^1.0.0",
+        "path-scurry": "^1.11.1"
+      },
+      "bin": {
+        "glob": "dist/esm/bin.mjs"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/@npmcli/package-json/node_modules/json-parse-even-better-errors": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-3.0.2.tgz",
+      "integrity": "sha512-fi0NG4bPjCHunUJffmLd0gxssIgkNmArMvis4iNah6Owg1MCJjWhEcDLmsK6iGkJq3tHwbDkTlce70/tmXN4cQ==",
+      "license": "MIT",
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
+    "node_modules/@npmcli/package-json/node_modules/minimatch": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/@npmcli/promise-spawn": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@npmcli/promise-spawn/-/promise-spawn-6.0.2.tgz",
+      "integrity": "sha512-gGq0NJkIGSwdbUt4yhdF8ZrmkGKVz9vAdVzpOfnom+V8PLSmSOVhZwbNvZZS1EYcJN5hzzKBxmmVVAInM6HQLg==",
+      "license": "ISC",
+      "dependencies": {
+        "which": "^3.0.0"
+      },
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
+    "node_modules/@npmcli/promise-spawn/node_modules/which": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/which/-/which-3.0.1.tgz",
+      "integrity": "sha512-XA1b62dzQzLfaEOSQFTCOd5KFf/1VSzZo7/7TUjnya6u0vGGKzU96UQBZTAThCb2j4/xjBAyii1OhRLJEivHvg==",
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/which.js"
+      },
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
     "node_modules/@pkgjs/parseargs": {
       "version": "0.11.0",
       "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
       "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==",
-      "dev": true,
       "license": "MIT",
       "optional": true,
       "engines": {
@@ -1990,6 +2446,156 @@
         "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1"
       }
     },
+    "node_modules/@react-router/dev": {
+      "version": "7.7.1",
+      "resolved": "https://registry.npmjs.org/@react-router/dev/-/dev-7.7.1.tgz",
+      "integrity": "sha512-ByfgHmAyfx/JQYN/QwUx1sFJlBA5Z3HQAZ638wHSb+m6khWtHqSaKCvPqQh1P00wdEAeV3tX5L1aUM/ceCF6+w==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.27.7",
+        "@babel/generator": "^7.27.5",
+        "@babel/parser": "^7.27.7",
+        "@babel/plugin-syntax-jsx": "^7.27.1",
+        "@babel/preset-typescript": "^7.27.1",
+        "@babel/traverse": "^7.27.7",
+        "@babel/types": "^7.27.7",
+        "@npmcli/package-json": "^4.0.1",
+        "@react-router/node": "7.7.1",
+        "arg": "^5.0.1",
+        "babel-dead-code-elimination": "^1.0.6",
+        "chokidar": "^4.0.0",
+        "dedent": "^1.5.3",
+        "es-module-lexer": "^1.3.1",
+        "exit-hook": "2.2.1",
+        "isbot": "^5.1.11",
+        "jsesc": "3.0.2",
+        "lodash": "^4.17.21",
+        "pathe": "^1.1.2",
+        "picocolors": "^1.1.1",
+        "prettier": "^3.6.2",
+        "react-refresh": "^0.14.0",
+        "semver": "^7.3.7",
+        "set-cookie-parser": "^2.6.0",
+        "tinyglobby": "^0.2.14",
+        "valibot": "^0.41.0",
+        "vite-node": "^3.2.2"
+      },
+      "bin": {
+        "react-router": "bin.js"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "@react-router/serve": "^7.7.1",
+        "react-router": "^7.7.1",
+        "typescript": "^5.1.0",
+        "vite": "^5.1.0 || ^6.0.0 || ^7.0.0",
+        "wrangler": "^3.28.2 || ^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@react-router/serve": {
+          "optional": true
+        },
+        "typescript": {
+          "optional": true
+        },
+        "wrangler": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@react-router/dev/node_modules/chokidar": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
+      "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==",
+      "license": "MIT",
+      "dependencies": {
+        "readdirp": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 14.16.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/@react-router/dev/node_modules/jsesc": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.0.2.tgz",
+      "integrity": "sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==",
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/@react-router/dev/node_modules/prettier": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.6.2.tgz",
+      "integrity": "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==",
+      "license": "MIT",
+      "bin": {
+        "prettier": "bin/prettier.cjs"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/prettier/prettier?sponsor=1"
+      }
+    },
+    "node_modules/@react-router/dev/node_modules/react-refresh": {
+      "version": "0.14.2",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.14.2.tgz",
+      "integrity": "sha512-jCvmsr+1IUSMUyzOkRcvnVbX3ZYC6g9TDrDbFuFmRDq7PD4yaGbLKNQL6k2jnArV8hjYxh7hVhAZB6s9HDGpZA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/@react-router/dev/node_modules/readdirp": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz",
+      "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.18.0"
+      },
+      "funding": {
+        "type": "individual",
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/@react-router/node": {
+      "version": "7.7.1",
+      "resolved": "https://registry.npmjs.org/@react-router/node/-/node-7.7.1.tgz",
+      "integrity": "sha512-EHd6PEcw2nmcJmcYTPA0MmRWSqOaJ/meycfCp0ADA9T/6b7+fUHfr9XcNyf7UeZtYwu4zGyuYfPmLU5ic6Ugyg==",
+      "license": "MIT",
+      "dependencies": {
+        "@mjackson/node-fetch-server": "^0.2.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "react-router": "7.7.1",
+        "typescript": "^5.1.0"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@react-router/node/node_modules/@mjackson/node-fetch-server": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/@mjackson/node-fetch-server/-/node-fetch-server-0.2.0.tgz",
+      "integrity": "sha512-EMlH1e30yzmTpGLQjlFmaDAjyOeZhng1/XCd7DExR8PNAnG/G1tyruZxEoUe11ClnwGhGrtsdnyyUx1frSzjng==",
+      "license": "MIT"
+    },
     "node_modules/@react-stately/flags": {
       "version": "3.1.2",
       "resolved": "https://registry.npmjs.org/@react-stately/flags/-/flags-3.1.2.tgz",
@@ -2114,58 +2720,368 @@
         "node": ">=20.11.0"
       }
     },
-    "node_modules/@rushstack/eslint-patch": {
-      "version": "1.3.2",
-      "resolved": "https://registry.npmjs.org/@rushstack/eslint-patch/-/eslint-patch-1.3.2.tgz",
-      "integrity": "sha512-V+MvGwaHH03hYhY+k6Ef/xKd6RYlc4q8WBx+2ANmipHJcKuktNcI/NgEsJgdSUF6Lw32njT6OnrRsKYCdgHjYw=="
-    },
-    "node_modules/@swc/counter": {
-      "version": "0.1.3",
-      "resolved": "https://registry.npmjs.org/@swc/counter/-/counter-0.1.3.tgz",
-      "integrity": "sha512-e2BR4lsJkkRlKZ/qCHPw9ZaSxc0MVUd7gtbtaB7aMvHeJVYe8sOB8DBZkP2DtISHGSku9sCK6T6cnY0CtXrOCQ==",
-      "license": "Apache-2.0"
-    },
-    "node_modules/@swc/helpers": {
-      "version": "0.5.17",
-      "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.17.tgz",
-      "integrity": "sha512-5IKx/Y13RsYd+sauPb2x+U/xZikHjolzfuDgTAl/Tdf3Q8rslRvC19NKDLgAJQ6wsqADk10ntlv08nPFw/gO/A==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "tslib": "^2.8.0"
-      }
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-beta.27",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz",
+      "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==",
+      "dev": true,
+      "license": "MIT"
     },
-    "node_modules/@tanstack/react-virtual": {
-      "version": "3.13.10",
-      "resolved": "https://registry.npmjs.org/@tanstack/react-virtual/-/react-virtual-3.13.10.tgz",
-      "integrity": "sha512-nvrzk4E9mWB4124YdJ7/yzwou7IfHxlSef6ugCFcBfRmsnsma3heciiiV97sBNxyc3VuwtZvmwXd0aB5BpucVw==",
+    "node_modules/@rollup/pluginutils": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.2.0.tgz",
+      "integrity": "sha512-qWJ2ZTbmumwiLFomfzTyt5Kng4hwPi9rwCYN4SHb6eaRU1KNO4ccxINHr/VhH4GgPlt1XfSTLX2LBTme8ne4Zw==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@tanstack/virtual-core": "3.13.10"
+        "@types/estree": "^1.0.0",
+        "estree-walker": "^2.0.2",
+        "picomatch": "^4.0.2"
       },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/tannerlinsley"
+      "engines": {
+        "node": ">=14.0.0"
       },
       "peerDependencies": {
-        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
-        "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
       }
     },
-    "node_modules/@tanstack/virtual-core": {
-      "version": "3.13.10",
-      "resolved": "https://registry.npmjs.org/@tanstack/virtual-core/-/virtual-core-3.13.10.tgz",
-      "integrity": "sha512-sPEDhXREou5HyZYqSWIqdU580rsF6FGeN7vpzijmP3KTiOGjOMZASz4Y6+QKjiFQwhWrR58OP8izYaNGVxvViA==",
+    "node_modules/@rollup/pluginutils/node_modules/estree-walker": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/pluginutils/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
       "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
       "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/tannerlinsley"
+        "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
-    "node_modules/@trysound/sax": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/@trysound/sax/-/sax-0.2.0.tgz",
-      "integrity": "sha512-L7z9BgrNEcYyUYtF+HaEfiS5ebkh9jXqbszz7pC0hRBPaatV0XjSD3+eHrpqFemQfgwiFF0QPIarnIihIDn7OA==",
-      "dev": true,
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.46.2.tgz",
+      "integrity": "sha512-Zj3Hl6sN34xJtMv7Anwb5Gu01yujyE/cLBDB2gnHTAHaWS1Z38L7kuSG+oAh0giZMqG060f/YBStXtMH6FvPMA==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.46.2.tgz",
+      "integrity": "sha512-nTeCWY83kN64oQ5MGz3CgtPx8NSOhC5lWtsjTs+8JAJNLcP3QbLCtDDgUKQc/Ro/frpMq4SHUaHN6AMltcEoLQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.46.2.tgz",
+      "integrity": "sha512-HV7bW2Fb/F5KPdM/9bApunQh68YVDU8sO8BvcW9OngQVN3HHHkw99wFupuUJfGR9pYLLAjcAOA6iO+evsbBaPQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.46.2.tgz",
+      "integrity": "sha512-SSj8TlYV5nJixSsm/y3QXfhspSiLYP11zpfwp6G/YDXctf3Xkdnk4woJIF5VQe0of2OjzTt8EsxnJDCdHd2xMA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.46.2.tgz",
+      "integrity": "sha512-ZyrsG4TIT9xnOlLsSSi9w/X29tCbK1yegE49RYm3tu3wF1L/B6LVMqnEWyDB26d9Ecx9zrmXCiPmIabVuLmNSg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.46.2.tgz",
+      "integrity": "sha512-pCgHFoOECwVCJ5GFq8+gR8SBKnMO+xe5UEqbemxBpCKYQddRQMgomv1104RnLSg7nNvgKy05sLsY51+OVRyiVw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.46.2.tgz",
+      "integrity": "sha512-EtP8aquZ0xQg0ETFcxUbU71MZlHaw9MChwrQzatiE8U/bvi5uv/oChExXC4mWhjiqK7azGJBqU0tt5H123SzVA==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.46.2.tgz",
+      "integrity": "sha512-qO7F7U3u1nfxYRPM8HqFtLd+raev2K137dsV08q/LRKRLEc7RsiDWihUnrINdsWQxPR9jqZ8DIIZ1zJJAm5PjQ==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.46.2.tgz",
+      "integrity": "sha512-3dRaqLfcOXYsfvw5xMrxAk9Lb1f395gkoBYzSFcc/scgRFptRXL9DOaDpMiehf9CO8ZDRJW2z45b6fpU5nwjng==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.46.2.tgz",
+      "integrity": "sha512-fhHFTutA7SM+IrR6lIfiHskxmpmPTJUXpWIsBXpeEwNgZzZZSg/q4i6FU4J8qOGyJ0TR+wXBwx/L7Ho9z0+uDg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loongarch64-gnu": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.46.2.tgz",
+      "integrity": "sha512-i7wfGFXu8x4+FRqPymzjD+Hyav8l95UIZ773j7J7zRYc3Xsxy2wIn4x+llpunexXe6laaO72iEjeeGyUFmjKeA==",
+      "cpu": [
+        "loong64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.46.2.tgz",
+      "integrity": "sha512-B/l0dFcHVUnqcGZWKcWBSV2PF01YUt0Rvlurci5P+neqY/yMKchGU8ullZvIv5e8Y1C6wOn+U03mrDylP5q9Yw==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.46.2.tgz",
+      "integrity": "sha512-32k4ENb5ygtkMwPMucAb8MtV8olkPT03oiTxJbgkJa7lJ7dZMr0GCFJlyvy+K8iq7F/iuOr41ZdUHaOiqyR3iQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.46.2.tgz",
+      "integrity": "sha512-t5B2loThlFEauloaQkZg9gxV05BYeITLvLkWOkRXogP4qHXLkWSbSHKM9S6H1schf/0YGP/qNKtiISlxvfmmZw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.46.2.tgz",
+      "integrity": "sha512-YKjekwTEKgbB7n17gmODSmJVUIvj8CX7q5442/CK80L8nqOUbMtf8b01QkG3jOqyr1rotrAnW6B/qiHwfcuWQA==",
+      "cpu": [
+        "s390x"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.46.2.tgz",
+      "integrity": "sha512-Jj5a9RUoe5ra+MEyERkDKLwTXVu6s3aACP51nkfnK9wJTraCC8IMe3snOfALkrjTYd2G1ViE1hICj0fZ7ALBPA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.46.2.tgz",
+      "integrity": "sha512-7kX69DIrBeD7yNp4A5b81izs8BqoZkCIaxQaOpumcJ1S/kmqNFjPhDu1LHeVXv0SexfHQv5cqHsxLOjETuqDuA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.46.2.tgz",
+      "integrity": "sha512-wiJWMIpeaak/jsbaq2HMh/rzZxHVW1rU6coyeNNpMwk5isiPjSTx0a4YLSlYDwBH/WBvLz+EtsNqQScZTLJy3g==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.46.2.tgz",
+      "integrity": "sha512-gBgaUDESVzMgWZhcyjfs9QFK16D8K6QZpwAaVNJxYDLHWayOta4ZMjGm/vsAEy3hvlS2GosVFlBlP9/Wb85DqQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.46.2.tgz",
+      "integrity": "sha512-CvUo2ixeIQGtF6WvuB87XWqPQkoFAFqW+HUo/WzHwuHDvIwZCtjdWXoYCcr06iKGydiqTclC4jU/TNObC/xKZg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rushstack/eslint-patch": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/@rushstack/eslint-patch/-/eslint-patch-1.3.2.tgz",
+      "integrity": "sha512-V+MvGwaHH03hYhY+k6Ef/xKd6RYlc4q8WBx+2ANmipHJcKuktNcI/NgEsJgdSUF6Lw32njT6OnrRsKYCdgHjYw=="
+    },
+    "node_modules/@swc/counter": {
+      "version": "0.1.3",
+      "resolved": "https://registry.npmjs.org/@swc/counter/-/counter-0.1.3.tgz",
+      "integrity": "sha512-e2BR4lsJkkRlKZ/qCHPw9ZaSxc0MVUd7gtbtaB7aMvHeJVYe8sOB8DBZkP2DtISHGSku9sCK6T6cnY0CtXrOCQ==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@swc/helpers": {
+      "version": "0.5.17",
+      "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.17.tgz",
+      "integrity": "sha512-5IKx/Y13RsYd+sauPb2x+U/xZikHjolzfuDgTAl/Tdf3Q8rslRvC19NKDLgAJQ6wsqADk10ntlv08nPFw/gO/A==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.8.0"
+      }
+    },
+    "node_modules/@tanstack/react-virtual": {
+      "version": "3.13.10",
+      "resolved": "https://registry.npmjs.org/@tanstack/react-virtual/-/react-virtual-3.13.10.tgz",
+      "integrity": "sha512-nvrzk4E9mWB4124YdJ7/yzwou7IfHxlSef6ugCFcBfRmsnsma3heciiiV97sBNxyc3VuwtZvmwXd0aB5BpucVw==",
+      "license": "MIT",
+      "dependencies": {
+        "@tanstack/virtual-core": "3.13.10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/tannerlinsley"
+      },
+      "peerDependencies": {
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/@tanstack/virtual-core": {
+      "version": "3.13.10",
+      "resolved": "https://registry.npmjs.org/@tanstack/virtual-core/-/virtual-core-3.13.10.tgz",
+      "integrity": "sha512-sPEDhXREou5HyZYqSWIqdU580rsF6FGeN7vpzijmP3KTiOGjOMZASz4Y6+QKjiFQwhWrR58OP8izYaNGVxvViA==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/tannerlinsley"
+      }
+    },
+    "node_modules/@trysound/sax": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/@trysound/sax/-/sax-0.2.0.tgz",
+      "integrity": "sha512-L7z9BgrNEcYyUYtF+HaEfiS5ebkh9jXqbszz7pC0hRBPaatV0XjSD3+eHrpqFemQfgwiFF0QPIarnIihIDn7OA==",
+      "dev": true,
       "engines": {
         "node": ">=10.13.0"
       }
@@ -2178,6 +3094,51 @@
         "@types/estree": "*"
       }
     },
+    "node_modules/@types/babel__core": {
+      "version": "7.20.5",
+      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.20.7",
+        "@babel/types": "^7.20.7",
+        "@types/babel__generator": "*",
+        "@types/babel__template": "*",
+        "@types/babel__traverse": "*"
+      }
+    },
+    "node_modules/@types/babel__generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__template": {
+      "version": "7.4.4",
+      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.1.0",
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__traverse": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
+      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.2"
+      }
+    },
     "node_modules/@types/debug": {
       "version": "4.1.8",
       "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.8.tgz",
@@ -2187,9 +3148,9 @@
       }
     },
     "node_modules/@types/estree": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz",
-      "integrity": "sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==",
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
       "license": "MIT"
     },
     "node_modules/@types/estree-jsx": {
@@ -2223,13 +3184,14 @@
       "integrity": "sha512-iiUgKzV9AuaEkZqkOLDIvlQiL6ltuZd9tGcW3gwpnX8JbuiuhFlEGmmFXEXkN50Cvq7Os88IY2v0dkDqXYWVgA=="
     },
     "node_modules/@types/node": {
-      "version": "20.12.12",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.12.12.tgz",
-      "integrity": "sha512-eWLDGF/FOSPtAvEqeRAQ4C8LSA7M1I7i0ky1I8U7kD1J5ITyW3AsRhQrKVoWf5pFKZ2kILsEGJhsI9r93PYnOw==",
+      "version": "24.2.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.2.0.tgz",
+      "integrity": "sha512-3xyG3pMCq3oYCNg7/ZP+E1ooTaGB4cG8JWRsqqOYQdbWNY4zbaV0Ennrd7stjiJEFZCaybcIgpTjJWHRfBSIDw==",
       "devOptional": true,
+      "license": "MIT",
       "peer": true,
       "dependencies": {
-        "undici-types": "~5.26.4"
+        "undici-types": "~7.10.0"
       }
     },
     "node_modules/@types/prop-types": {
@@ -2400,15 +3362,57 @@
       "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.0.tgz",
       "integrity": "sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ=="
     },
-    "node_modules/@webassemblyjs/ast": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.14.1.tgz",
-      "integrity": "sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ==",
-      "devOptional": true,
+    "node_modules/@vitejs/plugin-react": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz",
+      "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==",
+      "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
-        "@webassemblyjs/helper-numbers": "1.13.2",
+        "@babel/core": "^7.28.0",
+        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
+        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
+        "@rolldown/pluginutils": "1.0.0-beta.27",
+        "@types/babel__core": "^7.20.5",
+        "react-refresh": "^0.17.0"
+      },
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+      }
+    },
+    "node_modules/@vitejs/plugin-rsc": {
+      "version": "0.4.16",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-rsc/-/plugin-rsc-0.4.16.tgz",
+      "integrity": "sha512-QIURKHMpMiwWPi78/9nBzW6wN0PKt3rqNMsLw7NRz5ZuayQVq6hZlH0fP018m6/giFDDHKokb8Hy+bvHrtdrqw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@mjackson/node-fetch-server": "^0.7.0",
+        "es-module-lexer": "^1.7.0",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.17",
+        "periscopic": "^4.0.2",
+        "turbo-stream": "^3.1.0",
+        "vitefu": "^1.1.1"
+      },
+      "peerDependencies": {
+        "react": "*",
+        "react-dom": "*",
+        "vite": "*"
+      }
+    },
+    "node_modules/@webassemblyjs/ast": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.14.1.tgz",
+      "integrity": "sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ==",
+      "devOptional": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@webassemblyjs/helper-numbers": "1.13.2",
         "@webassemblyjs/helper-wasm-bytecode": "1.13.2"
       }
     },
@@ -2738,8 +3742,7 @@
     "node_modules/arg": {
       "version": "5.0.2",
       "resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz",
-      "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==",
-      "dev": true
+      "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg=="
     },
     "node_modules/argparse": {
       "version": "2.0.1",
@@ -3015,6 +4018,18 @@
         "dequal": "^2.0.3"
       }
     },
+    "node_modules/babel-dead-code-elimination": {
+      "version": "1.0.10",
+      "resolved": "https://registry.npmjs.org/babel-dead-code-elimination/-/babel-dead-code-elimination-1.0.10.tgz",
+      "integrity": "sha512-DV5bdJZTzZ0zn0DC24v3jD7Mnidh6xhKa4GfKCbq3sfW8kaWhDdZjP3i81geA8T33tdYqWKw4D3fVv0CwEgKVA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.23.7",
+        "@babel/parser": "^7.23.6",
+        "@babel/traverse": "^7.23.7",
+        "@babel/types": "^7.23.6"
+      }
+    },
     "node_modules/bail": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz",
@@ -3145,7 +4160,6 @@
       "version": "4.24.2",
       "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.2.tgz",
       "integrity": "sha512-ZIc+Q62revdMcqC6aChtW4jz3My3klmCO1fEmINZY/8J3EpBg5/A/D0AKmBveUh6pgoeycoMkVMko84tuYS+Gg==",
-      "devOptional": true,
       "funding": [
         {
           "type": "opencollective",
@@ -3214,6 +4228,15 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/cac": {
+      "version": "6.7.14",
+      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
+      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/call-bind": {
       "version": "1.0.7",
       "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.7.tgz",
@@ -3531,6 +4554,12 @@
         "node": ">= 0.6"
       }
     },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "license": "MIT"
+    },
     "node_modules/cookie": {
       "version": "0.7.1",
       "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz",
@@ -3812,6 +4841,20 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/dedent": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/dedent/-/dedent-1.6.0.tgz",
+      "integrity": "sha512-F1Z+5UCFpmQUzJa11agbyPVMbpgT/qA3/SKyJ1jyBgm7dUcUEa8v9JwDkerSQXfakBwFljIxhOJqGkjUwZ9FSA==",
+      "license": "MIT",
+      "peerDependencies": {
+        "babel-plugin-macros": "^3.1.0"
+      },
+      "peerDependenciesMeta": {
+        "babel-plugin-macros": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/deep-is": {
       "version": "0.1.4",
       "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
@@ -4085,7 +5128,6 @@
       "version": "0.2.0",
       "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
       "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/ecc-jsbn": {
@@ -4106,7 +5148,6 @@
       "version": "1.5.68",
       "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.68.tgz",
       "integrity": "sha512-FgMdJlma0OzUYlbrtZ4AeXjKxKPk6KT8WOP8BjcqxWtlg8qyJQjRzPJzUtUn5GBg1oQ26hFs7HOOHJMYiJRnvQ==",
-      "devOptional": true,
       "license": "ISC"
     },
     "node_modules/emoji-regex": {
@@ -4155,6 +5196,12 @@
         "url": "https://github.com/fb55/entities?sponsor=1"
       }
     },
+    "node_modules/err-code": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/err-code/-/err-code-2.0.3.tgz",
+      "integrity": "sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==",
+      "license": "MIT"
+    },
     "node_modules/es-abstract": {
       "version": "1.22.1",
       "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.22.1.tgz",
@@ -4232,11 +5279,10 @@
       }
     },
     "node_modules/es-module-lexer": {
-      "version": "1.5.3",
-      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.5.3.tgz",
-      "integrity": "sha512-i1gCgmR9dCl6Vil6UKPI/trA69s08g/syhiDK9TG0Nf1RJjjFI+AzoWW7sPufzkgYAn861skuCwJa0pIIHYxvg==",
-      "devOptional": true,
-      "peer": true
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
+      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
+      "license": "MIT"
     },
     "node_modules/es-set-tostringtag": {
       "version": "2.0.1",
@@ -4311,7 +5357,6 @@
       "version": "0.25.1",
       "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.1.tgz",
       "integrity": "sha512-BGO5LtrGC7vxnqucAe/rmvKdJllfGaYWdyABvyMoXQlfYMb2bbRuReWR5tEGE//4LcNJj9XrkovTqNYRFZHAMQ==",
-      "dev": true,
       "hasInstallScript": true,
       "license": "MIT",
       "bin": {
@@ -4371,7 +5416,6 @@
       "version": "3.2.0",
       "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
       "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
-      "devOptional": true,
       "license": "MIT",
       "engines": {
         "node": ">=6"
@@ -4976,9 +6020,13 @@
       "license": "MIT"
     },
     "node_modules/estree-walker": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.0.tgz",
-      "integrity": "sha512-s6ceX0NFiU/vKPiKvFdR83U1Zffu7upwZsGwpoqfg5rbbq1l50WQ5hCeIvM6E6oD4shUHCYMsiFPns4Jk0YfMQ=="
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0"
+      }
     },
     "node_modules/esutils": {
       "version": "2.0.3",
@@ -5028,6 +6076,18 @@
         "url": "https://github.com/sindresorhus/execa?sponsor=1"
       }
     },
+    "node_modules/exit-hook": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/exit-hook/-/exit-hook-2.2.1.tgz",
+      "integrity": "sha512-eNTPlAD67BmP31LDINZ3U7HSF8l57TxOY2PmBJ1shpCvpnxBF93mWCE8YHBnXs8qiUZJc9WDcWIeC3a2HIAMfw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/express": {
       "version": "4.21.2",
       "resolved": "https://registry.npmjs.org/express/-/express-4.21.2.tgz",
@@ -5099,6 +6159,18 @@
       "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
       "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g=="
     },
+    "node_modules/extend-shallow": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
+      "integrity": "sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==",
+      "license": "MIT",
+      "dependencies": {
+        "is-extendable": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/extsprintf": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz",
@@ -5284,7 +6356,6 @@
       "version": "3.3.1",
       "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
       "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
-      "dev": true,
       "license": "ISC",
       "dependencies": {
         "cross-spawn": "^7.0.6",
@@ -5301,7 +6372,6 @@
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
       "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
-      "dev": true,
       "license": "ISC",
       "engines": {
         "node": ">=14"
@@ -5388,6 +6458,20 @@
       "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
       "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw=="
     },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
     "node_modules/function-bind": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
@@ -5429,6 +6513,15 @@
         "node": ">=10"
       }
     },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/gentype": {
       "version": "3.50.0",
       "resolved": "https://registry.npmjs.org/gentype/-/gentype-3.50.0.tgz",
@@ -5640,6 +6733,43 @@
       "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==",
       "peer": true
     },
+    "node_modules/gray-matter": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/gray-matter/-/gray-matter-4.0.3.tgz",
+      "integrity": "sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q==",
+      "license": "MIT",
+      "dependencies": {
+        "js-yaml": "^3.13.1",
+        "kind-of": "^6.0.2",
+        "section-matter": "^1.0.0",
+        "strip-bom-string": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=6.0"
+      }
+    },
+    "node_modules/gray-matter/node_modules/argparse": {
+      "version": "1.0.10",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
+      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+      "license": "MIT",
+      "dependencies": {
+        "sprintf-js": "~1.0.2"
+      }
+    },
+    "node_modules/gray-matter/node_modules/js-yaml": {
+      "version": "3.14.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz",
+      "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^1.0.7",
+        "esprima": "^4.0.0"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
     "node_modules/handlebars": {
       "version": "4.7.8",
       "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.7.8.tgz",
@@ -6017,6 +7147,27 @@
       "resolved": "https://registry.npmjs.org/highlightjs-rescript/-/highlightjs-rescript-0.2.2.tgz",
       "integrity": "sha512-4svMEPtDxxtoVW35DR6prREvo/4oTZfl/Ab1DSLzoZdMpjjuG8kaNkhKCd+1F083fKdlmoFNPCK8rykOxaZY1g=="
     },
+    "node_modules/hosted-git-info": {
+      "version": "6.1.3",
+      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-6.1.3.tgz",
+      "integrity": "sha512-HVJyzUrLIL1c0QmviVh5E8VGyUS7xCFPS6yydaVd1UegW+ibV/CohqTH9MkOLDp5o+rb82DMo77PTuc9F/8GKw==",
+      "license": "ISC",
+      "dependencies": {
+        "lru-cache": "^7.5.1"
+      },
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
+    "node_modules/hosted-git-info/node_modules/lru-cache": {
+      "version": "7.18.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz",
+      "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/html-encoding-sniffer": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-4.0.0.tgz",
@@ -6208,6 +7359,15 @@
       "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
     },
+    "node_modules/install": {
+      "version": "0.13.0",
+      "resolved": "https://registry.npmjs.org/install/-/install-0.13.0.tgz",
+      "integrity": "sha512-zDml/jzr2PKU9I8J/xyZBQn8rPCAY//UOYNmR01XwNwyfhEWObo2SWfSl1+0tm1u6PhxLwDnfsT/6jB7OUxqFA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
     "node_modules/internal-slot": {
       "version": "1.0.5",
       "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.5.tgz",
@@ -6372,6 +7532,15 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/is-extendable": {
+      "version": "0.1.1",
+      "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz",
+      "integrity": "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/is-extglob": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
@@ -6384,7 +7553,6 @@
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
       "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
-      "dev": true,
       "engines": {
         "node": ">=8"
       }
@@ -6494,6 +7662,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/is-reference": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-3.0.3.tgz",
+      "integrity": "sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.6"
+      }
+    },
     "node_modules/is-regex": {
       "version": "1.1.4",
       "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz",
@@ -6627,6 +7805,15 @@
       "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
       "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw=="
     },
+    "node_modules/isbot": {
+      "version": "5.1.29",
+      "resolved": "https://registry.npmjs.org/isbot/-/isbot-5.1.29.tgz",
+      "integrity": "sha512-DelDWWoa3mBoyWTq3wjp+GIWx/yZdN7zLUE7NFhKjAiJ+uJVRkbLlwykdduCE4sPUUy8mlTYTmdhBUYu91F+sw==",
+      "license": "Unlicense",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/isexe": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
@@ -6641,7 +7828,6 @@
       "version": "3.4.3",
       "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz",
       "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==",
-      "dev": true,
       "license": "BlueOak-1.0.0",
       "dependencies": {
         "@isaacs/cliui": "^8.0.2"
@@ -6688,7 +7874,7 @@
       "version": "1.21.7",
       "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
       "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==",
-      "dev": true,
+      "devOptional": true,
       "license": "MIT",
       "bin": {
         "jiti": "bin/jiti.js"
@@ -6775,14 +7961,15 @@
       }
     },
     "node_modules/jsesc": {
-      "version": "2.5.2",
-      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz",
-      "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==",
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "license": "MIT",
       "bin": {
         "jsesc": "bin/jsesc"
       },
       "engines": {
-        "node": ">=4"
+        "node": ">=6"
       }
     },
     "node_modules/json-buffer": {
@@ -6794,9 +7981,7 @@
     "node_modules/json-parse-even-better-errors": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
-      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
-      "devOptional": true,
-      "peer": true
+      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w=="
     },
     "node_modules/json-schema": {
       "version": "0.4.0",
@@ -6823,7 +8008,6 @@
       "version": "2.2.3",
       "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
       "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
-      "dev": true,
       "bin": {
         "json5": "lib/cli.js"
       },
@@ -6893,6 +8077,15 @@
         "json-buffer": "3.0.1"
       }
     },
+    "node_modules/kind-of": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz",
+      "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/language-subtag-registry": {
       "version": "0.3.22",
       "resolved": "https://registry.npmjs.org/language-subtag-registry/-/language-subtag-registry-0.3.22.tgz",
@@ -7021,7 +8214,6 @@
       "version": "10.4.3",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
       "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
-      "dev": true,
       "license": "ISC"
     },
     "node_modules/lz-string": {
@@ -7032,6 +8224,16 @@
         "lz-string": "bin/bin.js"
       }
     },
+    "node_modules/magic-string": {
+      "version": "0.30.17",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz",
+      "integrity": "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0"
+      }
+    },
     "node_modules/markdown-extensions": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/markdown-extensions/-/markdown-extensions-2.0.0.tgz",
@@ -15357,7 +16559,6 @@
       "version": "7.1.2",
       "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
       "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
-      "dev": true,
       "license": "ISC",
       "engines": {
         "node": ">=16 || 14 >=14.17"
@@ -15381,15 +16582,16 @@
       }
     },
     "node_modules/nanoid": {
-      "version": "3.3.8",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.8.tgz",
-      "integrity": "sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==",
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
       "funding": [
         {
           "type": "github",
           "url": "https://github.com/sponsors/ai"
         }
       ],
+      "license": "MIT",
       "bin": {
         "nanoid": "bin/nanoid.cjs"
       },
@@ -15491,82 +16693,2611 @@
         "react": ">=16"
       }
     },
-    "node_modules/next-mdx-remote/node_modules/@mdx-js/react": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/@mdx-js/react/-/react-3.1.0.tgz",
-      "integrity": "sha512-QjHtSaoameoalGnKDT3FoIl4+9RwyTmo9ZJGBdLOks/YOiWHoRDI3PUwEzOE7kEmGcV3AFcp9K6dYu9rEuKLAQ==",
+    "node_modules/next-mdx-remote/node_modules/@mdx-js/react": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@mdx-js/react/-/react-3.1.0.tgz",
+      "integrity": "sha512-QjHtSaoameoalGnKDT3FoIl4+9RwyTmo9ZJGBdLOks/YOiWHoRDI3PUwEzOE7kEmGcV3AFcp9K6dYu9rEuKLAQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdx": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      },
+      "peerDependencies": {
+        "@types/react": ">=16",
+        "react": ">=16"
+      }
+    },
+    "node_modules/next/node_modules/@swc/helpers": {
+      "version": "0.5.15",
+      "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.15.tgz",
+      "integrity": "sha512-JQ5TuMi45Owi4/BIMAJBoSQoOJu12oOk/gADqlcUL9JEdHB8vyjUSsxqeNXnmXHjYKMi2WcYtezGEEhqUI/E2g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.8.0"
+      }
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.18",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.18.tgz",
+      "integrity": "sha512-d9VeXT4SJ7ZeOqGX6R5EM022wpL+eWPooLI+5UpWn2jCT1aosUQEhQP214x33Wkwx3JQMvIm+tIoVOdodFS40g==",
+      "license": "MIT"
+    },
+    "node_modules/normalize-package-data": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-5.0.0.tgz",
+      "integrity": "sha512-h9iPVIfrVZ9wVYQnxFgtw1ugSvGEMOlyPWWtm8BMJhnwyEL/FLbYbTY3V3PpjI/BUK67n9PEWDu6eHzu1fB15Q==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "hosted-git-info": "^6.0.0",
+        "is-core-module": "^2.8.1",
+        "semver": "^7.3.5",
+        "validate-npm-package-license": "^3.0.4"
+      },
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/normalize-range": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz",
+      "integrity": "sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/npm": {
+      "version": "11.5.2",
+      "resolved": "https://registry.npmjs.org/npm/-/npm-11.5.2.tgz",
+      "integrity": "sha512-qsEkHPw/Qdw4eA1kKVxsa5F6QeJCiLM1GaexGt/FpUpfiBxkLXVXIVtscOAeVWVe17pmYwD9Aji8dfsXR4r68w==",
+      "bundleDependencies": [
+        "@isaacs/string-locale-compare",
+        "@npmcli/arborist",
+        "@npmcli/config",
+        "@npmcli/fs",
+        "@npmcli/map-workspaces",
+        "@npmcli/package-json",
+        "@npmcli/promise-spawn",
+        "@npmcli/redact",
+        "@npmcli/run-script",
+        "@sigstore/tuf",
+        "abbrev",
+        "archy",
+        "cacache",
+        "chalk",
+        "ci-info",
+        "cli-columns",
+        "fastest-levenshtein",
+        "fs-minipass",
+        "glob",
+        "graceful-fs",
+        "hosted-git-info",
+        "ini",
+        "init-package-json",
+        "is-cidr",
+        "json-parse-even-better-errors",
+        "libnpmaccess",
+        "libnpmdiff",
+        "libnpmexec",
+        "libnpmfund",
+        "libnpmorg",
+        "libnpmpack",
+        "libnpmpublish",
+        "libnpmsearch",
+        "libnpmteam",
+        "libnpmversion",
+        "make-fetch-happen",
+        "minimatch",
+        "minipass",
+        "minipass-pipeline",
+        "ms",
+        "node-gyp",
+        "nopt",
+        "normalize-package-data",
+        "npm-audit-report",
+        "npm-install-checks",
+        "npm-package-arg",
+        "npm-pick-manifest",
+        "npm-profile",
+        "npm-registry-fetch",
+        "npm-user-validate",
+        "p-map",
+        "pacote",
+        "parse-conflict-json",
+        "proc-log",
+        "qrcode-terminal",
+        "read",
+        "semver",
+        "spdx-expression-parse",
+        "ssri",
+        "supports-color",
+        "tar",
+        "text-table",
+        "tiny-relative-date",
+        "treeverse",
+        "validate-npm-package-name",
+        "which"
+      ],
+      "license": "Artistic-2.0",
+      "workspaces": [
+        "docs",
+        "smoke-tests",
+        "mock-globals",
+        "mock-registry",
+        "workspaces/*"
+      ],
+      "dependencies": {
+        "@isaacs/string-locale-compare": "^1.1.0",
+        "@npmcli/arborist": "^9.1.3",
+        "@npmcli/config": "^10.3.1",
+        "@npmcli/fs": "^4.0.0",
+        "@npmcli/map-workspaces": "^4.0.2",
+        "@npmcli/package-json": "^6.2.0",
+        "@npmcli/promise-spawn": "^8.0.2",
+        "@npmcli/redact": "^3.2.2",
+        "@npmcli/run-script": "^9.1.0",
+        "@sigstore/tuf": "^3.1.1",
+        "abbrev": "^3.0.1",
+        "archy": "~1.0.0",
+        "cacache": "^19.0.1",
+        "chalk": "^5.4.1",
+        "ci-info": "^4.3.0",
+        "cli-columns": "^4.0.0",
+        "fastest-levenshtein": "^1.0.16",
+        "fs-minipass": "^3.0.3",
+        "glob": "^10.4.5",
+        "graceful-fs": "^4.2.11",
+        "hosted-git-info": "^8.1.0",
+        "ini": "^5.0.0",
+        "init-package-json": "^8.2.1",
+        "is-cidr": "^5.1.1",
+        "json-parse-even-better-errors": "^4.0.0",
+        "libnpmaccess": "^10.0.1",
+        "libnpmdiff": "^8.0.6",
+        "libnpmexec": "^10.1.5",
+        "libnpmfund": "^7.0.6",
+        "libnpmorg": "^8.0.0",
+        "libnpmpack": "^9.0.6",
+        "libnpmpublish": "^11.1.0",
+        "libnpmsearch": "^9.0.0",
+        "libnpmteam": "^8.0.1",
+        "libnpmversion": "^8.0.1",
+        "make-fetch-happen": "^14.0.3",
+        "minimatch": "^9.0.5",
+        "minipass": "^7.1.1",
+        "minipass-pipeline": "^1.2.4",
+        "ms": "^2.1.2",
+        "node-gyp": "^11.2.0",
+        "nopt": "^8.1.0",
+        "normalize-package-data": "^7.0.1",
+        "npm-audit-report": "^6.0.0",
+        "npm-install-checks": "^7.1.1",
+        "npm-package-arg": "^12.0.2",
+        "npm-pick-manifest": "^10.0.0",
+        "npm-profile": "^11.0.1",
+        "npm-registry-fetch": "^18.0.2",
+        "npm-user-validate": "^3.0.0",
+        "p-map": "^7.0.3",
+        "pacote": "^21.0.0",
+        "parse-conflict-json": "^4.0.0",
+        "proc-log": "^5.0.0",
+        "qrcode-terminal": "^0.12.0",
+        "read": "^4.1.0",
+        "semver": "^7.7.2",
+        "spdx-expression-parse": "^4.0.0",
+        "ssri": "^12.0.0",
+        "supports-color": "^10.0.0",
+        "tar": "^6.2.1",
+        "text-table": "~0.2.0",
+        "tiny-relative-date": "^1.3.0",
+        "treeverse": "^3.0.0",
+        "validate-npm-package-name": "^6.0.2",
+        "which": "^5.0.0"
+      },
+      "bin": {
+        "npm": "bin/npm-cli.js",
+        "npx": "bin/npx-cli.js"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/npm-install-checks": {
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/npm-install-checks/-/npm-install-checks-6.3.0.tgz",
+      "integrity": "sha512-W29RiK/xtpCGqn6f3ixfRYGk+zRyr+Ew9F2E20BfXxT5/euLdA/Nm7fO7OeTGuAmTs30cpgInyJ0cYe708YTZw==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "semver": "^7.1.1"
+      },
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
+    "node_modules/npm-normalize-package-bin": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/npm-normalize-package-bin/-/npm-normalize-package-bin-3.0.1.tgz",
+      "integrity": "sha512-dMxCf+zZ+3zeQZXKxmyuCKlIDPGuv8EF940xbkC4kQVDTtqoh6rJFO+JTKSA6/Rwi0getWmtuy4Itup0AMcaDQ==",
+      "license": "ISC",
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
+    "node_modules/npm-package-arg": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/npm-package-arg/-/npm-package-arg-10.1.0.tgz",
+      "integrity": "sha512-uFyyCEmgBfZTtrKk/5xDfHp6+MdrqGotX/VoOyEEl3mBwiEE5FlBaePanazJSVMPT7vKepcjYBY2ztg9A3yPIA==",
+      "license": "ISC",
+      "dependencies": {
+        "hosted-git-info": "^6.0.0",
+        "proc-log": "^3.0.0",
+        "semver": "^7.3.5",
+        "validate-npm-package-name": "^5.0.0"
+      },
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
+    "node_modules/npm-pick-manifest": {
+      "version": "8.0.2",
+      "resolved": "https://registry.npmjs.org/npm-pick-manifest/-/npm-pick-manifest-8.0.2.tgz",
+      "integrity": "sha512-1dKY+86/AIiq1tkKVD3l0WI+Gd3vkknVGAggsFeBkTvbhMQ1OND/LKkYv4JtXPKUJ8bOTCyLiqEg2P6QNdK+Gg==",
+      "license": "ISC",
+      "dependencies": {
+        "npm-install-checks": "^6.0.0",
+        "npm-normalize-package-bin": "^3.0.0",
+        "npm-package-arg": "^10.0.0",
+        "semver": "^7.3.5"
+      },
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
+    "node_modules/npm-run-path": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.1.0.tgz",
+      "integrity": "sha512-sJOdmRGrY2sjNTRMbSvluQqg+8X7ZK61yvzBEIDhz4f8z1TZFYABsqjjCBd/0PUNE9M6QDgHJXQkGUEm7Q+l9Q==",
+      "dependencies": {
+        "path-key": "^4.0.0"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/npm-run-path/node_modules/path-key": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz",
+      "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/npm/node_modules/@isaacs/cliui": {
+      "version": "8.0.2",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^5.1.2",
+        "string-width-cjs": "npm:string-width@^4.2.0",
+        "strip-ansi": "^7.0.1",
+        "strip-ansi-cjs": "npm:strip-ansi@^6.0.1",
+        "wrap-ansi": "^8.1.0",
+        "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/npm/node_modules/@isaacs/cliui/node_modules/ansi-regex": {
+      "version": "6.1.0",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
+      }
+    },
+    "node_modules/npm/node_modules/@isaacs/cliui/node_modules/emoji-regex": {
+      "version": "9.2.2",
+      "inBundle": true,
+      "license": "MIT"
+    },
+    "node_modules/npm/node_modules/@isaacs/cliui/node_modules/string-width": {
+      "version": "5.1.2",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "eastasianwidth": "^0.2.0",
+        "emoji-regex": "^9.2.2",
+        "strip-ansi": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/npm/node_modules/@isaacs/cliui/node_modules/strip-ansi": {
+      "version": "7.1.0",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
+      }
+    },
+    "node_modules/npm/node_modules/@isaacs/fs-minipass": {
+      "version": "4.0.1",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^7.0.4"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/npm/node_modules/@isaacs/string-locale-compare": {
+      "version": "1.1.0",
+      "inBundle": true,
+      "license": "ISC"
+    },
+    "node_modules/npm/node_modules/@npmcli/agent": {
+      "version": "3.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "agent-base": "^7.1.0",
+        "http-proxy-agent": "^7.0.0",
+        "https-proxy-agent": "^7.0.1",
+        "lru-cache": "^10.0.1",
+        "socks-proxy-agent": "^8.0.3"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@npmcli/arborist": {
+      "version": "9.1.3",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@isaacs/string-locale-compare": "^1.1.0",
+        "@npmcli/fs": "^4.0.0",
+        "@npmcli/installed-package-contents": "^3.0.0",
+        "@npmcli/map-workspaces": "^4.0.1",
+        "@npmcli/metavuln-calculator": "^9.0.0",
+        "@npmcli/name-from-folder": "^3.0.0",
+        "@npmcli/node-gyp": "^4.0.0",
+        "@npmcli/package-json": "^6.0.1",
+        "@npmcli/query": "^4.0.0",
+        "@npmcli/redact": "^3.0.0",
+        "@npmcli/run-script": "^9.0.1",
+        "bin-links": "^5.0.0",
+        "cacache": "^19.0.1",
+        "common-ancestor-path": "^1.0.1",
+        "hosted-git-info": "^8.0.0",
+        "json-stringify-nice": "^1.1.4",
+        "lru-cache": "^10.2.2",
+        "minimatch": "^9.0.4",
+        "nopt": "^8.0.0",
+        "npm-install-checks": "^7.1.0",
+        "npm-package-arg": "^12.0.0",
+        "npm-pick-manifest": "^10.0.0",
+        "npm-registry-fetch": "^18.0.1",
+        "pacote": "^21.0.0",
+        "parse-conflict-json": "^4.0.0",
+        "proc-log": "^5.0.0",
+        "proggy": "^3.0.0",
+        "promise-all-reject-late": "^1.0.0",
+        "promise-call-limit": "^3.0.1",
+        "read-package-json-fast": "^4.0.0",
+        "semver": "^7.3.7",
+        "ssri": "^12.0.0",
+        "treeverse": "^3.0.0",
+        "walk-up-path": "^4.0.0"
+      },
+      "bin": {
+        "arborist": "bin/index.js"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/npm/node_modules/@npmcli/config": {
+      "version": "10.3.1",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/map-workspaces": "^4.0.1",
+        "@npmcli/package-json": "^6.0.1",
+        "ci-info": "^4.0.0",
+        "ini": "^5.0.0",
+        "nopt": "^8.1.0",
+        "proc-log": "^5.0.0",
+        "semver": "^7.3.5",
+        "walk-up-path": "^4.0.0"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/npm/node_modules/@npmcli/fs": {
+      "version": "4.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "semver": "^7.3.5"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@npmcli/git": {
+      "version": "6.0.3",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/promise-spawn": "^8.0.0",
+        "ini": "^5.0.0",
+        "lru-cache": "^10.0.1",
+        "npm-pick-manifest": "^10.0.0",
+        "proc-log": "^5.0.0",
+        "promise-retry": "^2.0.1",
+        "semver": "^7.3.5",
+        "which": "^5.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@npmcli/installed-package-contents": {
+      "version": "3.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "npm-bundled": "^4.0.0",
+        "npm-normalize-package-bin": "^4.0.0"
+      },
+      "bin": {
+        "installed-package-contents": "bin/index.js"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@npmcli/map-workspaces": {
+      "version": "4.0.2",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/name-from-folder": "^3.0.0",
+        "@npmcli/package-json": "^6.0.0",
+        "glob": "^10.2.2",
+        "minimatch": "^9.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@npmcli/metavuln-calculator": {
+      "version": "9.0.1",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "cacache": "^19.0.0",
+        "json-parse-even-better-errors": "^4.0.0",
+        "pacote": "^21.0.0",
+        "proc-log": "^5.0.0",
+        "semver": "^7.3.5"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/npm/node_modules/@npmcli/name-from-folder": {
+      "version": "3.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@npmcli/node-gyp": {
+      "version": "4.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@npmcli/package-json": {
+      "version": "6.2.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/git": "^6.0.0",
+        "glob": "^10.2.2",
+        "hosted-git-info": "^8.0.0",
+        "json-parse-even-better-errors": "^4.0.0",
+        "proc-log": "^5.0.0",
+        "semver": "^7.5.3",
+        "validate-npm-package-license": "^3.0.4"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@npmcli/promise-spawn": {
+      "version": "8.0.2",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "which": "^5.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@npmcli/query": {
+      "version": "4.0.1",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "postcss-selector-parser": "^7.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@npmcli/redact": {
+      "version": "3.2.2",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@npmcli/run-script": {
+      "version": "9.1.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/node-gyp": "^4.0.0",
+        "@npmcli/package-json": "^6.0.0",
+        "@npmcli/promise-spawn": "^8.0.0",
+        "node-gyp": "^11.0.0",
+        "proc-log": "^5.0.0",
+        "which": "^5.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@pkgjs/parseargs": {
+      "version": "0.11.0",
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/npm/node_modules/@sigstore/bundle": {
+      "version": "3.1.0",
+      "inBundle": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@sigstore/protobuf-specs": "^0.4.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@sigstore/core": {
+      "version": "2.0.0",
+      "inBundle": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@sigstore/protobuf-specs": {
+      "version": "0.4.3",
+      "inBundle": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@sigstore/sign": {
+      "version": "3.1.0",
+      "inBundle": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@sigstore/bundle": "^3.1.0",
+        "@sigstore/core": "^2.0.0",
+        "@sigstore/protobuf-specs": "^0.4.0",
+        "make-fetch-happen": "^14.0.2",
+        "proc-log": "^5.0.0",
+        "promise-retry": "^2.0.1"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@sigstore/tuf": {
+      "version": "3.1.1",
+      "inBundle": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@sigstore/protobuf-specs": "^0.4.1",
+        "tuf-js": "^3.0.1"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@sigstore/verify": {
+      "version": "2.1.1",
+      "inBundle": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@sigstore/bundle": "^3.1.0",
+        "@sigstore/core": "^2.0.0",
+        "@sigstore/protobuf-specs": "^0.4.1"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/@tufjs/canonical-json": {
+      "version": "2.0.0",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^16.14.0 || >=18.0.0"
+      }
+    },
+    "node_modules/npm/node_modules/@tufjs/models": {
+      "version": "3.0.1",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "@tufjs/canonical-json": "2.0.0",
+        "minimatch": "^9.0.5"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/abbrev": {
+      "version": "3.0.1",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/agent-base": {
+      "version": "7.1.4",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/npm/node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/ansi-styles": {
+      "version": "6.2.1",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/npm/node_modules/aproba": {
+      "version": "2.1.0",
+      "inBundle": true,
+      "license": "ISC"
+    },
+    "node_modules/npm/node_modules/archy": {
+      "version": "1.0.0",
+      "inBundle": true,
+      "license": "MIT"
+    },
+    "node_modules/npm/node_modules/balanced-match": {
+      "version": "1.0.2",
+      "inBundle": true,
+      "license": "MIT"
+    },
+    "node_modules/npm/node_modules/bin-links": {
+      "version": "5.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "cmd-shim": "^7.0.0",
+        "npm-normalize-package-bin": "^4.0.0",
+        "proc-log": "^5.0.0",
+        "read-cmd-shim": "^5.0.0",
+        "write-file-atomic": "^6.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/binary-extensions": {
+      "version": "3.1.0",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/npm/node_modules/brace-expansion": {
+      "version": "2.0.2",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/npm/node_modules/cacache": {
+      "version": "19.0.1",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/fs": "^4.0.0",
+        "fs-minipass": "^3.0.0",
+        "glob": "^10.2.2",
+        "lru-cache": "^10.0.1",
+        "minipass": "^7.0.3",
+        "minipass-collect": "^2.0.1",
+        "minipass-flush": "^1.0.5",
+        "minipass-pipeline": "^1.2.4",
+        "p-map": "^7.0.2",
+        "ssri": "^12.0.0",
+        "tar": "^7.4.3",
+        "unique-filename": "^4.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/cacache/node_modules/chownr": {
+      "version": "3.0.0",
+      "inBundle": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/npm/node_modules/cacache/node_modules/minizlib": {
+      "version": "3.0.2",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "minipass": "^7.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/npm/node_modules/cacache/node_modules/mkdirp": {
+      "version": "3.0.1",
+      "inBundle": true,
+      "license": "MIT",
+      "bin": {
+        "mkdirp": "dist/cjs/src/bin.js"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/npm/node_modules/cacache/node_modules/tar": {
+      "version": "7.4.3",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@isaacs/fs-minipass": "^4.0.0",
+        "chownr": "^3.0.0",
+        "minipass": "^7.1.2",
+        "minizlib": "^3.0.1",
+        "mkdirp": "^3.0.1",
+        "yallist": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/npm/node_modules/cacache/node_modules/yallist": {
+      "version": "5.0.0",
+      "inBundle": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/npm/node_modules/chalk": {
+      "version": "5.4.1",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.17.0 || ^14.13 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/npm/node_modules/chownr": {
+      "version": "2.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/npm/node_modules/ci-info": {
+      "version": "4.3.0",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/sibiraj-s"
+        }
+      ],
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/cidr-regex": {
+      "version": "4.1.3",
+      "inBundle": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "ip-regex": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/npm/node_modules/cli-columns": {
+      "version": "4.0.0",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "string-width": "^4.2.3",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/npm/node_modules/cmd-shim": {
+      "version": "7.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/color-convert": {
+      "version": "2.0.1",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/npm/node_modules/color-name": {
+      "version": "1.1.4",
+      "inBundle": true,
+      "license": "MIT"
+    },
+    "node_modules/npm/node_modules/common-ancestor-path": {
+      "version": "1.0.1",
+      "inBundle": true,
+      "license": "ISC"
+    },
+    "node_modules/npm/node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/npm/node_modules/cross-spawn/node_modules/which": {
+      "version": "2.0.2",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/npm/node_modules/cssesc": {
+      "version": "3.0.0",
+      "inBundle": true,
+      "license": "MIT",
+      "bin": {
+        "cssesc": "bin/cssesc"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/npm/node_modules/debug": {
+      "version": "4.4.1",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/npm/node_modules/diff": {
+      "version": "7.0.0",
+      "inBundle": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.3.1"
+      }
+    },
+    "node_modules/npm/node_modules/eastasianwidth": {
+      "version": "0.2.0",
+      "inBundle": true,
+      "license": "MIT"
+    },
+    "node_modules/npm/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "inBundle": true,
+      "license": "MIT"
+    },
+    "node_modules/npm/node_modules/encoding": {
+      "version": "0.1.13",
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "iconv-lite": "^0.6.2"
+      }
+    },
+    "node_modules/npm/node_modules/env-paths": {
+      "version": "2.2.1",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/npm/node_modules/err-code": {
+      "version": "2.0.3",
+      "inBundle": true,
+      "license": "MIT"
+    },
+    "node_modules/npm/node_modules/exponential-backoff": {
+      "version": "3.1.2",
+      "inBundle": true,
+      "license": "Apache-2.0"
+    },
+    "node_modules/npm/node_modules/fastest-levenshtein": {
+      "version": "1.0.16",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4.9.1"
+      }
+    },
+    "node_modules/npm/node_modules/foreground-child": {
+      "version": "3.3.1",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "cross-spawn": "^7.0.6",
+        "signal-exit": "^4.0.1"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/npm/node_modules/fs-minipass": {
+      "version": "3.0.3",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^7.0.3"
+      },
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
+    "node_modules/npm/node_modules/glob": {
+      "version": "10.4.5",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "foreground-child": "^3.1.0",
+        "jackspeak": "^3.1.2",
+        "minimatch": "^9.0.4",
+        "minipass": "^7.1.2",
+        "package-json-from-dist": "^1.0.0",
+        "path-scurry": "^1.11.1"
+      },
+      "bin": {
+        "glob": "dist/esm/bin.mjs"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/npm/node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "inBundle": true,
+      "license": "ISC"
+    },
+    "node_modules/npm/node_modules/hosted-git-info": {
+      "version": "8.1.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "lru-cache": "^10.0.1"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/http-cache-semantics": {
+      "version": "4.2.0",
+      "inBundle": true,
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/npm/node_modules/http-proxy-agent": {
+      "version": "7.0.2",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.0",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/npm/node_modules/https-proxy-agent": {
+      "version": "7.0.6",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/npm/node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/npm/node_modules/ignore-walk": {
+      "version": "7.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "minimatch": "^9.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/imurmurhash": {
+      "version": "0.1.4",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.19"
+      }
+    },
+    "node_modules/npm/node_modules/ini": {
+      "version": "5.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/init-package-json": {
+      "version": "8.2.1",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/package-json": "^6.1.0",
+        "npm-package-arg": "^12.0.0",
+        "promzard": "^2.0.0",
+        "read": "^4.0.0",
+        "semver": "^7.3.5",
+        "validate-npm-package-license": "^3.0.4",
+        "validate-npm-package-name": "^6.0.0"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/npm/node_modules/ip-address": {
+      "version": "9.0.5",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "jsbn": "1.1.0",
+        "sprintf-js": "^1.1.3"
+      },
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/npm/node_modules/ip-regex": {
+      "version": "5.0.0",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/npm/node_modules/is-cidr": {
+      "version": "5.1.1",
+      "inBundle": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "cidr-regex": "^4.1.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/npm/node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/isexe": {
+      "version": "2.0.0",
+      "inBundle": true,
+      "license": "ISC"
+    },
+    "node_modules/npm/node_modules/jackspeak": {
+      "version": "3.4.3",
+      "inBundle": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "@isaacs/cliui": "^8.0.2"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      },
+      "optionalDependencies": {
+        "@pkgjs/parseargs": "^0.11.0"
+      }
+    },
+    "node_modules/npm/node_modules/jsbn": {
+      "version": "1.1.0",
+      "inBundle": true,
+      "license": "MIT"
+    },
+    "node_modules/npm/node_modules/json-parse-even-better-errors": {
+      "version": "4.0.0",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/json-stringify-nice": {
+      "version": "1.1.4",
+      "inBundle": true,
+      "license": "ISC",
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/npm/node_modules/jsonparse": {
+      "version": "1.3.1",
+      "engines": [
+        "node >= 0.2.0"
+      ],
+      "inBundle": true,
+      "license": "MIT"
+    },
+    "node_modules/npm/node_modules/just-diff": {
+      "version": "6.0.2",
+      "inBundle": true,
+      "license": "MIT"
+    },
+    "node_modules/npm/node_modules/just-diff-apply": {
+      "version": "5.5.0",
+      "inBundle": true,
+      "license": "MIT"
+    },
+    "node_modules/npm/node_modules/libnpmaccess": {
+      "version": "10.0.1",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "npm-package-arg": "^12.0.0",
+        "npm-registry-fetch": "^18.0.1"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/npm/node_modules/libnpmdiff": {
+      "version": "8.0.6",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/arborist": "^9.1.3",
+        "@npmcli/installed-package-contents": "^3.0.0",
+        "binary-extensions": "^3.0.0",
+        "diff": "^7.0.0",
+        "minimatch": "^9.0.4",
+        "npm-package-arg": "^12.0.0",
+        "pacote": "^21.0.0",
+        "tar": "^6.2.1"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/npm/node_modules/libnpmexec": {
+      "version": "10.1.5",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/arborist": "^9.1.3",
+        "@npmcli/package-json": "^6.1.1",
+        "@npmcli/run-script": "^9.0.1",
+        "ci-info": "^4.0.0",
+        "npm-package-arg": "^12.0.0",
+        "pacote": "^21.0.0",
+        "proc-log": "^5.0.0",
+        "read": "^4.0.0",
+        "read-package-json-fast": "^4.0.0",
+        "semver": "^7.3.7",
+        "walk-up-path": "^4.0.0"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/npm/node_modules/libnpmfund": {
+      "version": "7.0.6",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/arborist": "^9.1.3"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/npm/node_modules/libnpmorg": {
+      "version": "8.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "aproba": "^2.0.0",
+        "npm-registry-fetch": "^18.0.1"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/npm/node_modules/libnpmpack": {
+      "version": "9.0.6",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/arborist": "^9.1.3",
+        "@npmcli/run-script": "^9.0.1",
+        "npm-package-arg": "^12.0.0",
+        "pacote": "^21.0.0"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/npm/node_modules/libnpmpublish": {
+      "version": "11.1.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/package-json": "^6.2.0",
+        "ci-info": "^4.0.0",
+        "npm-package-arg": "^12.0.0",
+        "npm-registry-fetch": "^18.0.1",
+        "proc-log": "^5.0.0",
+        "semver": "^7.3.7",
+        "sigstore": "^3.0.0",
+        "ssri": "^12.0.0"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/npm/node_modules/libnpmsearch": {
+      "version": "9.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "npm-registry-fetch": "^18.0.1"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/npm/node_modules/libnpmteam": {
+      "version": "8.0.1",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "aproba": "^2.0.0",
+        "npm-registry-fetch": "^18.0.1"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/npm/node_modules/libnpmversion": {
+      "version": "8.0.1",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/git": "^6.0.1",
+        "@npmcli/run-script": "^9.0.1",
+        "json-parse-even-better-errors": "^4.0.0",
+        "proc-log": "^5.0.0",
+        "semver": "^7.3.7"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/npm/node_modules/lru-cache": {
+      "version": "10.4.3",
+      "inBundle": true,
+      "license": "ISC"
+    },
+    "node_modules/npm/node_modules/make-fetch-happen": {
+      "version": "14.0.3",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/agent": "^3.0.0",
+        "cacache": "^19.0.1",
+        "http-cache-semantics": "^4.1.1",
+        "minipass": "^7.0.2",
+        "minipass-fetch": "^4.0.0",
+        "minipass-flush": "^1.0.5",
+        "minipass-pipeline": "^1.2.4",
+        "negotiator": "^1.0.0",
+        "proc-log": "^5.0.0",
+        "promise-retry": "^2.0.1",
+        "ssri": "^12.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/make-fetch-happen/node_modules/negotiator": {
+      "version": "1.0.0",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/npm/node_modules/minimatch": {
+      "version": "9.0.5",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/npm/node_modules/minipass": {
+      "version": "7.1.2",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/npm/node_modules/minipass-collect": {
+      "version": "2.0.1",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^7.0.3"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/npm/node_modules/minipass-fetch": {
+      "version": "4.0.1",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "minipass": "^7.0.3",
+        "minipass-sized": "^1.0.3",
+        "minizlib": "^3.0.1"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      },
+      "optionalDependencies": {
+        "encoding": "^0.1.13"
+      }
+    },
+    "node_modules/npm/node_modules/minipass-fetch/node_modules/minizlib": {
+      "version": "3.0.2",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "minipass": "^7.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/npm/node_modules/minipass-flush": {
+      "version": "1.0.5",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/npm/node_modules/minipass-flush/node_modules/minipass": {
+      "version": "3.3.6",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/minipass-pipeline": {
+      "version": "1.2.4",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/minipass-pipeline/node_modules/minipass": {
+      "version": "3.3.6",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/minipass-sized": {
+      "version": "1.0.3",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/minipass-sized/node_modules/minipass": {
+      "version": "3.3.6",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/minizlib": {
+      "version": "2.1.2",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "minipass": "^3.0.0",
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/npm/node_modules/minizlib/node_modules/minipass": {
+      "version": "3.3.6",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/mkdirp": {
+      "version": "1.0.4",
+      "inBundle": true,
+      "license": "MIT",
+      "bin": {
+        "mkdirp": "bin/cmd.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/npm/node_modules/ms": {
+      "version": "2.1.3",
+      "inBundle": true,
+      "license": "MIT"
+    },
+    "node_modules/npm/node_modules/mute-stream": {
+      "version": "2.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/node-gyp": {
+      "version": "11.2.0",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "env-paths": "^2.2.0",
+        "exponential-backoff": "^3.1.1",
+        "graceful-fs": "^4.2.6",
+        "make-fetch-happen": "^14.0.3",
+        "nopt": "^8.0.0",
+        "proc-log": "^5.0.0",
+        "semver": "^7.3.5",
+        "tar": "^7.4.3",
+        "tinyglobby": "^0.2.12",
+        "which": "^5.0.0"
+      },
+      "bin": {
+        "node-gyp": "bin/node-gyp.js"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/node-gyp/node_modules/chownr": {
+      "version": "3.0.0",
+      "inBundle": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/npm/node_modules/node-gyp/node_modules/minizlib": {
+      "version": "3.0.2",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "minipass": "^7.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/npm/node_modules/node-gyp/node_modules/mkdirp": {
+      "version": "3.0.1",
+      "inBundle": true,
+      "license": "MIT",
+      "bin": {
+        "mkdirp": "dist/cjs/src/bin.js"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/npm/node_modules/node-gyp/node_modules/tar": {
+      "version": "7.4.3",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@isaacs/fs-minipass": "^4.0.0",
+        "chownr": "^3.0.0",
+        "minipass": "^7.1.2",
+        "minizlib": "^3.0.1",
+        "mkdirp": "^3.0.1",
+        "yallist": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/npm/node_modules/node-gyp/node_modules/yallist": {
+      "version": "5.0.0",
+      "inBundle": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/npm/node_modules/nopt": {
+      "version": "8.1.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "abbrev": "^3.0.0"
+      },
+      "bin": {
+        "nopt": "bin/nopt.js"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/normalize-package-data": {
+      "version": "7.0.1",
+      "inBundle": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "hosted-git-info": "^8.0.0",
+        "semver": "^7.3.5",
+        "validate-npm-package-license": "^3.0.4"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/npm-audit-report": {
+      "version": "6.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/npm-bundled": {
+      "version": "4.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "npm-normalize-package-bin": "^4.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/npm-install-checks": {
+      "version": "7.1.1",
+      "inBundle": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "semver": "^7.1.1"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/npm-normalize-package-bin": {
+      "version": "4.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/npm-package-arg": {
+      "version": "12.0.2",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "hosted-git-info": "^8.0.0",
+        "proc-log": "^5.0.0",
+        "semver": "^7.3.5",
+        "validate-npm-package-name": "^6.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/npm-packlist": {
+      "version": "10.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "ignore-walk": "^7.0.0"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/npm/node_modules/npm-pick-manifest": {
+      "version": "10.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "npm-install-checks": "^7.1.0",
+        "npm-normalize-package-bin": "^4.0.0",
+        "npm-package-arg": "^12.0.0",
+        "semver": "^7.3.5"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/npm-profile": {
+      "version": "11.0.1",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "npm-registry-fetch": "^18.0.0",
+        "proc-log": "^5.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/npm-registry-fetch": {
+      "version": "18.0.2",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/redact": "^3.0.0",
+        "jsonparse": "^1.3.1",
+        "make-fetch-happen": "^14.0.0",
+        "minipass": "^7.0.2",
+        "minipass-fetch": "^4.0.0",
+        "minizlib": "^3.0.1",
+        "npm-package-arg": "^12.0.0",
+        "proc-log": "^5.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/npm-registry-fetch/node_modules/minizlib": {
+      "version": "3.0.2",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "minipass": "^7.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/npm/node_modules/npm-user-validate": {
+      "version": "3.0.0",
+      "inBundle": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/p-map": {
+      "version": "7.0.3",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/npm/node_modules/package-json-from-dist": {
+      "version": "1.0.1",
+      "inBundle": true,
+      "license": "BlueOak-1.0.0"
+    },
+    "node_modules/npm/node_modules/pacote": {
+      "version": "21.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "@npmcli/git": "^6.0.0",
+        "@npmcli/installed-package-contents": "^3.0.0",
+        "@npmcli/package-json": "^6.0.0",
+        "@npmcli/promise-spawn": "^8.0.0",
+        "@npmcli/run-script": "^9.0.0",
+        "cacache": "^19.0.0",
+        "fs-minipass": "^3.0.0",
+        "minipass": "^7.0.2",
+        "npm-package-arg": "^12.0.0",
+        "npm-packlist": "^10.0.0",
+        "npm-pick-manifest": "^10.0.0",
+        "npm-registry-fetch": "^18.0.0",
+        "proc-log": "^5.0.0",
+        "promise-retry": "^2.0.1",
+        "sigstore": "^3.0.0",
+        "ssri": "^12.0.0",
+        "tar": "^6.1.11"
+      },
+      "bin": {
+        "pacote": "bin/index.js"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/npm/node_modules/parse-conflict-json": {
+      "version": "4.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "json-parse-even-better-errors": "^4.0.0",
+        "just-diff": "^6.0.0",
+        "just-diff-apply": "^5.2.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/path-key": {
+      "version": "3.1.1",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/path-scurry": {
+      "version": "1.11.1",
+      "inBundle": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "lru-cache": "^10.2.0",
+        "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/npm/node_modules/postcss-selector-parser": {
+      "version": "7.1.0",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/npm/node_modules/proc-log": {
+      "version": "5.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/proggy": {
+      "version": "3.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/promise-all-reject-late": {
+      "version": "1.0.1",
+      "inBundle": true,
+      "license": "ISC",
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/npm/node_modules/promise-call-limit": {
+      "version": "3.0.2",
+      "inBundle": true,
+      "license": "ISC",
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/npm/node_modules/promise-retry": {
+      "version": "2.0.1",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "err-code": "^2.0.2",
+        "retry": "^0.12.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/npm/node_modules/promzard": {
+      "version": "2.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "read": "^4.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/qrcode-terminal": {
+      "version": "0.12.0",
+      "inBundle": true,
+      "bin": {
+        "qrcode-terminal": "bin/qrcode-terminal.js"
+      }
+    },
+    "node_modules/npm/node_modules/read": {
+      "version": "4.1.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "mute-stream": "^2.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/read-cmd-shim": {
+      "version": "5.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/read-package-json-fast": {
+      "version": "4.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "json-parse-even-better-errors": "^4.0.0",
+        "npm-normalize-package-bin": "^4.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/retry": {
+      "version": "0.12.0",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/npm/node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/npm/node_modules/semver": {
+      "version": "7.7.2",
+      "inBundle": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/npm/node_modules/shebang-command": {
+      "version": "2.0.0",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/signal-exit": {
+      "version": "4.1.0",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/npm/node_modules/sigstore": {
+      "version": "3.1.0",
+      "inBundle": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@sigstore/bundle": "^3.1.0",
+        "@sigstore/core": "^2.0.0",
+        "@sigstore/protobuf-specs": "^0.4.0",
+        "@sigstore/sign": "^3.1.0",
+        "@sigstore/tuf": "^3.1.0",
+        "@sigstore/verify": "^2.1.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/smart-buffer": {
+      "version": "4.2.0",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6.0.0",
+        "npm": ">= 3.0.0"
+      }
+    },
+    "node_modules/npm/node_modules/socks": {
+      "version": "2.8.6",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "ip-address": "^9.0.5",
+        "smart-buffer": "^4.2.0"
+      },
+      "engines": {
+        "node": ">= 10.0.0",
+        "npm": ">= 3.0.0"
+      }
+    },
+    "node_modules/npm/node_modules/socks-proxy-agent": {
+      "version": "8.0.5",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "^4.3.4",
+        "socks": "^2.8.3"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/npm/node_modules/spdx-correct": {
+      "version": "3.2.0",
+      "inBundle": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "spdx-expression-parse": "^3.0.0",
+        "spdx-license-ids": "^3.0.0"
+      }
+    },
+    "node_modules/npm/node_modules/spdx-correct/node_modules/spdx-expression-parse": {
+      "version": "3.0.1",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "spdx-exceptions": "^2.1.0",
+        "spdx-license-ids": "^3.0.0"
+      }
+    },
+    "node_modules/npm/node_modules/spdx-exceptions": {
+      "version": "2.5.0",
+      "inBundle": true,
+      "license": "CC-BY-3.0"
+    },
+    "node_modules/npm/node_modules/spdx-expression-parse": {
+      "version": "4.0.0",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "spdx-exceptions": "^2.1.0",
+        "spdx-license-ids": "^3.0.0"
+      }
+    },
+    "node_modules/npm/node_modules/spdx-license-ids": {
+      "version": "3.0.21",
+      "inBundle": true,
+      "license": "CC0-1.0"
+    },
+    "node_modules/npm/node_modules/sprintf-js": {
+      "version": "1.1.3",
+      "inBundle": true,
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/npm/node_modules/ssri": {
+      "version": "12.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^7.0.3"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/string-width": {
+      "version": "4.2.3",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/string-width-cjs": {
+      "name": "string-width",
+      "version": "4.2.3",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/strip-ansi-cjs": {
+      "name": "strip-ansi",
+      "version": "6.0.1",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/supports-color": {
+      "version": "10.0.0",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/supports-color?sponsor=1"
+      }
+    },
+    "node_modules/npm/node_modules/tar": {
+      "version": "6.2.1",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "chownr": "^2.0.0",
+        "fs-minipass": "^2.0.0",
+        "minipass": "^5.0.0",
+        "minizlib": "^2.1.1",
+        "mkdirp": "^1.0.3",
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/npm/node_modules/tar/node_modules/fs-minipass": {
+      "version": "2.1.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/npm/node_modules/tar/node_modules/fs-minipass/node_modules/minipass": {
+      "version": "3.3.6",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/tar/node_modules/minipass": {
+      "version": "5.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/npm/node_modules/text-table": {
+      "version": "0.2.0",
+      "inBundle": true,
+      "license": "MIT"
+    },
+    "node_modules/npm/node_modules/tiny-relative-date": {
+      "version": "1.3.0",
+      "inBundle": true,
+      "license": "MIT"
+    },
+    "node_modules/npm/node_modules/tinyglobby": {
+      "version": "0.2.14",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.4.4",
+        "picomatch": "^4.0.2"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/npm/node_modules/tinyglobby/node_modules/fdir": {
+      "version": "6.4.6",
+      "inBundle": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/npm/node_modules/tinyglobby/node_modules/picomatch": {
+      "version": "4.0.3",
+      "inBundle": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/npm/node_modules/treeverse": {
+      "version": "3.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
+    "node_modules/npm/node_modules/tuf-js": {
+      "version": "3.1.0",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "@tufjs/models": "3.0.1",
+        "debug": "^4.4.1",
+        "make-fetch-happen": "^14.0.3"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/unique-filename": {
+      "version": "4.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "unique-slug": "^5.0.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/unique-slug": {
+      "version": "5.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "imurmurhash": "^0.1.4"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "inBundle": true,
+      "license": "MIT"
+    },
+    "node_modules/npm/node_modules/validate-npm-package-license": {
+      "version": "3.0.4",
+      "inBundle": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "spdx-correct": "^3.0.0",
+        "spdx-expression-parse": "^3.0.0"
+      }
+    },
+    "node_modules/npm/node_modules/validate-npm-package-license/node_modules/spdx-expression-parse": {
+      "version": "3.0.1",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "spdx-exceptions": "^2.1.0",
+        "spdx-license-ids": "^3.0.0"
+      }
+    },
+    "node_modules/npm/node_modules/validate-npm-package-name": {
+      "version": "6.0.2",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/walk-up-path": {
+      "version": "4.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/npm/node_modules/which": {
+      "version": "5.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^3.1.1"
+      },
+      "bin": {
+        "node-which": "bin/which.js"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/which/node_modules/isexe": {
+      "version": "3.1.1",
+      "inBundle": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/npm/node_modules/wrap-ansi": {
+      "version": "8.1.0",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^6.1.0",
+        "string-width": "^5.0.1",
+        "strip-ansi": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/npm/node_modules/wrap-ansi-cjs": {
+      "name": "wrap-ansi",
+      "version": "7.0.0",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/npm/node_modules/wrap-ansi-cjs/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "inBundle": true,
       "license": "MIT",
       "dependencies": {
-        "@types/mdx": "^2.0.0"
+        "color-convert": "^2.0.1"
       },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "engines": {
+        "node": ">=8"
       },
-      "peerDependencies": {
-        "@types/react": ">=16",
-        "react": ">=16"
-      }
-    },
-    "node_modules/next/node_modules/@swc/helpers": {
-      "version": "0.5.15",
-      "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.15.tgz",
-      "integrity": "sha512-JQ5TuMi45Owi4/BIMAJBoSQoOJu12oOk/gADqlcUL9JEdHB8vyjUSsxqeNXnmXHjYKMi2WcYtezGEEhqUI/E2g==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "tslib": "^2.8.0"
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
       }
     },
-    "node_modules/node-releases": {
-      "version": "2.0.18",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.18.tgz",
-      "integrity": "sha512-d9VeXT4SJ7ZeOqGX6R5EM022wpL+eWPooLI+5UpWn2jCT1aosUQEhQP214x33Wkwx3JQMvIm+tIoVOdodFS40g==",
-      "devOptional": true,
-      "license": "MIT"
-    },
-    "node_modules/normalize-path": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
-      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
-      "dev": true,
+    "node_modules/npm/node_modules/wrap-ansi/node_modules/ansi-regex": {
+      "version": "6.1.0",
+      "inBundle": true,
+      "license": "MIT",
       "engines": {
-        "node": ">=0.10.0"
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
       }
     },
-    "node_modules/normalize-range": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz",
-      "integrity": "sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==",
-      "dev": true,
-      "engines": {
-        "node": ">=0.10.0"
-      }
+    "node_modules/npm/node_modules/wrap-ansi/node_modules/emoji-regex": {
+      "version": "9.2.2",
+      "inBundle": true,
+      "license": "MIT"
     },
-    "node_modules/npm-run-path": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.1.0.tgz",
-      "integrity": "sha512-sJOdmRGrY2sjNTRMbSvluQqg+8X7ZK61yvzBEIDhz4f8z1TZFYABsqjjCBd/0PUNE9M6QDgHJXQkGUEm7Q+l9Q==",
+    "node_modules/npm/node_modules/wrap-ansi/node_modules/string-width": {
+      "version": "5.1.2",
+      "inBundle": true,
+      "license": "MIT",
       "dependencies": {
-        "path-key": "^4.0.0"
+        "eastasianwidth": "^0.2.0",
+        "emoji-regex": "^9.2.2",
+        "strip-ansi": "^7.0.1"
       },
       "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+        "node": ">=12"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/npm-run-path/node_modules/path-key": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz",
-      "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==",
+    "node_modules/npm/node_modules/wrap-ansi/node_modules/strip-ansi": {
+      "version": "7.1.0",
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^6.0.1"
+      },
       "engines": {
         "node": ">=12"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
       }
     },
+    "node_modules/npm/node_modules/write-file-atomic": {
+      "version": "6.0.0",
+      "inBundle": true,
+      "license": "ISC",
+      "dependencies": {
+        "imurmurhash": "^0.1.4",
+        "signal-exit": "^4.0.1"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/npm/node_modules/yallist": {
+      "version": "4.0.0",
+      "inBundle": true,
+      "license": "ISC"
+    },
     "node_modules/nth-check": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz",
@@ -15817,7 +19548,6 @@
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
       "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
-      "dev": true,
       "license": "BlueOak-1.0.0"
     },
     "node_modules/parent-module": {
@@ -15919,7 +19649,6 @@
       "version": "1.11.1",
       "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz",
       "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==",
-      "dev": true,
       "license": "BlueOak-1.0.0",
       "dependencies": {
         "lru-cache": "^10.2.0",
@@ -15945,11 +19674,29 @@
         "node": ">=8"
       }
     },
+    "node_modules/pathe": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.2.tgz",
+      "integrity": "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==",
+      "license": "MIT"
+    },
     "node_modules/performance-now": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz",
       "integrity": "sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow=="
     },
+    "node_modules/periscopic": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/periscopic/-/periscopic-4.0.2.tgz",
+      "integrity": "sha512-sqpQDUy8vgB7ycLkendSKS6HnVz1Rneoc3Rc+ZBUCe2pbqlVuCC5vF52l0NJ1aiMg/r1qfYF9/myz8CZeI2rjA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "*",
+        "is-reference": "^3.0.2",
+        "zimmerframe": "^1.0.0"
+      }
+    },
     "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -16205,6 +19952,16 @@
         }
       }
     },
+    "node_modules/postcss-load-config/node_modules/yaml": {
+      "version": "1.10.2",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-1.10.2.tgz",
+      "integrity": "sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">= 6"
+      }
+    },
     "node_modules/postcss-merge-longhand": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-6.0.0.tgz",
@@ -16636,6 +20393,34 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/proc-log": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/proc-log/-/proc-log-3.0.0.tgz",
+      "integrity": "sha512-++Vn7NS4Xf9NacaU9Xq3URUuqZETPsf8L4j5/ckhaRYsfPeRyzGw+iDjFhV/Jr3uNmTvvddEJFWh5R1gRgUH8A==",
+      "license": "ISC",
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
+    "node_modules/promise-inflight": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/promise-inflight/-/promise-inflight-1.0.1.tgz",
+      "integrity": "sha512-6zWPyEOFaQBJYcGMHBKTKJ3u6TBsnMFOIZSa6ce1e/ZrrsOlnHRHbabMjLiBYKp+n44X9eUI6VUPaukCXHuG4g==",
+      "license": "ISC"
+    },
+    "node_modules/promise-retry": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/promise-retry/-/promise-retry-2.0.1.tgz",
+      "integrity": "sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==",
+      "license": "MIT",
+      "dependencies": {
+        "err-code": "^2.0.2",
+        "retry": "^0.12.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/prop-types": {
       "version": "15.8.1",
       "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
@@ -16861,6 +20646,173 @@
         "url": "https://opencollective.com/unified"
       }
     },
+    "node_modules/react-refresh": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",
+      "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-router": {
+      "version": "7.7.1",
+      "resolved": "https://registry.npmjs.org/react-router/-/react-router-7.7.1.tgz",
+      "integrity": "sha512-jVKHXoWRIsD/qS6lvGveckwb862EekvapdHJN/cGmzw40KnJH5gg53ujOJ4qX6EKIK9LSBfFed/xiQ5yeXNrUA==",
+      "license": "MIT",
+      "dependencies": {
+        "cookie": "^1.0.1",
+        "set-cookie-parser": "^2.6.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=18",
+        "react-dom": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/react-router-mdx": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/react-router-mdx/-/react-router-mdx-1.0.6.tgz",
+      "integrity": "sha512-VZJ8cuE4uKbeuWEI32x5utRyMXDfZn0/rpzK6TNlMLcP2KKhGc6xMdbtlIKyAQHzCytPL5/GH6HqopxtEjE4Sw==",
+      "license": "ISC",
+      "dependencies": {
+        "@mdx-js/mdx": "^3.1.0",
+        "@mdx-js/react": "^3.1.0",
+        "glob": "^11.0.2",
+        "gray-matter": "^4.0.3",
+        "remark-frontmatter": "^5.0.0",
+        "slash": "^5.1.0"
+      },
+      "peerDependencies": {
+        "@react-router/dev": "^7.6.2",
+        "react": "^19.1.0",
+        "react-router": "^7.0.0"
+      }
+    },
+    "node_modules/react-router-mdx/node_modules/@mdx-js/react": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@mdx-js/react/-/react-3.1.0.tgz",
+      "integrity": "sha512-QjHtSaoameoalGnKDT3FoIl4+9RwyTmo9ZJGBdLOks/YOiWHoRDI3PUwEzOE7kEmGcV3AFcp9K6dYu9rEuKLAQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdx": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      },
+      "peerDependencies": {
+        "@types/react": ">=16",
+        "react": ">=16"
+      }
+    },
+    "node_modules/react-router-mdx/node_modules/glob": {
+      "version": "11.0.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-11.0.3.tgz",
+      "integrity": "sha512-2Nim7dha1KVkaiF4q6Dj+ngPPMdfvLJEOpZk/jKiUAkqKebpGAWQXAq9z1xu9HKu5lWfqw/FASuccEjyznjPaA==",
+      "license": "ISC",
+      "dependencies": {
+        "foreground-child": "^3.3.1",
+        "jackspeak": "^4.1.1",
+        "minimatch": "^10.0.3",
+        "minipass": "^7.1.2",
+        "package-json-from-dist": "^1.0.0",
+        "path-scurry": "^2.0.0"
+      },
+      "bin": {
+        "glob": "dist/esm/bin.mjs"
+      },
+      "engines": {
+        "node": "20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/react-router-mdx/node_modules/jackspeak": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-4.1.1.tgz",
+      "integrity": "sha512-zptv57P3GpL+O0I7VdMJNBZCu+BPHVQUk55Ft8/QCJjTVxrnJHuVuX/0Bl2A6/+2oyR/ZMEuFKwmzqqZ/U5nPQ==",
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "@isaacs/cliui": "^8.0.2"
+      },
+      "engines": {
+        "node": "20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/react-router-mdx/node_modules/lru-cache": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.1.0.tgz",
+      "integrity": "sha512-QIXZUBJUx+2zHUdQujWejBkcD9+cs94tLn0+YL8UrCh+D5sCXZ4c7LaEH48pNwRY3MLDgqUFyhlCyjJPf1WP0A==",
+      "license": "ISC",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/react-router-mdx/node_modules/minimatch": {
+      "version": "10.0.3",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.0.3.tgz",
+      "integrity": "sha512-IPZ167aShDZZUMdRk66cyQAW3qr0WzbHkPdMYa8bzZhlHhO3jALbKdxcaak7W9FfT2rZNpQuUu4Od7ILEpXSaw==",
+      "license": "ISC",
+      "dependencies": {
+        "@isaacs/brace-expansion": "^5.0.0"
+      },
+      "engines": {
+        "node": "20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/react-router-mdx/node_modules/path-scurry": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.0.tgz",
+      "integrity": "sha512-ypGJsmGtdXUOeM5u93TyeIEfEhM6s+ljAhrk5vAvSx8uyY/02OvrZnA0YNGUrPXfpJMgI1ODd3nwz8Npx4O4cg==",
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "lru-cache": "^11.0.0",
+        "minipass": "^7.1.2"
+      },
+      "engines": {
+        "node": "20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/react-router-mdx/node_modules/slash": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/slash/-/slash-5.1.0.tgz",
+      "integrity": "sha512-ZA6oR3T/pEyuqwMgAKT0/hAv8oAXckzbkmR0UkUosQ+Mc4RxGoJkRmwHgHufaenlyAgE1Mxgpdcrf75y6XcnDg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/react-router/node_modules/cookie": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-1.0.2.tgz",
+      "integrity": "sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/read-cache": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz",
@@ -17212,14 +21164,6 @@
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/remark-mdx-frontmatter/node_modules/yaml": {
-      "version": "2.3.2",
-      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.3.2.tgz",
-      "integrity": "sha512-N/lyzTPaJasoDmfV7YTrYCI0G/3ivm/9wdG0aHuheKowWQwGTsK0Eoiw6utmzAnI6pkJa0DUVygvp3spqqEKXg==",
-      "engines": {
-        "node": ">= 14"
-      }
-    },
     "node_modules/remark-parse": {
       "version": "11.0.0",
       "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-11.0.0.tgz",
@@ -18137,6 +22081,15 @@
         "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
       }
     },
+    "node_modules/retry": {
+      "version": "0.12.0",
+      "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz",
+      "integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
     "node_modules/reusify": {
       "version": "1.0.4",
       "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz",
@@ -18161,6 +22114,45 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
+    "node_modules/rollup": {
+      "version": "4.46.2",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.46.2.tgz",
+      "integrity": "sha512-WMmLFI+Boh6xbop+OAGo9cQ3OgX9MIg7xOQjn+pTCwOkk+FNDAeAemXkJ3HzDJrVXleLOFVa1ipuc1AmEx1Dwg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.46.2",
+        "@rollup/rollup-android-arm64": "4.46.2",
+        "@rollup/rollup-darwin-arm64": "4.46.2",
+        "@rollup/rollup-darwin-x64": "4.46.2",
+        "@rollup/rollup-freebsd-arm64": "4.46.2",
+        "@rollup/rollup-freebsd-x64": "4.46.2",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.46.2",
+        "@rollup/rollup-linux-arm-musleabihf": "4.46.2",
+        "@rollup/rollup-linux-arm64-gnu": "4.46.2",
+        "@rollup/rollup-linux-arm64-musl": "4.46.2",
+        "@rollup/rollup-linux-loongarch64-gnu": "4.46.2",
+        "@rollup/rollup-linux-ppc64-gnu": "4.46.2",
+        "@rollup/rollup-linux-riscv64-gnu": "4.46.2",
+        "@rollup/rollup-linux-riscv64-musl": "4.46.2",
+        "@rollup/rollup-linux-s390x-gnu": "4.46.2",
+        "@rollup/rollup-linux-x64-gnu": "4.46.2",
+        "@rollup/rollup-linux-x64-musl": "4.46.2",
+        "@rollup/rollup-win32-arm64-msvc": "4.46.2",
+        "@rollup/rollup-win32-ia32-msvc": "4.46.2",
+        "@rollup/rollup-win32-x64-msvc": "4.46.2",
+        "fsevents": "~2.3.2"
+      }
+    },
     "node_modules/rrweb-cssom": {
       "version": "0.8.0",
       "resolved": "https://registry.npmjs.org/rrweb-cssom/-/rrweb-cssom-0.8.0.tgz",
@@ -18385,6 +22377,19 @@
       "license": "MIT",
       "peer": true
     },
+    "node_modules/section-matter": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/section-matter/-/section-matter-1.0.0.tgz",
+      "integrity": "sha512-vfD3pmTzGpufjScBh50YHKzEu2lxBWhVEHsNGoEXmCmn2hKGfeNLYMzCJpe8cD7gqX7TJluOVpBkAequ6dgMmA==",
+      "license": "MIT",
+      "dependencies": {
+        "extend-shallow": "^2.0.1",
+        "kind-of": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/semver": {
       "version": "7.7.2",
       "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
@@ -18537,6 +22542,12 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/set-cookie-parser": {
+      "version": "2.7.1",
+      "resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-2.7.1.tgz",
+      "integrity": "sha512-IOc8uWeOZgnb3ptbCURJWNjWUPcO3ZnTTdzsurqERrP6nPyv+paC55vJM0LpOlT2ne+Ix+9+CRG1MNLlyZ4GjQ==",
+      "license": "MIT"
+    },
     "node_modules/set-function-length": {
       "version": "1.2.2",
       "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
@@ -18721,6 +22732,44 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/spdx-correct": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.2.0.tgz",
+      "integrity": "sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "spdx-expression-parse": "^3.0.0",
+        "spdx-license-ids": "^3.0.0"
+      }
+    },
+    "node_modules/spdx-exceptions": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz",
+      "integrity": "sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==",
+      "license": "CC-BY-3.0"
+    },
+    "node_modules/spdx-expression-parse": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz",
+      "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==",
+      "license": "MIT",
+      "dependencies": {
+        "spdx-exceptions": "^2.1.0",
+        "spdx-license-ids": "^3.0.0"
+      }
+    },
+    "node_modules/spdx-license-ids": {
+      "version": "3.0.21",
+      "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.21.tgz",
+      "integrity": "sha512-Bvg/8F5XephndSK3JffaRqdT+gyhfqIPwDHpX80tJrF8QQRYMo8sNMeaZ2Dp5+jhwKnUmIOyFFQfHRkjJm5nXg==",
+      "license": "CC0-1.0"
+    },
+    "node_modules/sprintf-js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
+      "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==",
+      "license": "BSD-3-Clause"
+    },
     "node_modules/sshpk": {
       "version": "1.17.0",
       "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.17.0.tgz",
@@ -18765,7 +22814,6 @@
       "version": "4.2.3",
       "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
       "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "dev": true,
       "dependencies": {
         "emoji-regex": "^8.0.0",
         "is-fullwidth-code-point": "^3.0.0",
@@ -18780,7 +22828,6 @@
       "version": "4.2.3",
       "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
       "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "emoji-regex": "^8.0.0",
@@ -18795,14 +22842,12 @@
       "version": "8.0.0",
       "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
       "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/string-width/node_modules/emoji-regex": {
       "version": "8.0.0",
       "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "dev": true
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="
     },
     "node_modules/string.prototype.matchall": {
       "version": "4.0.8",
@@ -18906,7 +22951,6 @@
       "version": "6.0.1",
       "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
       "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "ansi-regex": "^5.0.1"
@@ -18923,6 +22967,15 @@
         "node": ">=4"
       }
     },
+    "node_modules/strip-bom-string": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/strip-bom-string/-/strip-bom-string-1.0.0.tgz",
+      "integrity": "sha512-uCC2VHvQRYu+lMh4My/sFNmF2klFymLX1wHJeXnbEJERpV/ZsVuonzerjfrGpIGF7LBVa1O7i9kjiWvJiFck8g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/strip-final-newline": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-3.0.0.tgz",
@@ -19288,19 +23341,6 @@
         }
       }
     },
-    "node_modules/tailwindcss/node_modules/yaml": {
-      "version": "2.7.1",
-      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.7.1.tgz",
-      "integrity": "sha512-10ULxpnOCQXxJvBgxsn9ptjq6uviG/htZKk9veJGhlqn3w/DxQ631zFF+nlQXLwmImeS5amR2dl2U8sg6U9jsQ==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "yaml": "bin.mjs"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
     "node_modules/tapable": {
       "version": "2.2.1",
       "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz",
@@ -19366,8 +23406,7 @@
     "node_modules/text-table": {
       "version": "0.2.0",
       "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
-      "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==",
-      "peer": true
+      "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw=="
     },
     "node_modules/thenby": {
       "version": "1.3.4",
@@ -19398,6 +23437,48 @@
         "node": ">=0.8"
       }
     },
+    "node_modules/tinyglobby": {
+      "version": "0.2.14",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.14.tgz",
+      "integrity": "sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==",
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.4.4",
+        "picomatch": "^4.0.2"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tinyglobby/node_modules/fdir": {
+      "version": "6.4.6",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.6.tgz",
+      "integrity": "sha512-hiFoqpyZcfNm1yc4u8oWCf9A2c4D3QjCrks3zmoVKVxpQRzmPNar1hUJcBG2RQHvEVGDN+Jm81ZheVLAQMK6+w==",
+      "license": "MIT",
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/tinyglobby/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
     "node_modules/titleize": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/titleize/-/titleize-3.0.0.tgz",
@@ -19429,14 +23510,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/to-fast-properties": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz",
-      "integrity": "sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==",
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/to-regex-range": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
@@ -19577,6 +23650,13 @@
         "node": "*"
       }
     },
+    "node_modules/turbo-stream": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/turbo-stream/-/turbo-stream-3.1.0.tgz",
+      "integrity": "sha512-tVI25WEXl4fckNEmrq70xU1XumxUwEx/FZD5AgEcV8ri7Wvrg2o7GEq8U7htrNx3CajciGm+kDyhRf5JB6t7/A==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/tweetnacl": {
       "version": "0.14.5",
       "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz",
@@ -19719,10 +23799,11 @@
       }
     },
     "node_modules/undici-types": {
-      "version": "5.26.5",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
-      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
+      "version": "7.10.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.10.0.tgz",
+      "integrity": "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag==",
       "devOptional": true,
+      "license": "MIT",
       "peer": true
     },
     "node_modules/unified": {
@@ -19933,7 +24014,6 @@
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.1.tgz",
       "integrity": "sha512-R8UzCaa9Az+38REPiJ1tXlImTJXlVfgHZsglwBD/k6nj76ctsH1E3q4doGrukiLQd3sGQYu56r5+lo5r94l29A==",
-      "devOptional": true,
       "funding": [
         {
           "type": "opencollective",
@@ -20005,6 +24085,39 @@
         "uuid": "bin/uuid"
       }
     },
+    "node_modules/valibot": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/valibot/-/valibot-0.41.0.tgz",
+      "integrity": "sha512-igDBb8CTYr8YTQlOKgaN9nSS0Be7z+WRuaeYqGf3Cjz3aKmSnqEmYnkfVjzIuumGqfHpa3fLIvMEAfhrpqN8ng==",
+      "license": "MIT",
+      "peerDependencies": {
+        "typescript": ">=5"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/validate-npm-package-license": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz",
+      "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "spdx-correct": "^3.0.0",
+        "spdx-expression-parse": "^3.0.0"
+      }
+    },
+    "node_modules/validate-npm-package-name": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/validate-npm-package-name/-/validate-npm-package-name-5.0.1.tgz",
+      "integrity": "sha512-OljLrQ9SQdOUqTaQxqL5dEfZWrXExyyWsozYlAWFawPVNuD83igl7uJD2RTkNMbniIYgt8l81eCJGIdQF7avLQ==",
+      "license": "ISC",
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
     "node_modules/vary": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
@@ -20054,18 +24167,6 @@
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/vfile-matter/node_modules/yaml": {
-      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.7.0.tgz",
-      "integrity": "sha512-+hSoy/QHluxmC9kCIJyL/uyFmLmc+e5CFR5Wa+bpIhIj85LVb9ZH2nVnqrHoSvKogwODv0ClqZkmiSSaIH5LTA==",
-      "license": "ISC",
-      "bin": {
-        "yaml": "bin.mjs"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
     "node_modules/vfile-message": {
       "version": "4.0.2",
       "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.2.tgz",
@@ -20092,6 +24193,199 @@
       "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==",
       "license": "MIT"
     },
+    "node_modules/vite": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-7.0.6.tgz",
+      "integrity": "sha512-MHFiOENNBd+Bd9uvc8GEsIzdkn1JxMmEeYX35tI3fv0sJBUTfW5tQsoaOwuY4KhBI09A3dUJ/DXf2yxPVPUceg==",
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.25.0",
+        "fdir": "^6.4.6",
+        "picomatch": "^4.0.3",
+        "postcss": "^8.5.6",
+        "rollup": "^4.40.0",
+        "tinyglobby": "^0.2.14"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "lightningcss": "^1.21.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite-node": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-3.2.4.tgz",
+      "integrity": "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==",
+      "license": "MIT",
+      "dependencies": {
+        "cac": "^6.7.14",
+        "debug": "^4.4.1",
+        "es-module-lexer": "^1.7.0",
+        "pathe": "^2.0.3",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0"
+      },
+      "bin": {
+        "vite-node": "vite-node.mjs"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/vite-node/node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite-node/node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "license": "MIT"
+    },
+    "node_modules/vite/node_modules/fdir": {
+      "version": "6.4.6",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.6.tgz",
+      "integrity": "sha512-hiFoqpyZcfNm1yc4u8oWCf9A2c4D3QjCrks3zmoVKVxpQRzmPNar1hUJcBG2RQHvEVGDN+Jm81ZheVLAQMK6+w==",
+      "license": "MIT",
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/vite/node_modules/postcss": {
+      "version": "8.5.6",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
+      "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/vitefu": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/vitefu/-/vitefu-1.1.1.tgz",
+      "integrity": "sha512-B/Fegf3i8zh0yFbpzZ21amWzHmuNlLlmJT6n7bu5e+pCHUKQIfXSYokrqOBGEMMe9UG2sostKQF9mml/vYaWJQ==",
+      "dev": true,
+      "license": "MIT",
+      "workspaces": [
+        "tests/deps/*",
+        "tests/projects/*",
+        "tests/projects/workspace/packages/*"
+      ],
+      "peerDependencies": {
+        "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0-beta.0"
+      },
+      "peerDependenciesMeta": {
+        "vite": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/w3c-xmlserializer": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz",
@@ -20362,7 +24656,6 @@
       "version": "7.0.0",
       "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
       "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "ansi-styles": "^4.0.0",
@@ -20429,13 +24722,22 @@
         "node": ">=10"
       }
     },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "license": "ISC"
+    },
     "node_modules/yaml": {
-      "version": "1.10.2",
-      "resolved": "https://registry.npmjs.org/yaml/-/yaml-1.10.2.tgz",
-      "integrity": "sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==",
-      "dev": true,
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.0.tgz",
+      "integrity": "sha512-4lLa/EcQCB0cJkyts+FpIRx5G/llPxfP6VQU5KByHEhLxY3IJCH0f0Hy1MHI8sClTvsIb8qwRJ6R/ZdlDJ/leQ==",
+      "license": "ISC",
+      "bin": {
+        "yaml": "bin.mjs"
+      },
       "engines": {
-        "node": ">= 6"
+        "node": ">= 14.6"
       }
     },
     "node_modules/yargs": {
@@ -20477,6 +24779,13 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/zimmerframe": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/zimmerframe/-/zimmerframe-1.1.2.tgz",
+      "integrity": "sha512-rAbqEGa8ovJy4pyBxZM70hg4pE6gDgaQ0Sl9M3enG3I0d6H4XSAM3GeNGLKnsBpuijUow064sf7ww1nutC5/3w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/zwitch": {
       "version": "2.0.4",
       "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz",
diff --git a/package.json b/package.json
index 58869e8ac..643cdc615 100644
--- a/package.json
+++ b/package.json
@@ -23,6 +23,7 @@
     "@docsearch/react": "^3.9.0",
     "@headlessui/react": "^2.2.4",
     "@mdx-js/loader": "^3.1.0",
+    "@react-router/node": "^7.7.1",
     "@rescript/react": "^0.14.0-rc.1",
     "@rescript/webapi": "^0.1.0-experimental-03eae8b",
     "codemirror": "^5.54.0",
@@ -34,6 +35,7 @@
     "glob": "^7.1.4",
     "highlight.js": "^11.9.0",
     "highlightjs-rescript": "^0.2.2",
+    "isbot": "^5",
     "lz-string": "^1.4.4",
     "next": "^15.0.0",
     "next-mdx-remote": "^5.0.0",
@@ -41,6 +43,8 @@
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "react-markdown": "^10.1.0",
+    "react-router": "^7.7.1",
+    "react-router-mdx": "^1.0.6",
     "rehype-slug": "^6.0.0",
     "rehype-stringify": "^10.0.1",
     "remark-comment": "^1.0.0",
@@ -57,9 +61,9 @@
     "vfile-matter": "^5.0.0"
   },
   "scripts": {
-    "dev": "next",
+    "dev": "vite",
     "res:watch": "rescript build -w",
-    "build": "rescript && npm run update-index && next build",
+    "build": "rescript && vite build",
     "test": "node scripts/test-examples.mjs && node scripts/test-hrefs.mjs",
     "reanalyze": "reanalyze -all-cmt .",
     "update-index": "npm run generate-llms && node scripts/extract-indices.mjs && node scripts/extract-tocs.mjs && node scripts/extract-syntax.mjs && node scripts/generate_feed.mjs > public/blog/feed.xml",
@@ -69,6 +73,10 @@
   },
   "devDependencies": {
     "@mdx-js/react": "^2.3.0",
+    "@mdx-js/rollup": "^3.1.0",
+    "@react-router/dev": "^7.7.1",
+    "@vitejs/plugin-react": "^4.7.0",
+    "@vitejs/plugin-rsc": "^0.4.16",
     "autoprefixer": "^10.4.14",
     "cssnano": "^6.0.1",
     "dotenv": "^16.4.7",
@@ -79,6 +87,7 @@
     "postcss-nesting": "^12.1.1",
     "reanalyze": "^2.16.0",
     "simple-functional-loader": "^1.2.1",
-    "tailwindcss": "^3.3.3"
+    "tailwindcss": "^3.3.3",
+    "vite": "^7.0.6"
   }
-}
+}
\ No newline at end of file
diff --git a/pages/docs/manual/v12.0.0/api.mdx b/pages/docs/manual/api.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/api.mdx
rename to pages/docs/manual/api.mdx
diff --git a/pages/docs/manual/v12.0.0/api/[...slug].js b/pages/docs/manual/api/[...slug].js
similarity index 100%
rename from pages/docs/manual/v12.0.0/api/[...slug].js
rename to pages/docs/manual/api/[...slug].js
diff --git a/pages/docs/manual/v12.0.0/array-and-list.mdx b/pages/docs/manual/array-and-list.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/array-and-list.mdx
rename to pages/docs/manual/array-and-list.mdx
diff --git a/pages/docs/manual/v12.0.0/async-await.mdx b/pages/docs/manual/async-await.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/async-await.mdx
rename to pages/docs/manual/async-await.mdx
diff --git a/pages/docs/manual/v12.0.0/attribute.mdx b/pages/docs/manual/attribute.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/attribute.mdx
rename to pages/docs/manual/attribute.mdx
diff --git a/pages/docs/manual/v12.0.0/bind-to-global-js-values.mdx b/pages/docs/manual/bind-to-global-js-values.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/bind-to-global-js-values.mdx
rename to pages/docs/manual/bind-to-global-js-values.mdx
diff --git a/pages/docs/manual/v12.0.0/bind-to-js-function.mdx b/pages/docs/manual/bind-to-js-function.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/bind-to-js-function.mdx
rename to pages/docs/manual/bind-to-js-function.mdx
diff --git a/pages/docs/manual/v12.0.0/bind-to-js-object.mdx b/pages/docs/manual/bind-to-js-object.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/bind-to-js-object.mdx
rename to pages/docs/manual/bind-to-js-object.mdx
diff --git a/pages/docs/manual/v12.0.0/browser-support-polyfills.mdx b/pages/docs/manual/browser-support-polyfills.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/browser-support-polyfills.mdx
rename to pages/docs/manual/browser-support-polyfills.mdx
diff --git a/pages/docs/manual/v12.0.0/build-configuration-schema.mdx b/pages/docs/manual/build-configuration-schema.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/build-configuration-schema.mdx
rename to pages/docs/manual/build-configuration-schema.mdx
diff --git a/pages/docs/manual/v12.0.0/build-configuration.mdx b/pages/docs/manual/build-configuration.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/build-configuration.mdx
rename to pages/docs/manual/build-configuration.mdx
diff --git a/pages/docs/manual/v12.0.0/build-external-stdlib.mdx b/pages/docs/manual/build-external-stdlib.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/build-external-stdlib.mdx
rename to pages/docs/manual/build-external-stdlib.mdx
diff --git a/pages/docs/manual/v12.0.0/build-overview.mdx b/pages/docs/manual/build-overview.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/build-overview.mdx
rename to pages/docs/manual/build-overview.mdx
diff --git a/pages/docs/manual/v12.0.0/build-performance.mdx b/pages/docs/manual/build-performance.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/build-performance.mdx
rename to pages/docs/manual/build-performance.mdx
diff --git a/pages/docs/manual/v12.0.0/build-pinned-dependencies.mdx b/pages/docs/manual/build-pinned-dependencies.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/build-pinned-dependencies.mdx
rename to pages/docs/manual/build-pinned-dependencies.mdx
diff --git a/pages/docs/manual/v12.0.0/control-flow.mdx b/pages/docs/manual/control-flow.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/control-flow.mdx
rename to pages/docs/manual/control-flow.mdx
diff --git a/pages/docs/manual/v12.0.0/converting-from-js.mdx b/pages/docs/manual/converting-from-js.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/converting-from-js.mdx
rename to pages/docs/manual/converting-from-js.mdx
diff --git a/pages/docs/manual/v12.0.0/dict.mdx b/pages/docs/manual/dict.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/dict.mdx
rename to pages/docs/manual/dict.mdx
diff --git a/pages/docs/manual/v12.0.0/editor-code-analysis.mdx b/pages/docs/manual/editor-code-analysis.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/editor-code-analysis.mdx
rename to pages/docs/manual/editor-code-analysis.mdx
diff --git a/pages/docs/manual/v12.0.0/editor-plugins.mdx b/pages/docs/manual/editor-plugins.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/editor-plugins.mdx
rename to pages/docs/manual/editor-plugins.mdx
diff --git a/pages/docs/manual/v12.0.0/embed-raw-javascript.mdx b/pages/docs/manual/embed-raw-javascript.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/embed-raw-javascript.mdx
rename to pages/docs/manual/embed-raw-javascript.mdx
diff --git a/pages/docs/manual/v12.0.0/equality-comparison.mdx b/pages/docs/manual/equality-comparison.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/equality-comparison.mdx
rename to pages/docs/manual/equality-comparison.mdx
diff --git a/pages/docs/manual/v12.0.0/exception.mdx b/pages/docs/manual/exception.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/exception.mdx
rename to pages/docs/manual/exception.mdx
diff --git a/pages/docs/manual/v12.0.0/extensible-variant.mdx b/pages/docs/manual/extensible-variant.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/extensible-variant.mdx
rename to pages/docs/manual/extensible-variant.mdx
diff --git a/pages/docs/manual/v12.0.0/external.mdx b/pages/docs/manual/external.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/external.mdx
rename to pages/docs/manual/external.mdx
diff --git a/pages/docs/manual/v12.0.0/function.mdx b/pages/docs/manual/function.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/function.mdx
rename to pages/docs/manual/function.mdx
diff --git a/pages/docs/manual/v12.0.0/generate-converters-accessors.mdx b/pages/docs/manual/generate-converters-accessors.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/generate-converters-accessors.mdx
rename to pages/docs/manual/generate-converters-accessors.mdx
diff --git a/pages/docs/manual/v12.0.0/import-export.mdx b/pages/docs/manual/import-export.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/import-export.mdx
rename to pages/docs/manual/import-export.mdx
diff --git a/pages/docs/manual/v12.0.0/import-from-export-to-js.mdx b/pages/docs/manual/import-from-export-to-js.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/import-from-export-to-js.mdx
rename to pages/docs/manual/import-from-export-to-js.mdx
diff --git a/pages/docs/manual/v12.0.0/inlining-constants.mdx b/pages/docs/manual/inlining-constants.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/inlining-constants.mdx
rename to pages/docs/manual/inlining-constants.mdx
diff --git a/pages/docs/manual/v12.0.0/installation.mdx b/pages/docs/manual/installation.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/installation.mdx
rename to pages/docs/manual/installation.mdx
diff --git a/pages/docs/manual/v12.0.0/interop-cheatsheet.mdx b/pages/docs/manual/interop-cheatsheet.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/interop-cheatsheet.mdx
rename to pages/docs/manual/interop-cheatsheet.mdx
diff --git a/pages/docs/manual/v12.0.0/interop-with-js-build-systems.mdx b/pages/docs/manual/interop-with-js-build-systems.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/interop-with-js-build-systems.mdx
rename to pages/docs/manual/interop-with-js-build-systems.mdx
diff --git a/pages/docs/manual/v12.0.0/introduction.mdx b/pages/docs/manual/introduction.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/introduction.mdx
rename to pages/docs/manual/introduction.mdx
diff --git a/pages/docs/manual/v12.0.0/json.mdx b/pages/docs/manual/json.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/json.mdx
rename to pages/docs/manual/json.mdx
diff --git a/pages/docs/manual/v12.0.0/jsx.mdx b/pages/docs/manual/jsx.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/jsx.mdx
rename to pages/docs/manual/jsx.mdx
diff --git a/pages/docs/manual/v12.0.0/lazy-values.mdx b/pages/docs/manual/lazy-values.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/lazy-values.mdx
rename to pages/docs/manual/lazy-values.mdx
diff --git a/pages/docs/manual/v12.0.0/let-binding.mdx b/pages/docs/manual/let-binding.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/let-binding.mdx
rename to pages/docs/manual/let-binding.mdx
diff --git a/pages/docs/manual/v12.0.0/libraries.mdx b/pages/docs/manual/libraries.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/libraries.mdx
rename to pages/docs/manual/libraries.mdx
diff --git a/pages/docs/manual/v12.0.0/migrate-to-v11.mdx b/pages/docs/manual/migrate-to-v11.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/migrate-to-v11.mdx
rename to pages/docs/manual/migrate-to-v11.mdx
diff --git a/pages/docs/manual/v12.0.0/module.mdx b/pages/docs/manual/module.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/module.mdx
rename to pages/docs/manual/module.mdx
diff --git a/pages/docs/manual/v12.0.0/mutation.mdx b/pages/docs/manual/mutation.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/mutation.mdx
rename to pages/docs/manual/mutation.mdx
diff --git a/pages/docs/manual/v12.0.0/null-undefined-option.mdx b/pages/docs/manual/null-undefined-option.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/null-undefined-option.mdx
rename to pages/docs/manual/null-undefined-option.mdx
diff --git a/pages/docs/manual/v12.0.0/object.mdx b/pages/docs/manual/object.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/object.mdx
rename to pages/docs/manual/object.mdx
diff --git a/pages/docs/manual/v12.0.0/overview.mdx b/pages/docs/manual/overview.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/overview.mdx
rename to pages/docs/manual/overview.mdx
diff --git a/pages/docs/manual/v12.0.0/pattern-matching-destructuring.mdx b/pages/docs/manual/pattern-matching-destructuring.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/pattern-matching-destructuring.mdx
rename to pages/docs/manual/pattern-matching-destructuring.mdx
diff --git a/pages/docs/manual/v12.0.0/pipe.mdx b/pages/docs/manual/pipe.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/pipe.mdx
rename to pages/docs/manual/pipe.mdx
diff --git a/pages/docs/manual/v12.0.0/polymorphic-variant.mdx b/pages/docs/manual/polymorphic-variant.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/polymorphic-variant.mdx
rename to pages/docs/manual/polymorphic-variant.mdx
diff --git a/pages/docs/manual/v12.0.0/primitive-types.mdx b/pages/docs/manual/primitive-types.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/primitive-types.mdx
rename to pages/docs/manual/primitive-types.mdx
diff --git a/pages/docs/manual/v12.0.0/project-structure.mdx b/pages/docs/manual/project-structure.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/project-structure.mdx
rename to pages/docs/manual/project-structure.mdx
diff --git a/pages/docs/manual/v12.0.0/promise.mdx b/pages/docs/manual/promise.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/promise.mdx
rename to pages/docs/manual/promise.mdx
diff --git a/pages/docs/manual/v12.0.0/record.mdx b/pages/docs/manual/record.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/record.mdx
rename to pages/docs/manual/record.mdx
diff --git a/pages/docs/manual/v12.0.0/reserved-keywords.mdx b/pages/docs/manual/reserved-keywords.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/reserved-keywords.mdx
rename to pages/docs/manual/reserved-keywords.mdx
diff --git a/pages/docs/manual/v12.0.0/scoped-polymorphic-types.mdx b/pages/docs/manual/scoped-polymorphic-types.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/scoped-polymorphic-types.mdx
rename to pages/docs/manual/scoped-polymorphic-types.mdx
diff --git a/pages/docs/manual/v12.0.0/shared-data-types.mdx b/pages/docs/manual/shared-data-types.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/shared-data-types.mdx
rename to pages/docs/manual/shared-data-types.mdx
diff --git a/pages/docs/manual/v12.0.0/tagged-templates.mdx b/pages/docs/manual/tagged-templates.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/tagged-templates.mdx
rename to pages/docs/manual/tagged-templates.mdx
diff --git a/pages/docs/manual/v12.0.0/try.mdx b/pages/docs/manual/try.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/try.mdx
rename to pages/docs/manual/try.mdx
diff --git a/pages/docs/manual/v12.0.0/tuple.mdx b/pages/docs/manual/tuple.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/tuple.mdx
rename to pages/docs/manual/tuple.mdx
diff --git a/pages/docs/manual/v12.0.0/type.mdx b/pages/docs/manual/type.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/type.mdx
rename to pages/docs/manual/type.mdx
diff --git a/pages/docs/manual/v12.0.0/typescript-integration.mdx b/pages/docs/manual/typescript-integration.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/typescript-integration.mdx
rename to pages/docs/manual/typescript-integration.mdx
diff --git a/pages/docs/manual/v12.0.0/use-illegal-identifier-names.mdx b/pages/docs/manual/use-illegal-identifier-names.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/use-illegal-identifier-names.mdx
rename to pages/docs/manual/use-illegal-identifier-names.mdx
diff --git a/pages/docs/manual/v10.0.0/api.mdx b/pages/docs/manual/v10.0.0/api.mdx
deleted file mode 100644
index ce832115e..000000000
--- a/pages/docs/manual/v10.0.0/api.mdx
+++ /dev/null
@@ -1,15 +0,0 @@
-# Introduction
-
-ReScript ships 3 modules in its standard library.
-
-- [Js](api/js): bindings for all your familiar JavaScript APIs.
-- [Belt](api/belt): extra collections and helpers not available in JavaScript.
-- [Dom](api/dom): Dom related types and modules.
-
-Usage heuristics:
-
-- Default to using the `Js` module. Most of the APIs in it are runtime-free and compile down to clean, readable JavaScript, which is our priority.
-- For other APIs that aren't available in regular JavaScript (and thus don't exist in our `Js` bindings), use Belt. For example, prefer `Js.Array2` over `Belt.Array`.
-- The `Dom` module contains our standardized types used by various userland DOM bindings. Due to the complexity of DOM, we don't mind that you ignore this module and build your application-specific DOM bindings.
-
-**Note**: we do not recommend other userland standard library alternatives (unless it's DOM bindings). These cause confusion and split points for the community.
diff --git a/pages/docs/manual/v10.0.0/api/belt.mdx b/pages/docs/manual/v10.0.0/api/belt.mdx
deleted file mode 100644
index 1c5b8039a..000000000
--- a/pages/docs/manual/v10.0.0/api/belt.mdx
+++ /dev/null
@@ -1,179 +0,0 @@
-# Belt
-
-The ReScript standard library.
-
-Belt is currently mostly covering collection types. It has no string or date functions yet, although Belt.String is in the works. In the meantime, use [Js.String](js/string) for string functions and [Js.Date](js/date) for date functions.
-
-## Motivation
-
-Belt provides:
-
-- The **highest quality** immutable data structures in JavaScript.
-- Safety by default: A Belt function will never throw exceptions, unless it is
-  indicated explicitly in the function name (suffix "Exn").
-- Better performance and smaller code size running on the JS platform.
-- Ready for [Tree Shaking](https://webpack.js.org/guides/tree-shaking/).
-
-## Usage
-
-To use modules from Belt, either refer to them by their fully qualified name (`Belt.List`, `Belt.Array` etc.) or open the `Belt` module by putting
-
-```res
-open Belt
-```
-
-at the top of your source files. After opening Belt this way, `Array` will refer to `Belt.Array`, `List` will refer to `Belt.List` etc. in the subsequent code.
-
-If you want to open Belt globally for all files in your project instead, you can put
-
-```json
-  "bsc-flags": ["-open Belt"],
-```
-
-into your `bsconfig.json`.
-
-**Note**: this is the **only** `open` we encourage.
-
-Example usage:
-
-```res
-let someNumbers = [1, 1, 4, 2, 3, 6, 3, 4, 2]
-
-let greaterThan2UniqueAndSorted =
-  someNumbers
-  ->Belt.Array.keep(x => x > 2)
-  // convert to and from set to make values unique
-  ->Belt.Set.Int.fromArray
-  ->Belt.Set.Int.toArray // output is already sorted
-
-Js.log2("result", greaterThan2UniqueAndSorted)
-```
-
-## Curried vs. Uncurried Callbacks
-
-For functions taking a callback parameter, there are usually two versions
-available:
-
-- curried (no suffix)
-- uncurried (suffixed with `U`)
-
-E.g.:
-
-```res
-let forEach: (t<'a>, 'a => unit) => unit
-
-let forEachU: (t<'a>, (. 'a) => unit) => unit
-```
-
-The uncurried version will be faster in some cases, but for simplicity we recommend to stick with the curried version unless you need the extra performance.
-
-The two versions can be invoked as follows:
-
-```
-["a", "b", "c"]->Belt.Array.forEach(x => Js.log(x))
-
-["a", "b", "c"]->Belt.Array.forEachU((. x) => Js.log(x))
-```
-
-## Specialized Collections
-
-For collections types like set or map, Belt provides both a generic module as well as specialized, more efficient implementations for string and int keys.
-
-For example, Belt has the following set modules:
-
-- [Belt.Set](belt/set)
-- [Belt.Set.Int](belt/set-int)
-- [Belt.Set.String](belt/set-string)
-
-## Implementation Details
-
-### Array access runtime safety
-
-One common confusion comes from the way Belt handles array access. It differs from than the default standard library's.
-
-```res
-let letters = ["a", "b", "c"]
-let a = letters[0] // a == "a"
-let capitalA = Js.String.toUpperCase(a)
-let k = letters[10] // Raises an exception! The 10th index doesn't exist.
-```
-
-Because Belt avoids exceptions and returns `options` instead, this code behaves differently:
-
-```res
-open Belt
-let letters = ["a", "b", "c"]
-let a = letters[0] // a == Some("a")
-let captialA = Js.String.toUpperCase(a) // Type error! This code will not compile.
-let k = letters[10] // k == None
-```
-
-Although we've fixed the problem where `k` raises an exception, we now have a type error when trying to capitalize `a`. There are a few things going on here:
-
-- Reason transforms array index access to the function `Array.get`. So `letters[0]` is the same as `Array.get(letters, 0)`.
-- The compiler uses whichever `Array` module is in scope. If you `open Belt`, then it uses `Belt.Array`.
-- `Belt.Array.get` returns values wrapped in options, so `letters[0] == Some("a")`.
-
-Fortunately, this is easy to fix:
-
-```res example
-open Belt
-let letters = ["a", "b", "c"]
-let a = letters[0]
-
-// Use a switch statement:
-let capitalA =
-  switch a {
-  | Some(a) => Some(Js.String.toUpperCase(a))
-  | None => None
-  }
-
-let k = letters[10] // k == None
-```
-
-With that little bit of tweaking, our code now compiles successfully and is 100% free of runtime errors!
-
-### A Special Encoding for Collection Safety
-
-When we create a collection library for a custom data type we need a way to provide a comparator function. Take Set for example, suppose its element type is a pair of ints, it needs a custom compare function that takes two tuples and returns their order. The Set could not just be typed as Set.t (int \* int) , its customized compare function needs to manifest itself in the signature, otherwise, if the user creates another customized compare function, the two collection could mix which would result in runtime error.
-
-We use a phantom type to solve the problem:
-
-```res
-module Comparable1 =
-  Belt.Id.MakeComparable(
-    {
-      type t = (int, int)
-      let cmp = ((a0, a1), (b0, b1)) =>
-        switch Pervasives.compare(a0, b0) {
-        | 0 => Pervasives.compare(a1, b1)
-        | c => c
-        }
-    }
-  )
-
-let mySet1 = Belt.Set.make(~id=module(Comparable1))
-
-module Comparable2 =
-  Belt.Id.MakeComparable(
-    {
-      type t = (int, int)
-      let cmp = ((a0, a1), (b0, b1)) =>
-        switch Pervasives.compare(a0, b0) {
-        | 0 => Pervasives.compare(a1, b1)
-        | c => c
-        }
-    }
-  )
-
-let mySet2 = Belt.Set.make(~id=module(Comparable2))
-```
-
-Here, the compiler would infer `mySet1` and `mySet2` having different type, so e.g. a `merge` operation that tries to merge these two sets will correctly fail.
-
-```res
-let mySet1: t<(int, int), Comparable1.identity>
-let mySet2: t<(int, int), Comparable2.identity>
-```
-
-`Comparable1.identity` and `Comparable2.identity` are not the same using our encoding scheme.
diff --git a/pages/docs/manual/v10.0.0/api/belt/array.mdx b/pages/docs/manual/v10.0.0/api/belt/array.mdx
deleted file mode 100644
index a54d244fe..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/array.mdx
+++ /dev/null
@@ -1,940 +0,0 @@
-# Array
-
-<Intro>
-
-Utililites for `Array` functions.
-
-</Intro>
-
-### Note about index syntax
-
-Code like `arr[0]` does *not* compile to JavaScript `arr[0]`. ReScript transforms the `[]` index syntax into a function: `Array.get(arr, 0)`. By default, this uses the default standard library's `Array.get` function, which may raise an exception if the index isn't found. If you `open Belt`, it will use the `Belt.Array.get` function which returns options instead of raising exceptions. [See this for more information](../belt.mdx#array-access-runtime-safety).
-
-## length
-
-```res sig
-let length: array<'a> => int
-```
-
-return the size of the array
-
-```res example
-// Returns 1
-Belt.Array.length(["test"])
-```
-
-## size
-
-```res sig
-let size: array<'a> => int
-```
-
-See Belt_Array.length
-
-## get
-
-```res sig
-let get: (array<'a>, int) => option<'a>
-```
-
-If `i <= 0 <= length(arr)` returns `Some(value)` where `value` is the item at index `i`.
-If `i` is out of range returns `None`
-
-## getExn
-
-```res sig
-let getExn: (array<'a>, int) => 'a
-```
-
-Raise an exception if `i` is out of range.
-Otherwise return the value at index `i` in `arr`.
-
-## getUnsafe
-
-```res sig
-let getUnsafe: (array<'a>, int) => 'a
-```
-
-Unsafe
-
-no bounds checking; this would cause type error if `i` does not stay within range
-
-## getUndefined
-
-```res sig
-let getUndefined: (array<'a>, int) => Js.undefined<'a>
-```
-
-It does the samething in the runtime as `Belt_Array.getUnsafe` it is type safe since the return type still track whether it is in range or not
-
-## set
-
-```res sig
-let set: (array<'a>, int, 'a) => bool
-```
-
-`set(arr, n, x)` modifies `arr` in place; it replaces the nth element of `arr` with `x`.
-
-Returns false means not updated due to out of range.
-
-## setExn
-
-```res sig
-let setExn: (array<'a>, int, 'a) => unit
-```
-
-`setExn(arr, i, x)` raise an exception if `i` is out of range.
-
-## setUnsafe
-
-```res sig
-let setUnsafe: (array<'a>, int, 'a) => unit
-```
-
-## shuffleInPlace
-
-```res sig
-let shuffleInPlace: array<'a> => unit
-```
-
-`shuffleInPlace(arr)` randomly re-orders the items in `arr`
-
-## shuffle
-
-```res sig
-let shuffle: array<'a> => array<'a>
-```
-
-Returns a fresh array with items in original array randomly shuffled.
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: array<'a> => unit
-```
-
-`reverseInPlace(arr)` reverses items in `arr` in place.
-
-```res example
-let arr = [10, 11, 12, 13, 14]
-
-let () = Belt.Array.reverseInPlace(arr)
-
-arr == [14, 13, 12, 11, 10]
-```
-
-## reverse
-
-```res sig
-let reverse: array<'a> => array<'a>
-```
-
-`reverse(arr)` returns a fresh array with items in arr in reverse order.
-
-```res example
-Belt.Array.reverse([10, 11, 12, 13, 14]) == [14, 13, 12, 11, 10]
-```
-
-## makeUninitialized
-
-```res sig
-let makeUninitialized: int => array<Js.undefined<'a>>
-```
-
-`makeUninitialized(n)` creates an array of length `n` filled with the undefined value. You must specify the type of data that will eventually fill the array.
-
-```res example
-let arr: array<Js.undefined<string>> = Belt.Array.makeUninitialized(5)
-
-Belt.Array.getExn(arr, 0) == Js.undefined
-```
-
-## makeUninitializedUnsafe
-
-```res sig
-let makeUninitializedUnsafe: int => array<'a>
-```
-
-Unsafe
-
-```res example
-let arr = Belt.Array.makeUninitializedUnsafe(5)
-
-Js.log(Belt.Array.getExn(arr, 0)) // undefined
-
-Belt.Array.setExn(arr, 0, "example")
-
-Js.log(Belt.Array.getExn(arr, 0) == "example")
-```
-
-## make
-
-```res sig
-let make: (int, 'a) => array<'a>
-```
-
-`make(n, e)` return an array of size `n` filled with value `e`.
-Returns an empty array when `n` is negative.
-
-## range
-
-```res sig
-let range: (int, int) => array<int>
-```
-
-`range(start, finish)` create an inclusive array.
-
-```res example
-Belt.Array.range(0, 3) == [0, 1, 2, 3]
-
-Belt.Array.range(3, 0) == []
-
-Belt.Array.range(3, 3) == [3]
-```
-
-## rangeBy
-
-```res sig
-let rangeBy: (int, int, ~step: int) => array<int>
-```
-
-`rangeBy(start, finish, ~step)`
-
-Returns empty array when step is 0 or negative. It also return an empty array when `start > finish`.
-
-```res example
-Belt.Array.rangeBy(0, 10, ~step=3) == [0, 3, 6, 9]
-
-Belt.Array.rangeBy(0, 12, ~step=3) == [0, 3, 6, 9, 12]
-
-Belt.Array.rangeBy(33, 0, ~step=1) == []
-
-Belt.Array.rangeBy(33, 0, ~step=-1) == []
-
-Belt.Array.rangeBy(3, 12, ~step=-1) == []
-
-Belt.Array.rangeBy(3, 3, ~step=0) == []
-
-Belt.Array.rangeBy(3, 3, ~step=1) == [3]
-```
-
-## makeByU
-
-```res sig
-let makeByU: (int, (. int) => 'a) => array<'a>
-```
-
-## makeBy
-
-```res sig
-let makeBy: (int, int => 'a) => array<'a>
-```
-
-`makeBy(n, f)`
-
-Return an empty array when n is negative return an array of size n populated by `f(i)` start from `0` to `n - 1`.
-
-```res example
-Belt.Array.makeBy(5, (i) => i) == [0, 1, 2, 3, 4]
-
-Belt.Array.makeBy(5, (i) => i * i) == [0, 1, 4, 9, 16]
-```
-
-## makeByAndShuffleU
-
-```res sig
-let makeByAndShuffleU: (int, (. int) => 'a) => array<'a>
-```
-
-## makeByAndShuffle
-
-```res sig
-let makeByAndShuffle: (int, int => 'a) => array<'a>
-```
-
-`makeByAndShuffle(n, f)`
-
-Equivalent to `shuffle(makeBy(n, f))`
-
-## zip
-
-```res sig
-let zip: (array<'a>, array<'b>) => array<('a, 'b)>
-```
-
-`zip(a, b)`
-
-Create an array of pairs from corresponding elements of a and b. Stop with the shorter array.
-
-```res example
-Belt.Array.zip([1, 2], [3, 4, 5]) == [(1, 3), (2, 4)]
-```
-
-## zipByU
-
-```res sig
-let zipByU: (array<'a>, array<'b>, (. 'a, 'b) => 'c) => array<'c>
-```
-
-## zipBy
-
-```res sig
-let zipBy: (array<'a>, array<'b>, ('a, 'b) => 'c) => array<'c>
-```
-
-`zipBy(xs, ys, f)`
-
-Create an array by applying `f` to corresponding elements of `xs` and `ys`. Stops with shorter array.
-
-Equivalent to `map(zip(xs, ys), ((a, b)) => f(a, b))`
-
-```res example
-Belt.Array.zipBy([1, 2, 3], [4, 5], (a, b) => 2 * a + b) == [6, 9]
-```
-
-## unzip
-
-```res sig
-let unzip: array<('a, 'b)> => (array<'a>, array<'b>)
-```
-
-`unzip(a)` takes an array of pairs and creates a pair of arrays. The first array contains all the first items of the pairs; the second array contains all the second items.
-
-```res example
-Belt.Array.unzip([(1, 2), (3, 4)]) == ([1, 3], [2, 4])
-
-Belt.Array.unzip([(1, 2), (3, 4), (5, 6), (7, 8)]) == ([1, 3, 5, 7], [2, 4, 6, 8])
-```
-
-## concat
-
-```res sig
-let concat: (array<'a>, array<'a>) => array<'a>
-```
-
-`concat(xs, ys)`
-
-Returns a fresh array containing the concatenation of the arrays `v1` and `v2`;so even if `v1` or `v2` is empty; it can not be shared
-
-```res example
-Belt.Array.concat([1, 2, 3], [4, 5]) == [1, 2, 3, 4, 5]
-
-Belt.Array.concat([], ["a", "b", "c"]) == ["a", "b", "c"]
-```
-
-## concatMany
-
-```res sig
-let concatMany: array<array<'a>> => array<'a>
-```
-
-`concatMany(xss)`
-
-Returns a fresh array as the concatenation of `xss` (an array of arrays)
-
-```res example
-Belt.Array.concatMany([[1, 2, 3], [4, 5, 6], [7, 8]]) == [1, 2, 3, 4, 5, 6, 7, 8]
-```
-
-## slice
-
-```res sig
-let slice: (array<'a>, ~offset: int, ~len: int) => array<'a>
-```
-
-`slice(xs, offset, len)` creates a new array with the len elements of `xs`
-starting at `offset` for `offset` can be negative;and is evaluated as
-`length(xs) - offset(slice, xs) - 1(1)` means get the last element as a
-singleton array `slice(xs, ~-len, len)` will return a copy of the array if the
-array does not have enough data; `slice` extracts through the end of sequence.
-
-if `len` is negative; returns the empty array.
-
-```res example
-Belt.Array.slice([10, 11, 12, 13, 14, 15, 16], ~offset=2, ~len=3) == [12, 13, 14]
-
-Belt.Array.slice([10, 11, 12, 13, 14, 15, 16], ~offset=-4, ~len=3) == [13, 14, 15]
-
-Belt.Array.slice([10, 11, 12, 13, 14, 15, 16], ~offset=4, ~len=9) == [14, 15, 16]
-```
-
-## sliceToEnd
-
-```res sig
-let sliceToEnd: (array<'a>, int) => array<'a>
-```
-
-`sliceToEnd(xs, offset)` creates a new array with the elements of `xs` starting at `offset`
-
-`offset` can be negative; and is evaluated as `length(xs) - offset(sliceToEnd, xs) - 1` means get the last element as a singleton array
-
-`sliceToEnd(xs, 0)` will return a copy of the array
-
-```res example
-Belt.Array.sliceToEnd([10, 11, 12, 13, 14, 15, 16], 2) == [12, 13, 14, 15, 16]
-
-Belt.Array.sliceToEnd([10, 11, 12, 13, 14, 15, 16], -4) == [13, 14, 15, 16]
-```
-
-## copy
-
-```res sig
-let copy: array<'a> => array<'a>
-```
-
-`copy(a)`
-
-Returns a copy of a; that is; a fresh array containing the same elements as a.
-
-## fill
-
-```res sig
-let fill: (array<'a>, ~offset: int, ~len: int, 'a) => unit
-```
-
-`fill(arr, ~offset, ~len, x)`
-
-Modifies `arr` in place, storing `x` in elements number `offset` to `offset + len - 1`.
-`offset` can be negative; and is evaluated as `length(arr - offset)`
-
-`fill(arr, ~offset=-1, ~len=1)` means fill the last element, if the array does not have enough data; `fill` will ignore it
-
-```res example
-let arr = Belt.Array.makeBy(5, (i) => i)
-
-Belt.Array.fill(arr, ~offset=2, ~len=2, 9)
-
-arr == [0, 1, 9, 9, 4]
-
-Belt.Array.fill(arr, ~offset=7, ~len=2, 8)
-
-arr == [0, 1, 9, 9, 4]
-```
-
-## blit
-
-```res sig
-let blit:
-  (
-    ~src: array<'a>,
-    ~srcOffset: int,
-    ~dst: array<'a>,
-    ~dstOffset: int,
-    ~len: int
-  ) =>
-  unit
-```
-
-`blit(~src=v1, ~srcOffset=o1, ~dst=v2, ~dstOffset=o2, ~len)`
-
-copies `len` elements from array `v1`;starting at element number `o1`;to array `v2`, starting at element number `o2`.
-
-It works correctly even if `v1` and `v2` are the same array;and the source and destination chunks overlap.
-
-`offset` can be negative; `-1` means `len - 1`; if `len + offset` is still negative;it will be set as 0
-
-For each of the examples;presume that `v1 == [10, 11, 12, 13, 14, 15, 16, 17]` and `v2 == [20, 21, 22, 23, 24, 25, 26, 27]`. The result shown is the content of the destination array.
-
-```res example
-let v1 = [10, 11, 12, 13, 14, 15, 16, 17]
-let v2 = [20, 21, 22, 23, 24, 25, 26, 27]
-
-Belt.Array.blit(~src=v1, ~srcOffset=4, ~dst=v2, ~dstOffset=2, ~len=3)
-v2 == [20, 21, 14, 15, 16, 25, 26, 27]
-
-Belt.Array.blit(~src=v1, ~srcOffset=4, ~dst=v1, ~dstOffset=2, ~len=3)
-v1 == [10, 11, 14, 15, 16, 15, 16, 17]
-```
-
-## blitUnsafe
-
-```res sig
-let blitUnsafe: (~src: array<'a>, ~srcOffset: int, ~dst: array<'a>, ~dstOffset: int, ~len: int) => unit
-```
-
-Unsafe blit without bounds checking.
-
-## forEachU
-
-```res sig
-let forEachU: (array<'a>, (. 'a) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (array<'a>, 'a => unit) => unit
-```
-
-`forEach(xs, f)`
-
-Call `f` on each element of `xs` from the beginning to end. `f` returns `unit`;so no new array is created. Use `forEach` when you are primarily concerned with repetitively creating side effects.
-
-```res example
-Belt.Array.forEach(["a", "b", "c"], x => Js.log("Item: " ++ x))
-
-/*
-  prints:
-  Item: a
-  Item: b
-  Item: c
-*/
-let total = ref(0)
-
-Belt.Array.forEach([1, 2, 3, 4], x => total := total.contents + x)
-
-total.contents == 1 + 2 + 3 + 4
-```
-
-## mapU
-
-```res sig
-let mapU: (array<'a>, (. 'a) => 'b) => array<'b>
-```
-
-## map
-
-```res sig
-let map: (array<'a>, 'a => 'b) => array<'b>
-```
-
-`map(xs, f)`
-
-Returns a new array by calling `f` for each element of `xs` from the beginning to end.
-
-```res example
-Belt.Array.map([1, 2], (x) => x + 2) == [3, 4]
-```
-
-## getByU
-
-```res sig
-let getByU: (array<'a>, (. 'a) => bool) => option<'a>
-```
-
-## getBy
-
-```res sig
-let getBy: (array<'a>, 'a => bool) => option<'a>
-```
-
-`getBy(xs, p)`
-
-Returns `Some(value)` for the first value in `xs` that satisifies the predicate function `p`; returns `None` if no element satisifies the function.
-
-```res example
-Belt.Array.getBy([1, 4, 3, 2], (x) => mod(x, 2) == 0) == Some(4)
-Belt.Array.getBy([15, 13, 11], (x) => mod(x, 2) == 0) == None
-```
-
-## getIndexByU
-
-```res sig
-let getIndexByU: (array<'a>, (. 'a) => bool) => option<int>
-```
-
-## getIndexBy
-
-```res sig
-let getIndexBy: (array<'a>, 'a => bool) => option<int>
-```
-
-`getIndexBy(xs, p)`
-
-returns `Some(index)` for the first value in `xs` that satisifies the predicate function `p`;
-returns `None` if no element satisifies the function.
-
-```res example
-Belt.Array.getIndexBy([1, 4, 3, 2], (x) => mod(x, 2) == 0) == Some(1)
-Belt.Array.getIndexBy([15, 13, 11], (x) => mod(x, 2) == 0) == None
-```
-
-## keepU
-
-```res sig
-let keepU: (array<'a>, (. 'a) => bool) => array<'a>
-```
-
-## keep
-
-```res sig
-let keep: (array<'a>, 'a => bool) => array<'a>
-```
-
-`keep(xs, p)`
-
-Returns a new array that keep all elements satisfy `p`.
-
-```res example
-Belt.Array.keep([1, 2, 3], (x) => mod(x, 2) == 0) == [2]
-```
-
-## keepWithIndexU
-
-```res sig
-let keepWithIndexU: (array<'a>, (. 'a, int) => bool) => array<'a>
-```
-
-## keepWithIndex
-
-```res sig
-let keepWithIndex: (array<'a>, ('a, int) => bool) => array<'a>
-```
-
-`keepWithIndex(xs, p)`
-
-Returns a new array that keep all elements satisfy `p`.
-
-```res example
-Belt.Array.keepWithIndex([1, 2, 3], (_x, i) => i == 1) == [2]
-```
-
-## keepMapU
-
-```res sig
-let keepMapU: (array<'a>, (. 'a) => option<'b>) => array<'b>
-```
-
-## keepMap
-
-```res sig
-let keepMap: (array<'a>, 'a => option<'b>) => array<'b>
-```
-
-`keepMap(xs, p)`
-
-Returns a new array that keep all elements that return a non-None applied `p`.
-
-```res example
-Belt.Array.keepMap([1, 2, 3], x =>
-  if mod(x, 2) == 0 {
-    Some(x)
-  } else {
-    None
-  }
-)
-== [2]
-```
-
-## forEachWithIndexU
-
-```res sig
-let forEachWithIndexU: (array<'a>, (. int, 'a) => unit) => unit
-```
-
-## forEachWithIndex
-
-```res sig
-let forEachWithIndex: (array<'a>, (int, 'a) => unit) => unit
-```
-
-`forEachWithIndex(xs, f)`
-
-The same as `Belt_Array.forEach`;
-except that `f` is supplied two arguments: the index starting from 0 and the element from `xs`.
-
-```res example
-Belt.Array.forEachWithIndex(["a", "b", "c"], (i, x) => Js.log("Item " ++ Belt.Int.toString(i) ++ " is " ++ x))
-
-/*
-  prints:
-  Item 0 is a
-  Item 1 is b
-  Item 2 is cc
-*/
-let total = ref(0)
-
-Belt.Array.forEachWithIndex([10, 11, 12, 13], (i, x) => total := total.contents + x + i)
-
-total.contents == 0 + 10 + 1 + 11 + 2 + 12 + 3 + 13
-```
-
-## mapWithIndexU
-
-```res sig
-let mapWithIndexU: (array<'a>, (. int, 'a) => 'b) => array<'b>
-```
-
-## mapWithIndex
-
-```res sig
-let mapWithIndex: (array<'a>, (int, 'a) => 'b) => array<'b>
-```
-
-`mapWithIndex(xs, f)`
-
-`mapWithIndex(xs, f)` applies `f` to each element of `xs`. Function `f` takes two arguments: the index starting from 0 and the element from `xs`.
-
-```res example
-Belt.Array.mapWithIndex([1, 2, 3], (i, x) => i + x) == [0 + 1, 1 + 2, 2 + 3]
-```
-
-## partitionU
-
-```res sig
-let partitionU: (array<'a>, (. 'a) => bool) => (array<'a>, array<'a>)
-```
-
-## partition
-
-```res sig
-let partition: (array<'a>, 'a => bool) => (array<'a>, array<'a>)
-```
-
-`partition(xs, p)` split array into tuple of two arrays based on predicate `p`; first of tuple where predicate cause true, second where predicate cause false.
-
-```res example
-Belt.Array.partition([1, 2, 3, 4, 5], (x) => mod(x, 2) == 0) == ([2, 4], [1, 3, 5])
-
-Belt.Array.partition([1, 2, 3, 4, 5], (x) => mod(x, 2) != 0) == ([1, 3, 5], [2, 4])
-```
-
-## reduceU
-
-```res sig
-let reduceU: (array<'b>, 'a, (. 'a, 'b) => 'a) => 'a
-```
-
-## reduce
-
-```res sig
-let reduce: (array<'b>, 'a, ('a, 'b) => 'a) => 'a
-```
-
-`reduce(arr, init, f)`
-
-Applies `f` to each element of `arr`.
-
-Function `f` has two parameters: an "accumulator" which starts with a value of `init` and the next value from the array. 
-
-It returns the final value of the accumulator.
-
-```res example
-Belt.Array.reduce([2, 3, 4], 1, (acc, value) => acc + value) == 10
-
-Belt.Array.reduce(["a", "b", "c", "d"], "", (a, b) => a ++ b) == "abcd"
-```
-
-## reduceReverseU
-
-```res sig
-let reduceReverseU: (array<'b>, 'a, (. 'a, 'b) => 'a) => 'a
-```
-
-## reduceReverse
-
-```res sig
-let reduceReverse: (array<'b>, 'a, ('a, 'b) => 'a) => 'a
-```
-
-`reduceReverse(xs, init, f)`
-
-Works like `Belt_Array.reduce`; except that function `f` is applied to each item of `xs` from the last back to the first.
-
-```res example
-Belt.Array.reduceReverse(["a", "b", "c", "d"], "", (a, b) => a ++ b) == "dcba"
-```
-
-## reduceReverse2U
-
-```res sig
-let reduceReverse2U: (array<'a>, array<'b>, 'c, (. 'c, 'a, 'b) => 'c) => 'c
-```
-
-## reduceReverse2
-
-```res sig
-let reduceReverse2: (array<'a>, array<'b>, 'c, ('c, 'a, 'b) => 'c) => 'c
-```
-
-`reduceReverse2(xs, ys, init, f)`
-
-Reduces two arrays xs and ys;taking items starting at `min(length(xs), length(ys))` down to and including zero.
-
-```res example
-Belt.Array.reduceReverse2([1, 2, 3], [1, 2], 0, (acc, x, y) => acc + x + y) == 6
-```
-
-## reduceWithIndexU
-
-```res sig
-let reduceWithIndexU: (array<'a>, 'b, (. 'b, 'a, int) => 'b) => 'b
-```
-
-## reduceWithIndex
-
-```res sig
-let reduceWithIndex: (array<'a>, 'b, ('b, 'a, int) => 'b) => 'b
-```
-
-`reduceWithIndex(arr, init, f)`
-
-Applies `f` to each element of `arr` from beginning to end. Function `f` has three parameters: an "accumulator", which starts with a value of `init` and the item from the array and the index of each element. `reduceWithIndex` returns the final value of the accumulator.
-
-```res example
-Belt.Array.reduceWithIndex([1, 2, 3, 4], 0, (acc, value, i) => acc + value + i) == 16
-```
-
-## someU
-
-```res sig
-let someU: (array<'a>, (. 'a) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (array<'a>, 'a => bool) => bool
-```
-
-`some(xs, p)`
-
-Returns true if at least one of the elements in `xs` satifies `p`; where `p` is a predicate: a function taking an element and returning a `bool`.
-
-```res example
-Belt.Array.some([2, 3, 4], (x) => mod(x, 2) == 1) == true
-
-Belt.Array.some([(-1), (-3), (-5)], (x) => x > 0) == false
-```
-
-## everyU
-
-```res sig
-let everyU: (array<'a>, (. 'a) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (array<'a>, 'a => bool) => bool
-```
-
-`every(xs, p)`
-
-Returns `true` if all elements satisfy `p`; where `p` is a predicate: a function taking an element and returning a `bool`.
-
-```res example
-Belt.Array.every([1, 3, 5], (x) => mod(x, 2) == 1) == true
-
-Belt.Array.every([1, (-3), 5], (x) => x > 0) == false
-```
-
-## every2U
-
-```res sig
-let every2U: (array<'a>, array<'b>, (. 'a, 'b) => bool) => bool
-```
-
-## every2
-
-```res sig
-let every2: (array<'a>, array<'b>, ('a, 'b) => bool) => bool
-```
-
-`every2(xs, ys, p)`
-
-returns true if `p(xi, yi)` is true for all pairs of elements up to the shorter length (i.e. `min(length(xs), length(ys))`)
-
-```res example
-Belt.Array.every2([1, 2, 3], [0, 1], (a, b) => a > b) == true
-
-Belt.Array.every2([], [1], (x, y) => x > y) == true
-
-Belt.Array.every2([2, 3], [1], (x, y) => x > y) == true
-
-Belt.Array.every2([0, 1], [5, 0], (x, y) => x > y) == false
-```
-
-## some2U
-
-```res sig
-let some2U: (array<'a>, array<'b>, (. 'a, 'b) => bool) => bool
-```
-
-## some2
-
-```res sig
-let some2: (array<'a>, array<'b>, ('a, 'b) => bool) => bool
-```
-
-`some2(xs, ys, p)`
-
-returns true if `p(xi, yi)` is true for any pair of elements up to the shorter length (i.e. `min(length(xs), length(ys))`)
-
-```res example
-Belt.Array.some2([0, 2], [1, 0, 3], (a, b) => a > b) == true
-
-Belt.Array.some2([], [1], (x, y) => x > y) == false
-
-Belt.Array.some2([2, 3], [1, 4], (x, y) => x > y) == true
-```
-
-## cmpU
-
-```res sig
-let cmpU: (array<'a>, array<'a>, (. 'a, 'a) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (array<'a>, array<'a>, ('a, 'a) => int) => int
-```
-
-`cmp(xs, ys, f)`
-
-Compared by length if `length(xs) != length(ys)`; returning -1 if `length(xs) < length(ys)` or 1 if `length(xs) > length(ys)`
-Otherwise compare one by one `f(x, y)`. `f` returns
-a negative number if `x` is “less than” `y`
-zero if `x` is “equal to” `y`
-a positive number if `x` is “greater than” `y`
-The comparison returns the first non-zero result of `f`;or zero if `f` returns zero for all `x` and `y`.
-
-```res example
-Belt.Array.cmp([1, 3, 5], [1, 4, 2], (a, b) => compare(a, b)) == -1
-
-Belt.Array.cmp([1, 3, 5], [1, 2, 3], (a, b) => compare(a, b)) == 1
-
-Belt.Array.cmp([1, 3, 5], [1, 3, 5], (a, b) => compare(a, b)) == 0
-```
-
-## eqU
-
-```res sig
-let eqU: (array<'a>, array<'a>, (. 'a, 'a) => bool) => bool
-```
-
-## eq
-
-```res sig
-let eq: (array<'a>, array<'a>, ('a, 'a) => bool) => bool
-```
-
-`eq(xs, ys)`
-
-return false if length is not the same
-otherwise compare items one by one using `f(xi, yi)`; and return true if all results are truefalse otherwise
-
-```res example
-Belt.Array.eq([1, 2, 3], [(-1), (-2), (-3)], (a, b) => abs(a) == abs(b)) == true
-```
-
-## truncateToLengthUnsafe
-
-```res sig
-let truncateToLengthUnsafe: (array<'a>, int) => unit
-```
-
-Unsafe `truncateToLengthUnsafe(xs, n)` sets length of array `xs` to `n`.
-
-If `n` is greater than the length of `xs`; the extra elements are set to `Js.Null_undefined.null`.
-
-If `n` is less than zero; raises a `RangeError`.
-
-```res example
-let arr = ["ant", "bee", "cat", "dog", "elk"]
-
-Belt.Array.truncateToLengthUnsafe(arr, 3)
-
-arr == ["ant", "bee", "cat"]
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/debug.mdx b/pages/docs/manual/v10.0.0/api/belt/debug.mdx
deleted file mode 100644
index 9fe40751f..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/debug.mdx
+++ /dev/null
@@ -1,7 +0,0 @@
-# Debug
-
-## setupChromeDebugger
-
-```res sig
-let setupChromeDebugger: unit => unit
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/float.mdx b/pages/docs/manual/v10.0.0/api/belt/float.mdx
deleted file mode 100644
index 9e316e24a..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/float.mdx
+++ /dev/null
@@ -1,107 +0,0 @@
-# Float
-
-This module includes convenience methods for handling `float` types.
-
-## toInt
-
-```res sig
-let toInt: float => int
-```
-
-Converts a given `float` to an `int`.
-
-```res example
-Js.log(Belt.Float.toInt(1.0) === 1) /* true */
-```
-
-## fromInt
-
-```res sig
-let fromInt: int => float
-```
-
-Converts a given `int` to a `float`.
-
-```res example
-Js.log(Belt.Float.fromInt(1) === 1.0) /* true */
-```
-
-## fromString
-
-```res sig
-let fromString: string => option<float>
-```
-
-Converts a given `string` to a `float`. Returns `Some(float)` when the input is a number, `None` otherwise.
-
-```res example
-Js.log(Belt.Float.fromString("1.0") === Some(1.0)) /* true */
-```
-
-## toString
-
-```res sig
-let toString: float => string
-```
-
-Converts a given `float` to a `string`. Uses the JavaScript `String` constructor under the hood.
-
-```res example
-Js.log(Belt.Float.toString(1.0) === "1.0") /* true */
-```
-
-## +
-
-```re sig
-let (+): (float, float) => float
-```
-
-Addition of two `float` values.
-Can be opened in a module to avoid dot-notation (`+.`), however this yields a shadow warning (Warning number 44) in the default configuration.
-
-```res example
-open Belt.Float
-Js.log(2.0 + 2.0 === 4.0) /* true */
-```
-
-## -
-
-```re sig
-let (-): (float, float) => float
-```
-
-Subtraction of two `float` values.
-Can be opened in a module to avoid dot-notation (`-.`), however this yields a shadow warning (Warning number 44) in the default configuration.
-
-```res example
-open Belt.Float
-Js.log(2.0 - 1.0 === 1.0) /* true */
-```
-
-## \*
-
-```re sig
-let (*): (float, float) => float
-```
-
-Multiplication of two `float` values.
-Can be opened in a module to avoid dot-notation (`*.`), however this yields a shadow warning (Warning number 44) in the default configuration.
-
-```res example
-open Belt.Float
-Js.log(2.0 * 2.0 === 4.0) /* true */
-```
-
-## /
-
-```re sig
-let (/): (float, float) => float
-```
-
-Division of two `float` values.
-Can be opened in a module to avoid dot-notation (`/.`), however this yields a shadow warning (Warning number 44) in the default configuration.
-
-```res example
-open Belt.Float
-Js.log(4.0 / 2.0 === 2.0) /* true */
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/hash-map-int.mdx b/pages/docs/manual/v10.0.0/api/belt/hash-map-int.mdx
deleted file mode 100644
index 0adeb762a..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/hash-map-int.mdx
+++ /dev/null
@@ -1,325 +0,0 @@
-# HashMapInt
-
-<Intro>
-
-Specialized when key type is `int`, more efficient than the generic type
-
-</Intro>
-
-## key
-
-```res prelude
-type key = int
-```
-
-Type of the `Belt.HashMap.Int` key.
-
-## t
-
-```res prelude
-type t<'b>
-```
-
-Type of the `Belt.HashMap.Int`
-
-## make
-
-```res sig
-let make: (~hintSize: int) => t<'b>
-```
-
-`make(~hintSize=10)` creates a new hash map by taking the `hintSize`.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-
-Belt.HashMap.Int.set(hMap, 1, "a")
-```
-
-## clear
-
-```res sig
-let clear: t<'b> => unit
-```
-
-Clears a hash table.
-
-```res example
-let hMap = Belt.HashMap.Int.fromArray([(1, "1")])
-Belt.HashMap.Int.clear(hMap)
-Belt.HashMap.Int.isEmpty(hMap) == true
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a> => bool
-```
-
-`isEmpty(m)` checks whether a hash map is empty.
-
-```res example
-let hMap = Belt.HashMap.Int.fromArray([(1, "1")])
-Belt.HashMap.Int.isEmpty(hMap) == false
-```
-
-## set
-
-```res sig
-let set: (t<'a>, key, 'a) => unit
-```
-
-`set(tbl, k, v)` if `k` does not exist, add the binding `k,v`, otherwise, update the old value with the new `v`.
-
-```res example
-let hMap = Belt.HashMap.Int.fromArray([(2, "2")])
-
-Belt.HashMap.Int.set(hMap, 1, "1")
-
-Belt.HashMap.Int.valuesToArray(hMap) == ["1", "2"]
-```
-
-## copy
-
-```res sig
-let copy: t<'a> => t<'a>
-```
-
-Creates copy of a hash map.
-
-```res example
-let hMap1 = Belt.HashMap.Int.fromArray([(1, "1"), (2, "2")])
-let hMap2 = Belt.HashMap.Int.copy(hMap1)
-
-Belt.HashMap.Int.set(hMap2, 2, "3")
-
-Belt.HashMap.Int.get(hMap1, 2) != Belt.HashMap.Int.get(hMap2, 2)
-```
-
-## get
-
-```res sig
-let get: (t<'a>, key) => option<'a>
-```
-
-## has
-
-```res sig
-let has: (t<'b>, key) => bool
-```
-
-Returns value bound under specific key. If values not exist returns `None`.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-
-Belt.HashMap.Int.get(hMap, 1) == Some("value1")
-Belt.HashMap.Int.get(hMap, 2) == None
-```
-
-## remove
-
-```res sig
-let remove: (t<'a>, key) => unit
-```
-
-If bound exists, removes it from the hash map.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-Belt.HashMap.Int.remove(hMap, 1)
-Belt.HashMap.Int.has(hMap, 1) == false
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'b>, (. key, 'b) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t<'b>, (key, 'b) => unit) => unit
-```
-
-`forEach(tbl, f)` applies `f` to all bindings in table `tbl`. `f` receives the key as first argument, and the associated value as second argument. Each binding is presented exactly once to `f`.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-Belt.HashMap.Int.forEach(hMap, (key, value) => Js.log2(key, value))
-// prints ("1", "value1")
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t<'b>, 'c, (. 'c, key, 'b) => 'c) => 'c
-```
-
-Same as [reduce](##reduce) but takes uncurried functon.
-
-## reduce
-
-```res sig
-let reduce: (t<'b>, 'c, ('c, key, 'b) => 'c) => 'c
-```
-
-`reduce(tbl, init, f)` computes `(f(kN, dN) ... (f(k1, d1, init))...)`, where `k1 ... kN` are the keys of all bindings in `tbl`, and `d1 ... dN` are the associated values. Each binding is presented exactly once to `f`.
-
-The order in which the bindings are passed to `f` is unspecified. However, if the table contains several bindings for the same key, they are passed to `f` in reverse order of introduction, that is, the most recent binding is passed first.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-Belt.HashMap.Int.set(hMap, 2, "value2")
-
-Belt.HashMap.Int.reduce(hMap, "", (acc, key, value) => acc ++ (", " ++ value)) == "value1, value2"
-```
-
-## keepMapInPlaceU
-
-```res sig
-let keepMapInPlaceU: (t<'a>, (. key, 'a) => option<'a>) => unit
-```
-
-Same as [keepMapInPlace](##keepMapInPlace) but takes uncurried functon.
-
-## keepMapInPlace
-
-```res sig
-let keepMapInPlace: (t<'a>, (key, 'a) => option<'a>) => unit
-```
-
-Filters out values for which function `f` returned `None`.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-Belt.HashMap.Int.set(hMap, 2, "value2")
-
-Belt.HashMap.Int.keepMapInPlace(hMap, (key, value) => mod(key, 1) == 0 ? None : Some(value))
-```
-
-## size
-
-```res sig
-let size: t<'a> => int
-```
-
-`size(tbl)` returns the number of bindings in `tbl`. It takes constant time.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-Belt.HashMap.Int.set(hMap, 2, "value2")
-
-Belt.HashMap.Int.size(hMap) == 2
-```
-
-## toArray
-
-```res sig
-let toArray: t<'a> => array<(key, 'a)>
-```
-
-Returns array of key value pairs.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-Belt.HashMap.Int.set(hMap, 2, "value2")
-
-Belt.HashMap.Int.toArray(hMap) == [(1, "value1"), (2, "value2")]
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'a> => array<key>
-```
-
-Returns array of keys.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-Belt.HashMap.Int.set(hMap, 2, "value2")
-
-Belt.HashMap.Int.keysToArray(hMap) == [1, 2]
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'a> => array<'a>
-```
-
-Returns array of values.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-Belt.HashMap.Int.set(hMap, 2, "value2")
-
-Belt.HashMap.Int.valuesToArray(hMap) == ["value1", "value2"]
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<(key, 'a)> => t<'a>
-```
-
-Creates new hash map from array of pairs.
-
-Returns array of values.
-
-```res example
-let hMap = Belt.HashMap.Int.fromArray([(1, "value1"), (1, "value2")])
-Belt.HashMap.Int.toArray(hMap) == [(1, "value1"), (2, "value2")]
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'a>, array<(key, 'a)>) => unit
-```
-
-Merges many key value pairs into hash map.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.mergeMany(hMap, [(1, "value1"), (2, "value2")])
-```
-
-## getBucketHistogram
-
-```res sig
-let getBucketHistogram: t<'a> => array<int>
-```
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "1")
-
-Belt.HashMap.Int.getBucketHistogram(hMap)
-```
-
-## logStats
-
-```res sig
-let logStats: t<'a> => unit
-```
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "1")
-
-Belt.HashMap.Int.logStats(hMap)
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/hash-map-string.mdx b/pages/docs/manual/v10.0.0/api/belt/hash-map-string.mdx
deleted file mode 100644
index 401e2dd70..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/hash-map-string.mdx
+++ /dev/null
@@ -1,337 +0,0 @@
-# HashMapString
-
-<Intro>
-
-Specialized when key type is `string`, more efficient than the generic type
-
-</Intro>
-
-## key
-
-```res prelude
-type key = string
-```
-
-Type of the `Belt.HashMap.String` key.
-
-## t
-
-```res prelude
-type t<'b>
-```
-
-Type of the `Belt.HashMap.String`.
-
-## make
-
-```res sig
-let make: (~hintSize: int) => t<'b>
-```
-
-`make(~hintSize=10)` creates a new hash map by taking the `hintSize`.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-
-Belt.HashMap.String.set(hMap, "key1", "a")
-```
-
-## clear
-
-```res sig
-let clear: t<'b> => unit
-```
-
-Clears a hash table.
-
-```res example
-let hMap = Belt.HashMap.String.fromArray([("1", "1")])
-Belt.HashMap.String.clear(hMap)
-Belt.HashMap.String.isEmpty(hMap) == true
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a> => bool
-```
-
-`isEmpty(m)` checks whether a hash map is empty.
-
-```res example
-let hMap = Belt.HashMap.String.fromArray([("1", "1")])
-Belt.HashMap.String.isEmpty(hMap) == false
-```
-
-## set
-
-```res sig
-let set: (t<'a>, key, 'a) => unit
-```
-
-`set(tbl, k, v)` if `k` does not exist, add the binding `k,v`, otherwise, update the old value with the new `v`.
-
-```res example
-let hMap = Belt.HashMap.String.fromArray([("2", "2")])
-
-Belt.HashMap.String.set(hMap, "1", "1")
-
-Belt.HashMap.String.valuesToArray(hMap) == ["1", "2"]
-```
-
-## copy
-
-```res sig
-let copy: t<'a> => t<'a>
-```
-
-Creates copy of a hash map.
-
-```res example
-let hMap1 = Belt.HashMap.String.fromArray([("1", "1"), ("2", "2")])
-let hMap2 = Belt.HashMap.String.copy(hMap1)
-
-Belt.HashMap.String.set(hMap2, "2", "3")
-
-Belt.HashMap.String.get(hMap1, "2") != Belt.HashMap.String.get(hMap2, "2")
-```
-
-## get
-
-```res sig
-let get: (t<'a>, key) => option<'a>
-```
-
-Returns value bound under specific key. If values not exist returns `None`.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-
-Belt.HashMap.String.get(hMap, "1") == Some("value1")
-Belt.HashMap.String.get(hMap, "2") == None
-```
-
-## has
-
-```res sig
-let has: (t<'b>, key) => bool
-```
-
-Checks if `x` is bound in `tbl`.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-
-Belt.HashMap.String.has(hMap, "1") == true
-Belt.HashMap.String.has(hMap, "2") == false
-```
-
-## remove
-
-```res sig
-let remove: (t<'a>, key) => unit
-```
-
-If bound exists, removes it from the hash map.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-Belt.HashMap.String.remove(hMap, "1")
-Belt.HashMap.String.has(hMap, "1") == false
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'b>, (. key, 'b) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t<'b>, (key, 'b) => unit) => unit
-```
-
-`forEach(tbl, f)` applies `f` to all bindings in table `tbl`. `f` receives the key as first argument, and the associated value as second argument. Each binding is presented exactly once to `f`.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-Belt.HashMap.String.forEach(hMap, (key, value) => Js.log2(key, value))
-// prints ("1", "value1")
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t<'b>, 'c, (. 'c, key, 'b) => 'c) => 'c
-```
-
-Same as [reduce](##reduce) but takes uncurried functon.
-
-## reduce
-
-```res sig
-let reduce: (t<'b>, 'c, ('c, key, 'b) => 'c) => 'c
-```
-
-`reduce(tbl, init, f)` computes `(f(kN, dN) ... (f(k1, d1, init))...)`, where `k1 ... kN` are the keys of all bindings in `tbl`, and `d1 ... dN` are the associated values. Each binding is presented exactly once to `f`.
-
-The order in which the bindings are passed to `f` is unspecified. However, if the table contains several bindings for the same key, they are passed to `f` in reverse order of introduction, that is, the most recent binding is passed first.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-Belt.HashMap.String.set(hMap, "2", "value2")
-
-Belt.HashMap.String.reduce(hMap, "", (acc, key, value) =>
-  acc ++ (", " ++ value)
-) == "value1, value2"
-```
-
-## keepMapInPlaceU
-
-```res sig
-let keepMapInPlaceU: (t<'a>, (. key, 'a) => option<'a>) => unit
-```
-
-Same as [keepMapInPlace](##keepMapInPlace) but takes uncurried functon.
-
-## keepMapInPlace
-
-```res sig
-let keepMapInPlace: (t<'a>, (key, 'a) => option<'a>) => unit
-```
-
-Filters out values for which function `f` returned `None`.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-Belt.HashMap.String.set(hMap, "2", "value2")
-
-Belt.HashMap.String.keepMapInPlace(hMap, (key, value) => key == "1" ? None : Some(value))
-```
-
-## size
-
-```res sig
-let size: t<'a> => int
-```
-
-`size(tbl)` returns the number of bindings in `tbl`. It takes constant time.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-Belt.HashMap.String.set(hMap, "2", "value2")
-
-Belt.HashMap.String.size(hMap) == 2
-```
-
-## toArray
-
-```res sig
-let toArray: t<'a> => array<(key, 'a)>
-```
-
-Returns array of key value pairs.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-Belt.HashMap.String.set(hMap, "2", "value2")
-
-Belt.HashMap.String.toArray(hMap) == [("1", "value1"), ("2", "value2")]
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'a> => array<key>
-```
-
-Returns array of keys.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-Belt.HashMap.String.set(hMap, "2", "value2")
-
-Belt.HashMap.String.keysToArray(hMap) == ["1", "2"]
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'a> => array<'a>
-```
-
-Returns array of values.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-Belt.HashMap.String.set(hMap, "2", "value2")
-
-Belt.HashMap.String.valuesToArray(hMap) == ["value1", "value2"]
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<(key, 'a)> => t<'a>
-```
-
-Creates new hash map from array of pairs.
-
-Returns array of values.
-
-```res example
-let hMap = Belt.HashMap.String.fromArray([("1", "value1"), ("2", "value2")])
-Belt.HashMap.String.toArray(hMap) == [("1", "value1"), ("2", "value2")]
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'a>, array<(key, 'a)>) => unit
-```
-
-Merges many key value pairs into hash map.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.mergeMany(hMap, [("1", "value1"), ("2", "value2")])
-```
-
-## getBucketHistogram
-
-```res sig
-let getBucketHistogram: t<'a> => array<int>
-```
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "1")
-
-Belt.HashMap.String.getBucketHistogram(hMap)
-```
-
-## logStats
-
-```res sig
-let logStats: t<'a> => unit
-```
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "1")
-
-Belt.HashMap.String.logStats(hMap)
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/hash-map.mdx b/pages/docs/manual/v10.0.0/api/belt/hash-map.mdx
deleted file mode 100644
index 36a8de539..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/hash-map.mdx
+++ /dev/null
@@ -1,444 +0,0 @@
-# HashMap
-
-<Intro>
-
-The top level provides generic mutable hash map operations.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'key, 'value, 'id>
-```
-
-The type of hash tables from type `'key` to type `'value`.
-
-## id
-
-```res prelude
-type id<'a, 'id> = Belt.Id.hashable<'a, 'id>
-```
-
-The identity needed for making an empty hash map.
-
-## make
-
-```res sig
-let make: (~hintSize: int, ~id: id<'key, 'id>) => t<'key, 'value, 'id>
-```
-
-`make(~hintSize=10, ~id)` creates a new map by taking in the comparator and `hintSize`.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let hMap = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-
-Belt.HashMap.set(hMap, 0, "a")
-```
-
-## clear
-
-```res sig
-let clear: t<'key, 'value, 'id> => unit
-```
-
-Clears a hash table.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let hMap = Belt.HashMap.fromArray([(1, "1")], ~id=module(IntHash))
-Belt.HashMap.clear(hMap)
-Belt.HashMap.isEmpty(hMap) == true
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a, 'b, 'c> => bool
-```
-
-`isEmpty(m)` checks whether a hash map is empty.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-Belt.HashMap.isEmpty(Belt.HashMap.fromArray([(1, "1")], ~id=module(IntHash))) == false
-```
-
-## set
-
-```res sig
-let set: (t<'key, 'value, 'id>, 'key, 'value) => unit
-```
-
-`set(hMap, k, v)` if `k` does not exist, add the binding `k,v`, otherwise, update the old value with the new `v`.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntHash))
-
-Belt.HashMap.set(s0, 2, "3")
-
-Belt.HashMap.valuesToArray(s0) == ["1", "3", "3"]
-```
-
-## copy
-
-```res sig
-let copy: t<'key, 'value, 'id> => t<'key, 'value, 'id>
-```
-
-Creates copy of a hash map.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntHash))
-let s1 = Belt.HashMap.copy(s0)
-
-Belt.HashMap.set(s0, 2, "3")
-
-Belt.HashMap.get(s0, 2) != Belt.HashMap.get(s1, 2)
-```
-
-## get
-
-```res sig
-let get: (t<'key, 'value, 'id>, 'key) => option<'value>
-```
-
-Returns value bound under specific key. If values not exist returns `None`.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-
-Belt.HashMap.get(s0, 1) == Some("value1")
-Belt.HashMap.get(s0, 2) == None
-```
-
-## has
-
-```res sig
-let has: (t<'key, 'value, 'id>, 'key) => bool
-```
-
-Checks if `x` is bound in `tbl`.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-
-Belt.HashMap.has(s0, 1) == true
-Belt.HashMap.has(s0, 2) == false
-```
-
-## remove
-
-```res sig
-let remove: (t<'key, 'value, 'id>, 'key) => unit
-```
-
-If bound exists, removes it from the hash map.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-Belt.HashMap.remove(s0, 1)
-Belt.HashMap.has(s0, 1) == false
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'key, 'value, 'id>, (. 'key, 'value) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t<'key, 'value, 'id>, ('key, 'value) => unit) => unit
-```
-
-`forEach(tbl, f)` applies `f` to all bindings in table `tbl`. `f` receives the key as first argument, and the associated value as second argument. Each binding is presented exactly once to `f`.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-Belt.HashMap.forEach(s0, (key, value) => Js.log2(key, value))
-// prints (1, "value1")
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t<'key, 'value, 'id>, 'c, (. 'c, 'key, 'value) => 'c) => 'c
-```
-
-Same as [reduce](##reduce) but takes uncurried functon.
-
-## reduce
-
-```res sig
-let reduce: (t<'key, 'value, 'id>, 'c, ('c, 'key, 'value) => 'c) => 'c
-```
-
-`reduce(tbl, init, f)` computes `(f(kN, dN) ... (f(k1, d1, init))...)`, where `k1 ... kN` are the keys of all bindings in `tbl`, and `d1 ... dN` are the associated values. Each binding is presented exactly once to `f`.
-
-The order in which the bindings are passed to `f` is unspecified. However, if the table contains several bindings for the same key, they are passed to `f` in reverse order of introduction, that is, the most recent binding is passed first.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-Belt.HashMap.set(s0, 2, "value2")
-
-Belt.HashMap.reduce(s0, "", (acc, key, value) => acc ++ (", " ++ value)) == "value1, value2"
-```
-
-## keepMapInPlaceU
-
-```res sig
-let keepMapInPlaceU: (t<'key, 'value, 'id>, (. 'key, 'value) => option<'value>) => unit
-```
-
-Same as [keepMapInPlace](##keepMapInPlace) but takes uncurried functon.
-
-## keepMapInPlace
-
-```res sig
-let keepMapInPlace: (t<'key, 'value, 'id>, ('key, 'value) => option<'value>) => unit
-```
-
-Filters out values for which function `f` returned `None`.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-Belt.HashMap.set(s0, 2, "value2")
-
-Belt.HashMap.keepMapInPlace(s0, (key, value) => key == 1 ? None : Some(value))
-```
-
-## size
-
-```res sig
-let size: t<'a, 'b, 'c> => int
-```
-
-`size(tbl)` returns the number of bindings in `tbl`. It takes constant time.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-Belt.HashMap.set(s0, 2, "value2")
-
-Belt.HashMap.size(s0) == 2
-```
-
-## toArray
-
-```res sig
-let toArray: t<'key, 'value, 'id> => array<('key, 'value)>
-```
-
-Returns array of key value pairs.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-Belt.HashMap.set(s0, 2, "value2")
-
-Belt.HashMap.toArray(s0) == [(1, "value1"), (2, "value2")]
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'key, 'a, 'b> => array<'key>
-```
-
-Returns array of keys.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-Belt.HashMap.set(s0, 2, "value2")
-
-Belt.HashMap.keysToArray(s0) == [1, 2]
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'a, 'value, 'b> => array<'value>
-```
-
-Returns array of values.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-Belt.HashMap.set(s0, 2, "value2")
-
-Belt.HashMap.valuesToArray(s0) == ["value1", "value2"]
-```
-
-## fromArray
-
-```res sig
-let fromArray: (array<('key, 'value)>, ~id: id<'key, 'id>) => t<'key, 'value, 'id>
-```
-
-Creates new hash map from array of pairs.
-
-Returns array of values.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.fromArray([(1, "value1"), (2, "value2")], ~id=module(IntHash))
-Belt.HashMap.toArray(s0) == [(1, "value1"), (2, "value2")]
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'key, 'value, 'id>, array<('key, 'value)>) => unit
-```
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let hMap = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.mergeMany(hMap, [(1, "1"), (2, "2")])
-```
-
-## getBucketHistogram
-
-```res sig
-let getBucketHistogram: t<'a, 'b, 'c> => array<int>
-```
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-let hMap = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(hMap, 1, "1")
-
-Belt.HashMap.getBucketHistogram(hMap)
-```
-
-## logStats
-
-```res sig
-let logStats: t<'a, 'b, 'c> => unit
-```
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-let hMap = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(hMap, 1, "1")
-
-Belt.HashMap.logStats(hMap)
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/hash-set-int.mdx b/pages/docs/manual/v10.0.0/api/belt/hash-set-int.mdx
deleted file mode 100644
index d73d3f856..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/hash-set-int.mdx
+++ /dev/null
@@ -1,123 +0,0 @@
-# HashSetInt
-
-<Intro>
-
-This module is `Belt.HashSet` specialized with key type to be a primitive type.
-
-It is more efficient in general, the API is the same with `Belt.HashSet` except its key type is fixed, and identity is not needed(using the built-in one).
-
-</Intro>
-
-## key
-
-```res prelude
-type key = int
-```
-
-## t
-
-```res prelude
-type t
-```
-
-## make
-
-```res sig
-let make: (~hintSize: int) => t
-```
-
-## clear
-
-```res sig
-let clear: t => unit
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t => bool
-```
-
-## add
-
-```res sig
-let add: (t, key) => unit
-```
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## has
-
-```res sig
-let has: (t, key) => bool
-```
-
-## remove
-
-```res sig
-let remove: (t, key) => unit
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t, (. key) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t, key => unit) => unit
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t, 'c, (. 'c, key) => 'c) => 'c
-```
-
-## reduce
-
-```res sig
-let reduce: (t, 'c, ('c, key) => 'c) => 'c
-```
-
-## size
-
-```res sig
-let size: t => int
-```
-
-## logStats
-
-```res sig
-let logStats: t => unit
-```
-
-## toArray
-
-```res sig
-let toArray: t => array<key>
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<key> => t
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t, array<key>) => unit
-```
-
-## getBucketHistogram
-
-```res sig
-let getBucketHistogram: t => array<int>
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/hash-set-string.mdx b/pages/docs/manual/v10.0.0/api/belt/hash-set-string.mdx
deleted file mode 100644
index 277d95228..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/hash-set-string.mdx
+++ /dev/null
@@ -1,123 +0,0 @@
-# HashSetString
-
-<Intro>
-
-This module is `Belt.HashSet` specialized with key type to be a primitive type.
-
-It is more efficient in general, the API is the same with `Belt.HashSet` except its key type is fixed, and identity is not needed(using the built-in one).
-
-</Intro>
-
-## key
-
-```res prelude
-type key = string
-```
-
-## t
-
-```res prelude
-type t
-```
-
-## make
-
-```res sig
-let make: (~hintSize: int) => t
-```
-
-## clear
-
-```res sig
-let clear: t => unit
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t => bool
-```
-
-## add
-
-```res sig
-let add: (t, key) => unit
-```
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## has
-
-```res sig
-let has: (t, key) => bool
-```
-
-## remove
-
-```res sig
-let remove: (t, key) => unit
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t, (. key) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t, key => unit) => unit
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t, 'c, (. 'c, key) => 'c) => 'c
-```
-
-## reduce
-
-```res sig
-let reduce: (t, 'c, ('c, key) => 'c) => 'c
-```
-
-## size
-
-```res sig
-let size: t => int
-```
-
-## logStats
-
-```res sig
-let logStats: t => unit
-```
-
-## toArray
-
-```res sig
-let toArray: t => array<key>
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<key> => t
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t, array<key>) => unit
-```
-
-## getBucketHistogram
-
-```res sig
-let getBucketHistogram: t => array<int>
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/hash-set.mdx b/pages/docs/manual/v10.0.0/api/belt/hash-set.mdx
deleted file mode 100644
index d10a07ef2..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/hash-set.mdx
+++ /dev/null
@@ -1,160 +0,0 @@
-# HashSet
-
-<Intro>
-
-A mutable Hash set which allows customized `hash` behavior.
-All data are parameterized by not its only type but also a unique identity in the time of initialization, so that two HashSets of ints initialized with different hash functions will have different type.
-
-</Intro>
-
-```res prelude
-module I0 = unpack(
-  Belt.Id.hashableU(
-    ~hash=(. a: int) => land(a, 65535),
-    ~eq=(. a, b) => a == b,
-  )
-)
-
-let s0 = Belt.HashSet.make(~id=module(I0), ~hintSize=40)
-
-module I1 = unpack(
-  Belt.Id.hashableU(
-    ~hash=(. a: int) => land(a, 255),
-    ~eq=(. a, b) => a == b,
-  )
-)
-
-let s1 = Belt.HashSet.make(~id=module(I1), ~hintSize=40)
-
-Belt.HashSet.add(s1, 0)
-Belt.HashSet.add(s1, 1)
-```
-
-The invariant must be held: for two elements who are equal, their hashed value should be the same.
-
-Here the compiler would infer `s0` and `s1` having different type so that it would not mix.
-
-```res sig
-let s0: Belt.HashSet.t<int, I0.identity>
-let s1: Belt.HashSet.t<int, I1.identity>
-```
-
-We can add elements to the collection (see last two lines in the example above). Since this is an mutable data structure, `s1` will contain two pairs.
-
-## t
-
-```res prelude
-type t<'a, 'id>
-```
-
-## id
-
-```res prelude
-type id<'a, 'id> = Belt.Id.hashable<'a, 'id>
-```
-
-## make
-
-```res sig
-let make: (~hintSize: int, ~id: id<'a, 'id>) => t<'a, 'id>
-```
-
-## clear
-
-```res sig
-let clear: t<'a, 'id> => unit
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a, 'b> => bool
-```
-
-## add
-
-```res sig
-let add: (t<'a, 'id>, 'a) => unit
-```
-
-## copy
-
-```res sig
-let copy: t<'a, 'id> => t<'a, 'id>
-```
-
-## has
-
-```res sig
-let has: (t<'a, 'id>, 'a) => bool
-```
-
-## remove
-
-```res sig
-let remove: (t<'a, 'id>, 'a) => unit
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'a, 'id>, (. 'a) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'a, 'id>, 'a => unit) => unit
-```
-
-Order unspecified.
-
-## reduceU
-
-```res sig
-let reduceU: (t<'a, 'id>, 'c, (. 'c, 'a) => 'c) => 'c
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'a, 'id>, 'c, ('c, 'a) => 'c) => 'c
-```
-
-Order unspecified.
-
-## size
-
-```res sig
-let size: t<'a, 'id> => int
-```
-
-## logStats
-
-```res sig
-let logStats: t<'a, 'b> => unit
-```
-
-## toArray
-
-```res sig
-let toArray: t<'a, 'id> => array<'a>
-```
-
-## fromArray
-
-```res sig
-let fromArray: (array<'a>, ~id: id<'a, 'id>) => t<'a, 'id>
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'a, 'id>, array<'a>) => unit
-```
-
-## getBucketHistogram
-
-```res sig
-let getBucketHistogram: t<'a, 'b> => array<int>
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/id.mdx b/pages/docs/manual/v10.0.0/api/belt/id.mdx
deleted file mode 100644
index b8646dffe..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/id.mdx
+++ /dev/null
@@ -1,157 +0,0 @@
-# Id
-
-<Intro>
-
-Provide utilities to create identified comparators or hashes for data
-structures used below.
-
-It creates a unique identifier per module of functions so that different data
-structures with slightly different comparison functions won't mix.
-
-</Intro>
-
-## hash
-
-```res sig
-type hash<'a, 'id>
-```
-
-Its runtime represenation is a hash function, but signed with a type parameter, so that different hash functions type mismatch.
-
-## eq
-
-```res sig
-type eq<'a, 'id>
-```
-
-Its runtime represenation is an eq function, but signed with a type parameter, so that different hash functions type mismatch.
-
-## cmp
-
-```res sig
-type cmp<'a, 'id>
-```
-
-Its runtime representation is a cmp function, but signed with a type parameter, so that different hash functions type mismatch.
-
-## Comparable
-
-```res prelude
-module type Comparable = {
-  type identity
-
-  type t
-
-  let cmp: Belt.Id.cmp<t, identity>
-}
-```
-
-## comparable
-
-```res sig
-type comparable<'key,'id> =
-  module(Belt.Id.Comparable with type identity = 'id and type t = 'key)
-```
-
-is a module of functions, here it only includes cmp.
-
-Unlike normal functions, when created, it comes with a unique identity (guaranteed by the type system).
-
-It can be created using function `Belt_Id.comparableU` or `Belt_Id.comparable`.
-
-The idea of a unique identity when created is that it makes sure two sets would type mismatch if they use different comparison function
-
-## MakeComparableU
-
-```res sig
-module MakeComparableU: (M: {
-  type t
-  let cmp: (. t, t) => int
-}) => Comparable with type t = M.t
-```
-
-## MakeComparable
-
-```res sig
-module MakeComparable: (M: {
-  type t
-  let cmp: (t, t) => int
-}) => Comparable with type t = M.t
-```
-
-## comparableU
-
-```res sig
-let comparableU: (~cmp: (. 'a, 'a) => int) =>
-  module(Belt.Id.Comparable with type t = 'a)
-```
-
-## comparable
-
-```res sig
-type comparable<'key, 'id> =
-  module(Belt.Id.Comparable with type identity = 'id and type t = 'key)
-```
-
-## Hashable
-
-```res prelude
-module type Hashable = {
-  type identity
-
-  type t
-
-  let hash: Belt.Id.hash<t, identity>
-
-  let eq: Belt.Id.eq<t, identity>
-}
-```
-
-## hashable
-
-```res sig
-type hashable<'key, 'id> =
-  module(Belt.Id.Hashable with type identity = 'id and type t = 'key)
-```
-
-is a module of functions, here it only includes hash, eq.
-
-Unlike normal functions, when created, it comes with a unique identity (guaranteed by the type system).
-
-It can be created using function `Belt_Id.hashableU` or `Belt_Id.hashable`.
-
-The idea of a unique identity when created is that it makes sure two hash sets would type mismatch if they use different comparison function.
-
-## MakeHashableU
-
-```res sig
-module MakeHashableU: (M: {
-  type t
-  let hash: (. t) => int
-  let eq: (. t, t) => bool
-}) => Hashable with type t = M.t
-```
-
-## MakeHashable
-
-```res sig
-module MakeHashable: (M: {
-  type t
-  let hash: t => int
-  let eq: (t, t) => bool
-}) => Hashable with type t = M.t
-```
-
-## hashableU
-
-```res sig
-let hashableU: (~hash: (. 'a) => int, ~eq: (. 'a, 'a) => bool) =>
-  module(Belt.Id.Hashable with type t = 'a)
-```
-
-## hashable
-
-```res sig
-let hashable: (~hash: 'a => int, ~eq: ('a, 'a) => bool) =>
-  module(Belt.Id.Hashable with type t = 'a)
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/int.mdx b/pages/docs/manual/v10.0.0/api/belt/int.mdx
deleted file mode 100644
index 76fa52fbb..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/int.mdx
+++ /dev/null
@@ -1,104 +0,0 @@
-# Int
-
-This module includes convenience methods for handling `int` types.
-
-## toFloat
-
-```res sig
-let toFloat: int => float
-```
-
-Converts a given `int` to a `float`.
-
-```res example
-Js.log(Belt.Int.toFloat(1) === 1.0) /* true */
-```
-
-## fromFloat
-
-```res sig
-let fromFloat: float => int
-```
-
-Converts a given `float` to an `int`.
-
-```res example
-Js.log(Belt.Int.fromFloat(1.0) === 1) /* true */
-```
-
-## fromString
-
-```res sig
-let fromString: string => option<int>
-```
-
-Converts a given `string` to an `int`. Returns `Some(int)` when the input is a number, `None` otherwise.
-
-```res example
-Js.log(Belt.Int.fromString("1") === Some(1)) /* true */
-```
-
-
-## toString
-
-```res sig
-let toString: int => string
-```
-
-Converts a given `int` to a `string`. Uses the JavaScript `String` constructor under the hood.
-
-```res example
-Js.log(Belt.Int.toString(1) === "1") /* true */
-```
-
-## +
-
-```re sig
-let (+): (int, int) => int
-```
-
-Addition of two `int` values. Same as the addition from `Pervasives`.
-
-```res example
-open Belt.Int
-Js.log(2 + 2 === 4) /* true */
-```
-
-## -
-
-```re sig
-let (-): (int, int) => int
-```
-
-Subtraction of two `int` values. Same as the subtraction from `Pervasives`.
-
-```res example
-open Belt.Int
-Js.log(2 - 1 === 1) /* true */
-```
-
-## \*
-
-```re sig
-let (*): (int, int) => int
-```
-
-Multiplication of two `int` values. Same as the multiplication from `Pervasives`.
-
-```res example
-open Belt.Int
-Js.log(2 * 2 === 4) /* true */
-```
-
-## /
-
-```re sig
-let (/): (int, int) => int
-```
-
-Division of two `int` values. Same as the division from `Pervasives`.
-
-```res example
-open Belt.Int
-Js.log(4 / 2 === 2); /* true */
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/list.mdx b/pages/docs/manual/v10.0.0/api/belt/list.mdx
deleted file mode 100644
index ce67561e8..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/list.mdx
+++ /dev/null
@@ -1,1123 +0,0 @@
-# List
-
-<Intro>
-
-Collection functions for manipulating the `list` data structures, a singly-linked list.
-
-**Prefer Array** if you need any of the following:
-
-- Random access of element
-- Better interop with JavaScript
-- Better memory usage & performance.
-
-</Intro>
-
-## t\<'a>
-
-```res prelude
-type t<'a> = list<'a>
-```
-
-## length
-
-```res sig
-let length: t<'a> => int
-```
-
-Returns the length of a list.
-
-```res example
-Belt.List.length(list{1, 2, 3}) // 3
-```
-
-## size
-
-```res sig
-let size: t<'a> => int
-```
-
-**See:** list\{length}(#length)
-
-## head
-
-```res sig
-let head: t<'a> => option<'a>
-```
-
-Returns `Some(value)` where `value` is the first element in the list, or `None` if `someList` is an empty list.
-
-```res example
-Belt.List.head(list{}) // None
-Belt.List.head(list{1, 2, 3}) // Some(1)
-```
-
-## headExn
-
-```res sig
-let headExn: t<'a> => 'a
-```
-
-Same as [head](#head), but raises an exception if `someList` is empty. Use with care.
-
-```res example
-Belt.List.headExn(list{1, 2, 3}) // 1
-
-Belt.List.headExn(list{}) // Raises an Error
-```
-
-## tail
-
-```res sig
-let tail: t<'a> => option<t<'a>>
-```
-
-Returns `None` if `someList` is empty, otherwise it returns `Some(tail)` where `tail` is everything except the first element of `someList`.
-
-```res example
-Belt.List.tail(list{1, 2, 3}) // Some(list{2, 3})
-
-Belt.List.tail(list{}) // None
-```
-
-## tailExn
-
-```res sig
-let tailExn: t<'a> => t<'a>
-```
-
-Same as [tail](#tail), but raises an exception if `someList` is empty. Use with care.
-
-```res example
-Belt.List.tailExn(list{1, 2, 3}) // list{2, 3}
-
-Belt.List.tailExn(list{}) // Raises an Error
-```
-
-## add
-
-```res sig
-let add: (t<'a>, 'a) => t<'a>
-```
-
-Adds `value` to the beginning of `someList`.
-
-```res example
-Belt.List.add(list{2, 3}, 1) // list{1, 2, 3}
-
-Belt.List.add(list{"World", "!"}, "Hello") // list{"Hello", "World", "!"}
-```
-
-## get
-
-```res sig
-let get: (t<'a>, int) => option<'a>
-```
-
-Return the nth element in `someList`, or `None` if `index` is larger than the length.
-
-```res example
-let abc = list{"A", "B", "C"}
-
-abc->Belt.List.get(1) // Some("B")
-
-abc->Belt.List.get(4) // None
-```
-
-## getExn
-
-```res sig
-let getExn: (t<'a>, int) => 'a
-```
-
-Same as [get](#get), but raises an exception if `index` is larger than the length. Use with care.
-
-```res example
-let abc = list{"A", "B", "C"}
-
-abc->Belt.List.getExn(1) // "B"
-
-abc->Belt.List.getExn(4) // Raises an Error
-```
-
-## make
-
-```
-let make: (int, 'a) => t<'a>
-```
-
-Returns a list of length `numItems` with each element filled with value `v`. Returns an empty list if `numItems` is negative.
-
-```res example
-Belt.List.make(3, 1) // list{1, 1, 1}
-```
-
-## makeBy
-
-```res sig
-let makeBy: (int, int => 'a) => t<'a>
-```
-
-Return a list of length `numItems` with element `i` initialized with `f(i)`.
-Returns an empty list if `numItems` is negative.
-
-```res example
-Belt.List.makeBy(5, i => i) // list{0, 1, 2, 3, 4}
-
-Belt.List.makeBy(5, i => i * i) // list{0, 1, 4, 9, 16}
-```
-
-## makeByU
-
-```res sig
-let makeByU: (int, (. int) => 'a) => t<'a>
-```
-
-Uncurried version of [makeBy](#makeBy)
-
-## shuffle
-
-```res sig
-let shuffle: t<'a> => t<'a>
-```
-
-Returns a new list in random order.
-
-```res example
-Belt.List.shuffle(list{1, 2, 3}) // list{2, 1, 3}
-```
-
-## drop
-
-```res sig
-let drop: (t<'a>, int) => option<t<'a>>
-```
-
-Return a new list, dropping the first `n` elements. Returns `None` if `someList` has fewer than `n` elements.
-
-```res example
-list{1, 2, 3}->Belt.List.drop(2) // Some(list{3})
-
-list{1, 2, 3}->Belt.List.drop(3) // Some(list{})
-
-list{1, 2, 3}->Belt.List.drop(4) // None
-```
-
-## take
-
-```res sig
-let take: (t<'a>, int) => option<t<'a>>
-```
-
-Returns a list with the first `n` elements from `someList`, or `None` if `someList` has fewer than `n` elements.
-
-```res example
-list{1, 2, 3}->Belt.List.take(1) // Some(list{1})
-
-list{1, 2, 3}->Belt.List.take(2) // Some(list{1, 2})
-
-list{1, 2, 3}->Belt.List.take(4) // None
-```
-
-## splitAt
-
-```res sig
-let splitAt: (t<'a>, int) => option<(list<'a>, list<'a>)>
-```
-
-Split the list `someList` at `index`. Returns `None` when the length of `someList` is less than `index`.
-
-```res example
-list{"Hello", "World"}->Belt.List.splitAt(1) // Some((list{"Hello"}, list{"World"}))
-
-list{0, 1, 2, 3, 4}->Belt.List.splitAt(2) // Some((list{0, 1}, list{2, 3, 4}))
-```
-
-## concat
-
-```res sig
-let concat: (t<'a>, t<'a>) => t<'a>
-```
-
-Returns the list obtained by adding `secondList` after `firstList`.
-
-```res example
-Belt.List.concat(list{1, 2, 3}, list{4, 5}) // list{1, 2, 3, 4, 5}
-```
-
-## concatMany
-
-```res sig
-let concatMany: array<t<'a>> => t<'a>
-```
-
-Returns the list obtained by concatenating all the lists in array `a`, in order.
-
-```res example
-Belt.List.concatMany([list{1, 2, 3}, list{}, list{3}]) // list{1, 2, 3, 3}
-```
-
-## reverseConcat
-
-```res sig
-let reverseConcat: (t<'a>, t<'a>) => t<'a>
-```
-
-Equivalent to writing: `concat(reverse(firstList, secondList)`
-
-```res example
-Belt.List.reverseConcat(list{1, 2}, list{3, 4}) // list{2, 1, 3, 4}
-```
-
-## flatten
-
-```res sig
-let flatten: t<t<'a>> => t<'a>
-```
-
-Return the list obtained by concatenating all the lists in list `ls`, in order.
-
-```res example
-Belt.List.flatten(list{list{1, 2, 3}, list{}, list{3}}) // list{1, 2, 3, 3}
-```
-
-## map
-
-```res sig
-let map: (t<'a>, 'a => 'b) => t<'b>
-```
-
-Returns a new list with `f` applied to each element of `someList`.
-
-```res example
-list{1, 2}->Belt.List.map(x => x + 1) // list{3, 4}
-```
-
-## mapU
-
-```res sig
-let mapU: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-Uncurried version of [map](#map).
-
-## zip
-
-```res sig
-let zip: (t<'a>, t<'b>) => t<('a, 'b)>
-```
-
-Returns a list of pairs from the two lists with the length of the shorter list.
-
-```res example
-Belt.List.zip(list{1, 2}, list{3, 4, 5}) // list{(1, 3), (2, 4)}
-```
-
-## zipBy
-
-```res sig
-let zipBy: (t<'a>, t<'b>, ('a, 'b) => 'c) => t<'c>
-```
-
-**See:** [zip](#zip)
-
-```res example
-Belt.List.zipBy(list{1, 2, 3}, list{4, 5}, (a, b) => 2 * a + b) // list{6, 9}
-```
-
-## zipByU
-
-```res sig
-let zipByU: (t<'a>, t<'b>, (. 'a, 'b) => 'c) => t<'c>
-```
-
-Uncurried version of [zipBy](#zipBy).
-
-## mapWithIndex
-
-```res sig
-let mapWithIndex: (t<'a>, (int, 'a) => 'b) => t<'b>
-```
-
-Applies `f` to each element of `someList`.
-Function `f` takes two arguments: the index starting from 0 and the element from `someList`, in that order.
-
-```res example
-list{1, 2, 3}->Belt.List.mapWithIndex((index, x) => index + x) // list{1, 3, 5}
-```
-
-## mapWithIndexU
-
-```res sig
-let mapWithIndexU: (t<'a>, (. int, 'a) => 'b) => t<'b>
-```
-
-Uncurried version of [mapWithIndex](#mapWithIndex).
-
-## fromArray
-
-```res sig
-let fromArray: array<'a> => t<'a>
-```
-
-Converts the given array to a list.
-
-```res example
-Belt.List.fromArray([1, 2, 3]) // list{1, 2, 3}
-```
-
-## toArray
-
-```res sig
-let toArray: t<'a> => array<'a>
-```
-
-Converts the given list to an array.
-
-```res example
-Belt.List.toArray(list{1, 2, 3}) // [1, 2, 3]
-```
-
-## reverse
-
-```res sig
-let reverse: t<'a> => t<'a>
-```
-
-Returns a new list whose elements are those of `someList` in reversed order.
-
-```res example
-Belt.List.reverse(list{1, 2, 3}) /* list{3, 2, 1} */
-```
-
-## mapReverse
-
-```res sig
-let mapReverse: (t<'a>, 'a => 'b) => t<'b>
-```
-
-Equivalent to:
-
-```res
-map(someList, f)->reverse
-```
-
-```res example
-list{3, 4, 5}->Belt.List.mapReverse(x => x * x) /* list{25, 16, 9} */
-```
-
-## mapReverseU
-
-```res sig
-let mapReverseU: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-Uncurried version of [mapReverse](#mapReverse).
-
-## forEach
-
-```res sig
-let forEach: (t<'a>, 'a => 'b) => unit
-```
-
-Call `f` on each element of `someList` from the beginning to end.
-`f` returns `unit`, so no new array is created. Use `forEach` when you are primarily concerned with repetitively creating side effects.
-
-```res example
-Belt.List.forEach(list{"a", "b", "c"}, x => Js.log("Item: " ++ x))
-/*
-  prints:
-  Item: a
-  Item: b
-  Item: c
-*/
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'a>, (. 'a) => 'b) => unit
-```
-
-Uncurried version of [forEach](#forEach).
-
-## forEachWithIndex
-
-```res sig
-let forEachWithIndex: (t<'a>, (int, 'a) => 'b) => unit
-```
-
-Call `f` on each element of `someList` from beginning to end.
-Function `f` takes two arguments: the index starting from 0 and the element from `someList`. `f` returns `unit`.
-
-```res example
-Belt.List.forEachWithIndex(list{"a", "b", "c"}, (index, x) => {
-  Js.log("Item " ++ Belt.Int.toString(index) ++ " is " ++ x)
-})
-/*
-  prints:
-  Item 0 is a
-  Item 1 is b
-  Item 2 is cc
-*/
-```
-
-## forEachWithIndexU
-
-```res sig
-let forEachWithIndexU: (t<'a>, (. int, 'a) => 'b) => unit
-```
-
-Uncurried version of [forEachWithIndex](#forEachWithIndex).
-
-## reduce
-
-```res sig
-let reduce: (t<'a>, 'b, ('b, 'a) => 'b) => 'b
-```
-
-Applies `f` to each element of `someList` from beginning to end. Function `f` has two parameters: the item from the list and an “accumulator”, which starts with a value of `initialValue`. reduce returns the final value of the accumulator.
-
-```res example
-list{1, 2, 3, 4}->Belt.List.reduce(0, (a, b) => a + b) /* 10 */
-
-/* same as */
-
-list{1, 2, 3, 4}->Belt.List.reduce(0, (acc, item) => acc + item) /* 10 */
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t<'a>, 'b, (. 'b, 'a) => 'b) => 'b
-```
-
-Uncurried version of [reduce](#reduce).
-
-## reduceWithIndex
-
-```res sig
-let reduceWithIndex: (t<'a>, 'b, ('b, 'a, int) => 'b) => 'b
-```
-
-Applies `f` to each element of `someList` from beginning to end. Function `f` has three parameters: the item from the list and an “accumulator”, which starts with a value of `initialValue` and the index of each element. `reduceWithIndex` returns the final value of the accumulator.
-
-```res example
-list{1, 2, 3, 4}->Belt.List.reduceWithIndex(0, (acc, item, index) => acc + item + index) /* 16 */
-```
-
-## reduceWithIndexU
-
-```res sig
-let reduceWithIndexU: (t<'a>, 'b, (. 'b, 'a, int) => 'b) => 'b
-```
-
-Uncurried version of [reduceWithIndex](#reduceWithIndex).
-
-## reduceReverse
-
-```res sig
-let reduceReverse: (t<'a>, 'b, ('b, 'a) => 'b) => 'b
-```
-
-Works like [reduce](#reduce), except that function `f` is applied to each item of `someList` from the last back to the first.
-
-```res example
-list{1, 2, 3, 4}->Belt.List.reduceReverse(0, (a, b) => a + b) /* 10 */
-
-list{1, 2, 3, 4}->Belt.List.reduceReverse(10, (a, b) => a - b) /* 0 */
-
-list{1, 2, 3, 4}->Belt.List.reduceReverse(list{}, Belt.List.add) // list{1, 2, 3, 4}
-```
-
-## reduceReverseU
-
-```res sig
-let reduceReverseU: (t<'a>, 'b, ('b, 'a) => 'b) => 'b
-```
-
-Uncurried version of [reduceReverse](#reduceReverse).
-
-## mapReverse2
-
-```res sig
-let mapReverse2: (t<'a>, t<'b>, ('a, 'b) => 'c) => t<'c>
-```
-
-Equivalent to: `zipBy(xs, ys, f)->reverse`
-
-```res example
-
-Belt.List.mapReverse2(list{1, 2, 3}, list{1, 2}, (a, b) => a + b) // list{4, 2}
-```
-## mapReverse2U
-
-```res sig
-let mapReverse2U: (t<'a>, t<'b>, ('a, 'b) => 'c) => t<'c>
-```
-
-Uncurried version of [mapReverse2](#mapReverse2).
-
-## forEach2
-
-```res sig
-let forEach2: (t<'a>, t<'b>, ('a, 'b) => 'c) => unit
-```
-
-Stops at the length of the shorter list.
-
-```res example
-Belt.List.forEach2(list{"Z", "Y"}, list{"A", "B", "C"}, (x, y) => Js.log2(x, y))
-
-/*
-  prints:
-  "Z" "A"
-  "Y" "B"
-*/
-```
-
-## forEach2U
-
-```res sig
-let forEach2U: (t<'a>, t<'b>, (.'a, 'b) => 'c) => unit
-```
-
-Uncurried version of [forEach2](#forEach2).
-
-## reduce2
-
-```res sig
-let reduce2: (t<'b>, t<'c>, 'a, ('a, 'b, 'c) => 'a) => 'a
-```
-
-Applies `f` to each element of `firstList` and `secondList` from beginning to end. Stops with the shorter list. Function `f` has three parameters: an “accumulator” which starts with a value of `initialValue`, an item from `firstList`, and an item from `secondList`. `reduce2` returns the final value of the accumulator.
-
-```res example
-Belt.List.reduce2(list{1, 2, 3}, list{4, 5}, 0, (acc, x, y) => acc + x * x + y) /* 0 + (1 * 1 + 4) + (2 * 2 + 5) */
-```
-
-## reduce2U
-
-```res sig
-let reduce2U: (t<'b>, t<'c>, 'a, (.'a, 'b, 'c) => 'a) => 'a
-```
-
-Uncurried version of [reduce2](#reduce2).
-
-## reduceReverse2
-
-```res sig
-let reduceReverse2: (t<'a>, t<'b>, 'c, ('c, 'a, 'b) => 'c) => 'c
-```
-
-Applies `f` to each element of `firstList` and `secondList` from end to beginning. Stops with the shorter list. Function `f` has three parameters: an “accumulator” which starts with a value of init, an item from `firstList`, and an item from `secondList`. `reduce2` returns the final value of the accumulator.
-
-```res example
-Belt.List.reduceReverse2(list{1, 2, 3}, list{4, 5}, 0, (acc, x, y) => acc + x * x + y) /*  + (1 * 1 + 4) + (2 * 2 + 5) */
-```
-
-## reduceReverse2U
-
-```res sig
-let reduceReverse2U: (t<'a>, t<'b>, 'c, (.'c, 'a, 'b) => 'c) => 'c
-```
-
-Uncurried version of [reduceReverse2](#reduceReverse2).
-
-## every
-
-```res sig
-let every: (t<'a>, 'a => bool) => bool
-```
-
-Returns `true` if all elements satisfy `pred`, where `pred` is a predicate: a function taking an element and returning a bool.
-
-```res example
-let isBelow10 = value => value < 10
-
-list{1, 9, 8, 2}->Belt.List.every(isBelow10) /* true */
-
-list{1, 99, 8, 2}->Belt.List.every(isBelow10) /* false */
-```
-
-## everyU
-
-```res sig
-let everyU: (t<'a>, (.'a) => bool) => bool
-```
-
-Uncurried version of [every](#every).
-
-## some
-
-```res sig
-let some: (t<'a>, 'a => bool) => bool
-```
-
-Returns `true` if at least _one_ of the elements in `someList` satisfies `pred`, where `pred` is a predicate: a function taking an element and returning a bool.
-
-```res example
-let isAbove100 = value => value > 100
-
-list{101, 1, 2, 3}->Belt.List.some(isAbove100) /* true */
-
-list{1, 2, 3, 4}->Belt.List.some(isAbove100) /* false */
-```
-
-## someU
-
-```res sig
-let someU: (t<'a>, (. 'a) => bool) => bool
-```
-
-Uncurried version of [some](#some).
-
-## every2
-
-```res sig
-let every2: (t<'a>, t<'b>, ('a, 'b) => bool) => bool
-```
-
-Returns `true` if predicate `pred(a, b)` is `true` for all pairs of elements up to the shorter length (i.e. `min(length(firstList), length(secondList))`)
-
-```res example
-Belt.List.every2(list{1, 2, 3}, list{0, 1}, (a, b) => a > b) /* true */
-
-Belt.List.every2(list{}, list{1}, (a, b) => a > b) /* true */
-
-Belt.List.every2(list{2, 3}, list{1}, (a, b) => a > b) /* true */
-
-Belt.List.every2(list{0, 1}, list{5, 0}, (a, b) => a > b) /* false */
-```
-
-## every2U
-
-```res sig
-let every2U: (t<'a>, t<'b>, (. 'a, 'b) => bool) => bool
-```
-
-Uncurried version of [every2](#every2).
-
-## some2
-
-```res sig
-let some2: (t<'a>, t<'b>, ('a, 'b) => bool) => bool
-```
-
-Returns `true` if predicate `pred(a, b)` is true for any pair of elements up to the shorter length (i.e. `min(length(firstList), length(secondList))`)
-
-```res example
-Belt.List.some2(list{1, 2, 3}, list{0, 1}, (a, b) => a > b) /* true */
-
-Belt.List.some2(list{}, list{1}, (a, b) => a > b) /* false */
-
-Belt.List.some2(list{2, 3}, list{1}, (a, b) => a > b) /* true */
-
-Belt.List.some2(list{0, 1}, list{5, 0}, (a, b) => a > b) /* true */
-```
-
-## some2U
-
-```res sig
-let some2U: (t<'a>, t<'b>, (. 'a, 'b) => bool) => bool
-```
-
-Uncurried version of [some2](#some2).
-
-## cmpByLength
-
-```res sig
-let cmpByLength: (t<'a>, t<'a>) => int
-```
-
-```res
-cmpByLength(firstList, secondList)
-```
-
-Compare two lists solely by length. Returns `-1` if `length(firstList)` is less than `length(secondList)`, `0` if `length(firstList)` equals `length(secondList)`, and `1` if `length(firstList)` is greater than `length(secondList)`.
-
-```res example
-Belt.List.cmpByLength(list{1, 2}, list{3, 4, 5, 6}) /* -1 */
-
-Belt.List.cmpByLength(list{1, 2, 3}, list{4, 5, 6}) /* = 0 */
-
-Belt.List.cmpByLength(list{1, 2, 3, 4}, list{5, 6}) /* = 1 */
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'a>, t<'a>, ('a, 'a) => int) => int
-```
-
-Compare elements one by one `compareFn(a, b)`. `compareFn` returns a negative number if `a` is "less than" `b`, zero if `a` is "equal to" `b`, a positive number if `a` is "greater than" `b`.
-
-The comparison returns the first non-zero result of `compareFn`, or zero if `compareFn` returns zero for all `a` and `b`.
-
-If all items have compared equal, but `firstList` is exhausted first, return `-1`. (`firstList` is shorter).
-If all items have compared equal, but `secondList` is exhausted first, return `1` (`firstList` is longer).
-
-```res example
-Belt.List.cmp(list{3}, list{3, 7}, (a, b) => compare(a, b)) /* (-1) */
-
-Belt.List.cmp(list{5, 3}, list{5}, (a, b) => compare(a, b)) /* 1 */
-
-Belt.List.cmp(list{1, 3, 5}, list{1, 4, 2}, (a, b) => compare(a, b)) /* (-1) */
-
-Belt.List.cmp(list{1, 3, 5}, list{1, 2, 3}, (a, b) => compare(a, b)) /* 1 */
-
-Belt.List.cmp(list{1, 3, 5}, list{1, 3, 5}, (a, b) => compare(a, b)) /* 0 */
-```
-
-**Please note:** The total ordering of List is different from Array,
-for Array, we compare the length first and, only if the lengths are equal, elements one by one.
-For lists, we just compare elements one by one.
-
-## cmpU
-
-```res sig
-let cmpU: (t<'a>, t<'a>, (. 'a, 'a) => int) => int
-```
-
-Uncurried version of [cmp](#cmp).
-
-## eq
-
-```res sig
-let eq: (t<'a>, t<'a>, ('a, 'a) => bool) => bool
-```
-
-Check equality of `firstList` and `secondList` using `eqElem` for equality on elements, where `eqElem` is a function that returns `true` if items `x` and `y` meet some criterion for equality, `false` otherwise. eq `false` if length of `firstList` and `secondList` are not the same.
-
-```res example
-Belt.List.eq(list{1, 2, 3}, list{1, 2}, (a, b) => a == b) /* false */
-
-Belt.List.eq(list{1, 2}, list{1, 2}, (a, b) => a == b) /* true */
-
-Belt.List.eq(list{1, 2, 3}, list{(-1), (-2), (-3)}, (a, b) => abs(a) == abs(b)) /* true */
-```
-
-## eqU
-
-```res sig
-let eqU: (t<'a>, t<'a>, (. 'a, 'a) => bool) => bool
-```
-
-Uncurried version of [eq](#eq).
-
-## has
-
-```res sig
-let has: (t<'a>, 'b, ('a, 'b) => bool) => bool
-```
-
-Returns `true` if the list contains at least one element for which `eqFunction(x)` returns true.
-
-```res example
-list{1, 2, 3}->Belt.List.has(2, (a, b) => a == b) /* true */
-
-list{1, 2, 3}->Belt.List.has(4, (a, b) => a == b) /* false */
-
-list{(-1), (-2), (-3)}->Belt.List.has(2, (a, b) => abs(a) == abs(b)) /* true */
-```
-
-## hasU
-
-```res sig
-let hasU: (t<'a>, 'b, (. 'a, 'b) => bool) => bool
-```
-
-Uncurried version of [has](#has).
-
-## getBy
-
-```res sig
-let getBy: (t<'a>, 'a => bool) => option<'a>
-```
-
-Returns `Some(value)` for the first value in `someList` that satisfies the predicate function `pred`. Returns `None` if no element satisfies the function.
-
-```res example
-Belt.List.getBy(list{1, 4, 3, 2}, x => x > 3) /* Some(4) */
-
-Belt.List.getBy(list{1, 4, 3, 2}, x => x > 4) /* None */
-```
-
-## getByU
-
-```res sig
-let getByU: (t<'a>, (. 'a) => bool) => option<'a>
-```
-
-Uncurried version of [getBy](#getBy).
-
-## keep
-
-```res sig
-let keep: (t<'a>, 'a => bool) => t<'a>
-```
-
-Returns a list of all elements in `someList` which satisfy the predicate function `pred`.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-Belt.List.keep(list{1, 2, 3, 4}, isEven) /* list{2, 4} */
-
-Belt.List.keep(list{None, Some(2), Some(3), None}, Belt.Option.isSome) /* list{Some(2), Some(3)} */
-```
-
-## keepU
-
-```res sig
-let keepU: (t<'a>, (. 'a) => bool) => t<'a>
-```
-
-Uncurried version of [keep](#keep).
-
-## filter
-
-```res sig
-let filter: (t<'a>, 'a => bool) => t<'a>
-```
-
-Returns a list of all elements in `someList` which satisfy the predicate function `pred`.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-Belt.List.filter(list{1, 2, 3, 4}, isEven) /* list{2, 4} */
-
-Belt.List.filter(list{None, Some(2), Some(3), None}, Belt.Option.isSome) /* list{Some(2), Some(3)} */
-```
-
-## keepWithIndex
-
-```res sig
-let keepWithIndex: (t<'a>, ('a, int) => bool) => t<'a>
-```
-
-Returns a list of all elements in `someList` which satisfy the predicate function `pred`.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-Belt.List.keepWithIndex(list{1, 2, 3, 4}, (_x, index) => isEven(index)) /* list{1, 3} */
-```
-
-## keepWithIndexU
-
-```res sig
-let keepWithIndexU: (t<'a>, (. 'a, int) => bool) => t<'a>
-```
-
-Uncurried version of [keepWithIndex](#keepWithIndex).
-
-## filterWithIndex
-
-```res sig
-let filterWithIndex: (t<'a>, ('a, int) => bool) => t<'a>
-```
-
-Returns a list of all elements in `someList` which satisfy the predicate function `pred`.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-Belt.List.filterWithIndex(list{1, 2, 3, 4}, (_x, index) => isEven(index)) /* list{1, 3} */
-```
-
-## keepMap
-
-```res sig
-let keepMap: (t<'a>, 'a => option<'b>) => t<'b>
-```
-
-Applies `f` to each element of `someList`. If `f(x)` returns `Some(value)`, then `value` is _kept_ in the resulting list.
-If `f(x)` returns `None`, the element is _not_ retained in the result.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-list{1, 2, 3, 4}
-->Belt.List.keepMap(x =>
-    if (isEven(x)) {
-      Some(x)
-    } else {
-      None
-    }
-  ) /* list{2, 4} */
-
-list{Some(1), Some(2), None}->Belt.List.keepMap(x => x) /* list{1, 2} */
-```
-
-## keepMapU
-
-```res sig
-let keepMapU: (t<'a>, (. 'a) => option<'b>) => t<'b>
-```
-
-Uncurried version of [keepMap](#keepMap).
-
-## partition
-
-```res sig
-let partition: (t<'a>, 'a => bool) => (t<'a>, t<'a>)
-```
-
-Creates a pair of lists; the first list consists of all elements of `someList` that satisfy the predicate function `pred`; the second list consists of all elements of `someList` that _do not_ satisfy `pred.
-
-In other words:
-
-```res
-(elementsThatSatisfies, elementsThatDoesNotSatisfy)
-```
-
-```res example
-Belt.List.partition(list{1, 2, 3, 4}, x => x > 2) /* (list{3, 4}, list{1, 2}) */
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t<'a>, (. 'a) => bool) => (t<'a>, t<'a>)
-```
-
-Uncurried version of [partition](#partition).
-
-## unzip
-
-```res sig
-let unzip: t<('a, 'b)> => (t<'a>, t<'b>)
-```
-
-Takes a list of pairs and creates a pair of lists. The first list contains all the first items of the pairs; the second list contains all the second items.
-
-```res example
-Belt.List.unzip(list{(1, 2), (3, 4)}) /* (list{1, 3}, list{2, 4}) */
-
-Belt.List.unzip(list{("H", "W"), ("e", "o"), ("l", "r"), ("l", "l"), ("o", "d"), (" ", "!")})
-/* (list{"H", "e", "l", "l", "o", " "}, list{"W", "o", "r", "l", "d", "!"}) */
-```
-
-## getAssoc
-
-```res sig
-let getAssoc: (t<('a, 'c)>, 'b, ('a, 'b) => bool) => option<'c>
-```
-
-Return the second element of a pair in `someList` where the first element equals `k` as per the predicate function `eqFunction`, or `None` if not found.
-
-```res example
-list{(1, "a"), (2, "b"), (3, "c")}->Belt.List.getAssoc(3, (a, b) => a == b) /* Some("c") */
-
-list{(9, "morning"), (15, "afternoon"), (22, "night")}
-->Belt.List.getAssoc(15, (k, item) => k /* 15 */ == item /* 9, 5, 22 */)
-/* Some("afternoon") */
-```
-
-## getAssocU
-
-```res sig
-let getAssocU: (t<('a, 'c)>, 'b, (. 'a, 'b) => bool) => option<'c>
-```
-
-Uncurried version of [getAssoc](#getAssoc).
-
-## hasAssoc
-
-```res sig
-let hasAssoc: (t<('a, 'c)>, 'b, ('a, 'b) => bool) => bool
-```
-
-Returns `true` if there is a pair in `someList` where the first element equals `k` as per the predicate function `eqFunction`.
-
-```res example
-list{(1, "a"), (2, "b"), (3, "c")}->Belt.List.hasAssoc(1, (a, b) => a == b) /* true */
-
-list{(9, "morning"), (15, "afternoon"), (22, "night")}
-->Belt.List.hasAssoc(25, (k, item) => k /* 25 */ == item /* 9, 5, 22 */) /* false */
-```
-
-## hasAssocU
-
-```res sig
-let hasAssocU: (t<('a, 'c)>, 'b, (. 'a, 'b) => bool) => bool
-```
-
-Uncurried version of [hasAssoc](#hasAssoc).
-
-## removeAssoc
-
-```res sig
-let removeAssoc: (t<('a, 'c)>, 'b, ('a, 'b) => bool) => t<('a, 'c)>
-```
-
-Return a list after removing the first pair whose first value is `k` per the equality predicate `eqFunction`; if not found, return a new list identical to `someList`.
-
-```res example
-list{(1, "a"), (2, "b"), (3, "c")}->Belt.List.removeAssoc(1, (a, b) => a == b) /* list{(2, "b"), (3, "c")} */
-
-list{(9, "morning"), (15, "afternoon"), (22, "night")}
-->Belt.List.removeAssoc(9, (k, item) => k /* 9 */ == item /* 9, 5, 22 */)
-/* list{(15, "afternoon"), (22, "night")} */
-```
-
-## removeAssocU
-
-```res sig
-let removeAssocU: (t<('a, 'c)>, 'b, (. 'a, 'b) => bool) => t<('a, 'c)>
-```
-
-Uncurried version of [removeAssoc](#removeAssoc).
-
-## setAssoc
-
-```res sig
-let setAssoc: (t<('a, 'c)>, 'a, 'c, ('a, 'a) => bool) => t<('a, 'c)>
-```
-
-If `k` exists in `someList` by satisfying the `eqFunction` predicate, return a new list with the key and value replaced by the new `k` and `v`; otherwise, return a new list with the pair `k`, `v` added to the head of `someList`.
-
-```res example
-list{(1, "a"), (2, "b"), (3, "c")}->Belt.List.setAssoc(2, "x", (a, b) => a == b) /* list{(1, "a"), (2, "x"), (3, "c")} */
-
-list{(1, "a"), (3, "c")}->Belt.List.setAssoc(2, "b", (a, b) => a == b) /* list{(2, "b"), (1, "a"), (3, "c")} */
-
-list{(9, "morning"), (3, "morning?!"), (22, "night")}
-->Belt.List.setAssoc(15, "afternoon", (a, b) => mod(a, 12) == mod(b, 12))
-/* list{(9, "morning"), (15, "afternoon"), (22, "night")} */
-```
-
-**Please note**
-
-In the last example, since: `15 mod 12` equals `3 mod 12`
-
-Both the key _and_ the value are replaced in the list.
-
-## setAssocU
-
-```res sig
-let setAssocU: (t<('a, 'c)>, 'a, 'c, (. 'a, 'a) => bool) => t<('a, 'c)>
-```
-
-Uncurried version of [setAssoc](#setAssoc).
-
-## sort
-
-```res sig
-let sort: (t<'a>, ('a, 'a) => int) => t<'a>
-```
-
-Returns a sorted list.
-
-```res example
-Belt.List.sort(list{5, 4, 9, 3, 7}, (a, b) => a - b) // list{3, 4, 5, 7, 9}
-```
-
-## sortU
-
-```res sig
-let sortU: (t<'a>, (. 'a, 'a) => int) => t<'a>
-```
-
-Uncurried version of [sort](#sort).
diff --git a/pages/docs/manual/v10.0.0/api/belt/map-dict.mdx b/pages/docs/manual/v10.0.0/api/belt/map-dict.mdx
deleted file mode 100644
index 4a9828f50..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/map-dict.mdx
+++ /dev/null
@@ -1,397 +0,0 @@
-# MapDict
-
-<Intro>
-
-This module separates identity from data, it is a bit more verbose but slightly more efficient due to the fact that there is no need to pack identity and data back after each operation
-
-**_Advanced usage only_**
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'key, 'value, 'id>
-```
-
-## cmp
-
-```res prelude
-type cmp<'key, 'id> = Belt_Id.cmp<'key, 'id>
-```
-
-## empty
-
-```res sig
-let empty: t<'k, 'v, 'id>
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'k, 'v, 'id> => bool
-```
-
-## has
-
-```res sig
-let has: (t<'k, 'a, 'id>, 'k, ~cmp: cmp<'k, 'id>) => bool
-```
-
-## cmpU
-
-```res sig
-let cmpU: (t<'k, 'v, 'id>, t<'k, 'v, 'id>, ~kcmp: cmp<'k, 'id>, ~vcmp: (. 'v, 'v) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'k, 'v, 'id>, t<'k, 'v, 'id>, ~kcmp: cmp<'k, 'id>, ~vcmp: ('v, 'v) => int) => int
-```
-
-## eqU
-
-```res sig
-let eqU: (t<'k, 'a, 'id>, t<'k, 'a, 'id>, ~kcmp: cmp<'k, 'id>, ~veq: (. 'a, 'a) => bool) => bool
-```
-
-## eq
-
-```res sig
-let eq: (t<'k, 'a, 'id>, t<'k, 'a, 'id>, ~kcmp: cmp<'k, 'id>, ~veq: ('a, 'a) => bool) => bool
-```
-
-`eq(m1, m2, cmp)` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data. `cmp` is the equality predicate used to compare the data associated with the keys.
-
-## findFirstByU
-
-```res sig
-let findFirstByU: (t<'k, 'v, 'id>, (. 'k, 'v) => bool) => option<('k, 'v)>
-```
-
-## findFirstBy
-
-```res sig
-let findFirstBy: (t<'k, 'v, 'id>, ('k, 'v) => bool) => option<('k, 'v)>
-```
-
-`findFirstBy(m, p)` uses function `f` to find the first key value pair to match predicate `p`.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Map.Dict.fromArray([(4, "4"), (1, "1"), (2, "2"), (3, "3")], ~cmp=IntCmp.cmp)
-
-Belt.Map.Dict.findFirstBy(s0, (k, _) => k == 4) == Some((4, "4"))
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'k, 'a, 'id>, (. 'k, 'a) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'k, 'a, 'id>, ('k, 'a) => unit) => unit
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the key as first argument, and the associated value as second argument. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## reduceU
-
-```res sig
-let reduceU: (t<'k, 'a, 'id>, 'b, (. 'b, 'k, 'a) => 'b) => 'b
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'k, 'a, 'id>, 'b, ('b, 'k, 'a) => 'b) => 'b
-```
-
-`reduce(m, a, f)` computes `f(kN, dN ... f(k1, d1, a)...)`, where `k1 ... kN` are the keys of all bindings in `m` (in increasing order), and `d1 ... dN` are the associated data.
-
-## everyU
-
-```res sig
-let everyU: (t<'k, 'a, 'id>, (. 'k, 'a) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'k, 'a, 'id>, ('k, 'a) => bool) => bool
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. Order unspecified
-
-## someU
-
-```res sig
-let someU: (t<'k, 'a, 'id>, (. 'k, 'a) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'k, 'a, 'id>, ('k, 'a) => bool) => bool
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. Order unspecified
-
-## size
-
-```res sig
-let size: t<'k, 'a, 'id> => int
-```
-
-## toList
-
-```res sig
-let toList: t<'k, 'a, 'id> => list<('k, 'a)>
-```
-
-In increasing order.
-
-## toArray
-
-```res sig
-let toArray: t<'k, 'a, 'id> => array<('k, 'a)>
-```
-
-## fromArray
-
-```res sig
-let fromArray: (array<('k, 'a)>, ~cmp: cmp<'k, 'id>) => t<'k, 'a, 'id>
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'k, 'a, 'id> => array<'k>
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'k, 'a, 'id> => array<'a>
-```
-
-## minKey
-
-```res sig
-let minKey: t<'k, 'a, 'b> => option<'k>
-```
-
-## minKeyUndefined
-
-```res sig
-let minKeyUndefined: t<'k, 'a, 'b> => Js.undefined<'k>
-```
-
-## maxKey
-
-```res sig
-let maxKey: t<'k, 'a, 'b> => option<'k>
-```
-
-## maxKeyUndefined
-
-```res sig
-let maxKeyUndefined: t<'k, 'a, 'b> => Js.undefined<'k>
-```
-
-## minimum
-
-```res sig
-let minimum: t<'k, 'a, 'b> => option<('k, 'a)>
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'k, 'a, 'b> => Js.undefined<('k, 'a)>
-```
-
-## maximum
-
-```res sig
-let maximum: t<'k, 'a, 'b> => option<('k, 'a)>
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'k, 'a, 'b> => Js.undefined<('k, 'a)>
-```
-
-## get
-
-```res sig
-let get: (t<'k, 'a, 'id>, 'k, ~cmp: cmp<'k, 'id>) => option<'a>
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'k, 'a, 'id>, 'k, ~cmp: cmp<'k, 'id>) => Js.undefined<'a>
-```
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (t<'k, 'a, 'id>, 'k, 'a, ~cmp: cmp<'k, 'id>) => 'a
-```
-
-## getExn
-
-```res sig
-let getExn: (t<'k, 'a, 'id>, 'k, ~cmp: cmp<'k, 'id>) => 'a
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t<'a, 'b, 'c> => unit
-```
-
-## remove
-
-```res sig
-let remove: (t<'a, 'b, 'id>, 'a, ~cmp: cmp<'a, 'id>) => t<'a, 'b, 'id>
-```
-
-`remove(m, x)` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
-
-## removeMany
-
-```res sig
-let removeMany: (t<'a, 'b, 'id>, array<'a>, ~cmp: cmp<'a, 'id>) => t<'a, 'b, 'id>
-```
-
-## set
-
-```res sig
-let set: (t<'a, 'b, 'id>, 'a, 'b, ~cmp: cmp<'a, 'id>) => t<'a, 'b, 'id>
-```
-
-`set(m, x, y)` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`. If `x` was already bound in `m`, its previous binding disappears.
-
-## updateU
-
-```res sig
-let updateU: (
-  t<'a, 'b, 'id>,
-  'a,
-  (. option<'b>) => option<'b>,
-  ~cmp: cmp<'a, 'id>,
-) => t<'a, 'b, 'id>
-```
-
-## update
-
-```res sig
-let update: (t<'a, 'b, 'id>, 'a, option<'b> => option<'b>, ~cmp: cmp<'a, 'id>) => t<'a, 'b, 'id>
-```
-
-## mergeU
-
-```res sig
-let mergeU: (
-  t<'a, 'b, 'id>,
-  t<'a, 'c, 'id>,
-  (. 'a, option<'b>, option<'c>) => option<'d>,
-  ~cmp: cmp<'a, 'id>,
-) => t<'a, 'd, 'id>
-```
-
-## merge
-
-```res sig
-let merge: (
-  t<'a, 'b, 'id>,
-  t<'a, 'c, 'id>,
-  ('a, option<'b>, option<'c>) => option<'d>,
-  ~cmp: cmp<'a, 'id>,
-) => t<'a, 'd, 'id>
-```
-
-`merge(m1, m2, f)` computes a map whose keys is a subset of keys of `m1` and of `m2`. The presence of each such binding, and the corresponding value, is determined with the function `f`.
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'a, 'b, 'id>, array<('a, 'b)>, ~cmp: cmp<'a, 'id>) => t<'a, 'b, 'id>
-```
-
-## keepU
-
-```res sig
-let keepU: (t<'k, 'a, 'id>, (. 'k, 'a) => bool) => t<'k, 'a, 'id>
-```
-
-## keep
-
-```res sig
-let keep: (t<'k, 'a, 'id>, ('k, 'a) => bool) => t<'k, 'a, 'id>
-```
-
-`keep(m, p)` returns the map with all the bindings in `m` that satisfy predicate `p`.
-
-## partitionU
-
-```res sig
-let partitionU: (t<'k, 'a, 'id>, (. 'k, 'a) => bool) => (t<'k, 'a, 'id>, t<'k, 'a, 'id>)
-```
-
-## partition
-
-```res sig
-let partition: (t<'k, 'a, 'id>, ('k, 'a) => bool) => (t<'k, 'a, 'id>, t<'k, 'a, 'id>)
-```
-
-`partition(m, p)` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `s` that satisfy the predicate `p`, and `m2` is the map with all the bindings of `s` that do not satisfy `p`.
-
-## split
-
-```res sig
-let split: (
-  t<'a, 'b, 'id>,
-  'a,
-  ~cmp: cmp<'a, 'id>,
-) => ((t<'a, 'b, 'id>, t<'a, 'b, 'id>), option<'b>)
-```
-
-`split(x, m)` returns a triple `(l, data, r)`, where `l` is the map with all the bindings of `m` whose key is strictly less than `x`; `r` is the map with all the bindings of `m` whose key is strictly greater than `x`; `data` is `None` if `m` contains no binding for `x`, or `Some(v)` if `m` binds `v` to `x`.
-
-## mapU
-
-```res sig
-let mapU: (t<'k, 'a, 'id>, (. 'a) => 'b) => t<'k, 'b, 'id>
-```
-
-## map
-
-```res sig
-let map: (t<'k, 'a, 'id>, 'a => 'b) => t<'k, 'b, 'id>
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value `a` of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```res sig
-let mapWithKeyU: (t<'k, 'a, 'id>, (. 'k, 'a) => 'b) => t<'k, 'b, 'id>
-```
-
-## mapWithKey
-
-```res sig
-let mapWithKey: (t<'k, 'a, 'id>, ('k, 'a) => 'b) => t<'k, 'b, 'id>
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/map-int.mdx b/pages/docs/manual/v10.0.0/api/belt/map-int.mdx
deleted file mode 100644
index 0c63212e7..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/map-int.mdx
+++ /dev/null
@@ -1,373 +0,0 @@
-# MapInt
-
-<Intro>
-
-Specialized when key type is `int`, more efficient than the generic type, its compare behavior is fixed using the built-in comparison
-
-</Intro>
-
-## key
-
-```res prelude
-type key = int
-```
-
-## t
-
-```res prelude
-type t<'value>
-```
-
-The type of maps from type `key` to type `'value`.
-
-## empty
-
-```res sig
-let empty: t<'v>
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'v> => bool
-```
-
-## has
-
-```res sig
-let has: (t<'v>, key) => bool
-```
-
-## cmpU
-
-```res sig
-let cmpU: (t<'v>, t<'v>, (. 'v, 'v) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'v>, t<'v>, ('v, 'v) => int) => int
-```
-
-## eqU
-
-```res sig
-let eqU: (t<'v>, t<'v>, (. 'v, 'v) => bool) => bool
-```
-
-## eq
-
-```res sig
-let eq: (t<'v>, t<'v>, ('v, 'v) => bool) => bool
-```
-
-`eq(m1,m2)` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data.
-
-## findFirstByU
-
-```res sig
-let findFirstByU: (t<'v>, (. key, 'v) => bool) => option<(key, 'v)>
-```
-
-## findFirstBy
-
-```res sig
-let findFirstBy: (t<'v>, (key, 'v) => bool) => option<(key, 'v)>
-```
-
-`findFirstBy(m, p)` uses function `f` to find the first key value pair to match predicate `p`.
-
-```res example
-let s0 = Belt.Map.Int.fromArray([(4, "4"), (1, "1"), (2, "2"), (3, "3")])
-
-Belt.Map.Int.findFirstBy(s0, (k, v) => k == 4) == Some((4, "4"))
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'v>, (. key, 'v) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'v>, (key, 'v) => unit) => unit
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the key as first argument, and the associated value as second argument. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## reduceU
-
-```res sig
-let reduceU: (t<'v>, 'v2, (. 'v2, key, 'v) => 'v2) => 'v2
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'v>, 'v2, ('v2, key, 'v) => 'v2) => 'v2
-```
-
-`reduce(m, a, f)` computes `f(kN, dN, ... f(k1, d1, a)...)`, where `k1 ... kN` are the keys of all bindings in `m` (in increasing order), and `d1 ... dN` are the associated data.
-
-## everyU
-
-```res sig
-let everyU: (t<'v>, (. key, 'v) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'v>, (key, 'v) => bool) => bool
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. Order unspecified
-
-## someU
-
-```res sig
-let someU: (t<'v>, (. key, 'v) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'v>, (key, 'v) => bool) => bool
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. Order unspecified
-
-## size
-
-```res sig
-let size: t<'v> => int
-```
-
-## toList
-
-```res sig
-let toList: t<'v> => list<(key, 'v)>
-```
-
-In increasing order.
-
-## toArray
-
-```res sig
-let toArray: t<'v> => array<(key, 'v)>
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<(key, 'v)> => t<'v>
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'v> => array<key>
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'v> => array<'v>
-```
-
-## minKey
-
-```res sig
-let minKey: t<'a> => option<key>
-```
-
-## minKeyUndefined
-
-```res sig
-let minKeyUndefined: t<'a> => Js.undefined<key>
-```
-
-## maxKey
-
-```res sig
-let maxKey: t<'a> => option<key>
-```
-
-## maxKeyUndefined
-
-```res sig
-let maxKeyUndefined: t<'a> => Js.undefined<key>
-```
-
-## minimum
-
-```res sig
-let minimum: t<'v> => option<(key, 'v)>
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'v> => Js.undefined<(key, 'v)>
-```
-
-## maximum
-
-```res sig
-let maximum: t<'v> => option<(key, 'v)>
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'v> => Js.undefined<(key, 'v)>
-```
-
-## get
-
-```res sig
-let get: (t<'v>, key) => option<'v>
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'v>, key) => Js.undefined<'v>
-```
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (t<'v>, key, 'v) => 'v
-```
-
-## getExn
-
-```res sig
-let getExn: (t<'v>, key) => 'v
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t<'a> => unit
-```
-
-**raise** when invariant is not held
-
-## remove
-
-```res sig
-let remove: (t<'v>, key) => t<'v>
-```
-
-`remove(m, x)` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
-
-## removeMany
-
-```res sig
-let removeMany: (t<'v>, array<key>) => t<'v>
-```
-
-## set
-
-```res sig
-let set: (t<'v>, key, 'v) => t<'v>
-```
-
-`set(m, x, y)` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`. If `x` was already bound in `m`, its previous binding disappears.
-
-## updateU
-
-```res sig
-let updateU: (t<'v>, key, (. option<'v>) => option<'v>) => t<'v>
-```
-
-## update
-
-```res sig
-let update: (t<'v>, key, option<'v> => option<'v>) => t<'v>
-```
-
-## mergeU
-
-```res sig
-let mergeU: (t<'v>, t<'v2>, (. key, option<'v>, option<'v2>) => option<'c>) => t<'c>
-```
-
-## merge
-
-```res sig
-let merge: (t<'v>, t<'v2>, (key, option<'v>, option<'v2>) => option<'c>) => t<'c>
-```
-
-`merge(m1, m2, f)` computes a map whose keys is a subset of keys of `m1` and of `m2`. The presence of each such binding, and the corresponding value, is determined with the function `f`.
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'v>, array<(key, 'v)>) => t<'v>
-```
-
-## keepU
-
-```res sig
-let keepU: (t<'v>, (. key, 'v) => bool) => t<'v>
-```
-
-## keep
-
-```res sig
-let keep: (t<'v>, (key, 'v) => bool) => t<'v>
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t<'v>, (. key, 'v) => bool) => (t<'v>, t<'v>)
-```
-
-## partition
-
-```res sig
-let partition: (t<'v>, (key, 'v) => bool) => (t<'v>, t<'v>)
-```
-
-`partition(m, p)` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `s` that satisfy the predicate `p`, and `m2` is the map with all the bindings of `s` that do not satisfy `p`.
-
-## split
-
-```res sig
-let split: (key, t<'v>) => (t<'v>, option<'v>, t<'v>)
-```
-
-`split(x, m)` returns a triple `(l, data, r)`, where `l` is the map with all the bindings of `m` whose key is strictly less than `x`; `r` is the map with all the bindings of `m` whose key is strictly greater than `x`; `data` is `None` if m contains no binding for `x`, or `Some(v)` if `m` binds `v` to `x`.
-
-## mapU
-
-```res sig
-let mapU: (t<'v>, (. 'v) => 'v2) => t<'v2>
-```
-
-## map
-
-```res sig
-let map: (t<'v>, 'v => 'v2) => t<'v2>
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value `a` of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```res sig
-let mapWithKeyU: (t<'v>, (. key, 'v) => 'v2) => t<'v2>
-```
-
-## mapWithKey
-
-```res sig
-let mapWithKey: (t<'v>, (key, 'v) => 'v2) => t<'v2>
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/map-string.mdx b/pages/docs/manual/v10.0.0/api/belt/map-string.mdx
deleted file mode 100644
index c74b488a3..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/map-string.mdx
+++ /dev/null
@@ -1,375 +0,0 @@
-# Map.String
-
-<Intro>
-
-Specialized when key type is `string`, more efficient than the generic type, its compare behavior is fixed using the built-in comparison
-
-</Intro>
-
-## key
-
-```res prelude
-type key = string
-```
-
-## t
-
-```res prelude
-type t<'value>
-```
-
-The type of maps from type `key` to type `'value`.
-
-## empty
-
-```res sig
-let empty: t<'v>
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'v> => bool
-```
-
-## has
-
-```res sig
-let has: (t<'v>, key) => bool
-```
-
-## cmpU
-
-```res sig
-let cmpU: (t<'v>, t<'v>, (. 'v, 'v) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'v>, t<'v>, ('v, 'v) => int) => int
-```
-
-## eqU
-
-```res sig
-let eqU: (t<'v>, t<'v>, (. 'v, 'v) => bool) => bool
-```
-
-## eq
-
-```res sig
-let eq: (t<'v>, t<'v>, ('v, 'v) => bool) => bool
-```
-
-`eq(m1, m2)` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data.
-
-## findFirstByU
-
-```res sig
-let findFirstByU: (t<'v>, (. key, 'v) => bool) => option<(key, 'v)>
-```
-
-## findFirstBy
-
-```res sig
-let findFirstBy: (t<'v>, (key, 'v) => bool) => option<(key, 'v)>
-```
-
-`findFirstBy(m, p)` uses function `f` to find the first key value pair to match predicate `p`.
-
-```res example
-let s0 = Belt.Map.String.fromArray([("4", 4), ("1", 1), ("2", 2), ("3", 3)])
-
-Belt.Map.String.findFirstBy(s0, (k, _) => k == "4") == Some(("4", 4))
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'v>, (. key, 'v) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'v>, (key, 'v) => unit) => unit
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the key as first argument, and the associated value as second argument. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## reduceU
-
-```res sig
-let reduceU: (t<'v>, 'v2, (. 'v2, key, 'v) => 'v2) => 'v2
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'v>, 'v2, ('v2, key, 'v) => 'v2) => 'v2
-```
-
-`reduce(m, a, f)` computes `f(kN, dN ... f(k1, d1, a)...), where k1 ... kN)` are the keys of all bindings in `m` (in increasing order), and `d1 ... dN` are the associated data.
-
-## everyU
-
-```res sig
-let everyU: (t<'v>, (. key, 'v) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'v>, (key, 'v) => bool) => bool
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. Order unspecified
-
-## someU
-
-```res sig
-let someU: (t<'v>, (. key, 'v) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'v>, (key, 'v) => bool) => bool
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. Order unspecified
-
-## size
-
-```res sig
-let size: t<'v> => int
-```
-
-## toList
-
-```res sig
-let toList: t<'v> => list<(key, 'v)>
-```
-
-In increasing order.
-
-## toArray
-
-```res sig
-let toArray: t<'v> => array<(key, 'v)>
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<(key, 'v)> => t<'v>
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'v> => array<key>
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'v> => array<'v>
-```
-
-## minKey
-
-```res sig
-let minKey: t<'a> => option<key>
-```
-
-## minKeyUndefined
-
-```res sig
-let minKeyUndefined: t<'a> => Js.undefined<key>
-```
-
-## maxKey
-
-```res sig
-let maxKey: t<'a> => option<key>
-```
-
-## maxKeyUndefined
-
-```res sig
-let maxKeyUndefined: t<'a> => Js.undefined<key>
-```
-
-## minimum
-
-```res sig
-let minimum: t<'v> => option<(key, 'v)>
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'v> => Js.undefined<(key, 'v)>
-```
-
-## maximum
-
-```res sig
-let maximum: t<'v> => option<(key, 'v)>
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'v> => Js.undefined<(key, 'v)>
-```
-
-## get
-
-```res sig
-let get: (t<'v>, key) => option<'v>
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'v>, key) => Js.undefined<'v>
-```
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (t<'v>, key, 'v) => 'v
-```
-
-## getExn
-
-```res sig
-let getExn: (t<'v>, key) => 'v
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t<'a> => unit
-```
-
-**raise** when invariant is not held
-
-## remove
-
-```res sig
-let remove: (t<'v>, key) => t<'v>
-```
-
-`remove(m, x)` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
-
-## removeMany
-
-```res sig
-let removeMany: (t<'v>, array<key>) => t<'v>
-```
-
-## set
-
-```res sig
-let set: (t<'v>, key, 'v) => t<'v>
-```
-
-`set(m, x, y)` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`. If `x` was already bound in `m`, its previous binding disappears.
-
-## updateU
-
-```res sig
-let updateU: (t<'v>, key, (. option<'v>) => option<'v>) => t<'v>
-```
-
-## update
-
-```res sig
-let update: (t<'v>, key, option<'v> => option<'v>) => t<'v>
-```
-
-## mergeU
-
-```res sig
-let mergeU: (t<'v>, t<'v2>, (. key, option<'v>, option<'v2>) => option<'c>) => t<'c>
-```
-
-## merge
-
-```res sig
-let merge: (t<'v>, t<'v2>, (key, option<'v>, option<'v2>) => option<'c>) => t<'c>
-```
-
-`merge(m1, m2, f)` computes a map whose keys is a subset of keys of `m1` and of `m2`. The presence of each such binding, and the corresponding value, is determined with the function `f`.
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'v>, array<(key, 'v)>) => t<'v>
-```
-
-## keepU
-
-```res sig
-let keepU: (t<'v>, (. key, 'v) => bool) => t<'v>
-```
-
-## keep
-
-```res sig
-let keep: (t<'v>, (key, 'v) => bool) => t<'v>
-```
-
-`keep(m, p)` returns the map with all the bindings in `m` that satisfy predicate `p`.
-
-## partitionU
-
-```res sig
-let partitionU: (t<'v>, (. key, 'v) => bool) => (t<'v>, t<'v>)
-```
-
-## partition
-
-```res sig
-let partition: (t<'v>, (key, 'v) => bool) => (t<'v>, t<'v>)
-```
-
-`partition(m, p)` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `s` that satisfy the predicate `p`, and `m2` is the map with all the bindings of s that do not satisfy `p`.
-
-## split
-
-```res sig
-let split: (key, t<'v>) => (t<'v>, option<'v>, t<'v>)
-```
-
-`split(x, m)` returns a triple `(l, data, r)`, where `l` is the map with all the bindings of `m` whose key is strictly less than `x`; `r` is the map with all the bindings of m whose key is strictly greater than `x`; `data` is `None` if `m` contains no binding for `x`, or `Some(v)` if `m` binds `v` to `x`.
-
-## mapU
-
-```res sig
-let mapU: (t<'v>, (. 'v) => 'v2) => t<'v2>
-```
-
-## map
-
-```res sig
-let map: (t<'v>, 'v => 'v2) => t<'v2>
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value `a` of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```res sig
-let mapWithKeyU: (t<'v>, (. key, 'v) => 'v2) => t<'v2>
-```
-
-## mapWithKey
-
-```res sig
-let mapWithKey: (t<'v>, (key, 'v) => 'v2) => t<'v2>
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/map.mdx b/pages/docs/manual/v10.0.0/api/belt/map.mdx
deleted file mode 100644
index ba31ca263..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/map.mdx
+++ /dev/null
@@ -1,649 +0,0 @@
-# Map
-
-The top level provides generic immutable map operations.
-
-It also has three specialized inner modules `Belt.Map.Int`, `Belt.Map.String` and `Belt.Map.Dict`.
-
-## t
-
-```res prelude
-type t<'key, 'value, 'identity>
-```
-
-`'key` is the field type
-
-`'value` is the element type
-
-`'identity` the identity of the collection
-
-## id
-
-```res prelude
-type id<'key, 'id> = Belt_Id.comparable<'key, 'id>
-```
-
-The identity needed for making an empty map.
-
-## make
-
-```res sig
-let make: (~id: id<'k, 'id>) => t<'k, 'v, 'id>
-```
-
-`make(~id)` creates a new map by taking in the comparator.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-let m = Belt.Map.make(~id=module(IntCmp))
-
-Belt.Map.set(m, 0, "a")
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a, 'b, 'c> => bool
-```
-
-`isEmpty(m)` checks whether a map m is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-Belt.Map.isEmpty(Belt.Map.fromArray([(1, "1")], ~id=module(IntCmp))) == false
-```
-
-## has
-
-```res sig
-let has: (t<'k, 'v, 'id>, 'k) => bool
-```
-
-`has(m, k)` checks whether `m` has the key `k`.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-Belt.Map.has(Belt.Map.fromArray([(1, "1")], ~id=module(IntCmp)), 1) == true
-```
-
-## cmpU
-
-```res sig
-let cmpU: (t<'k, 'v, 'id>, t<'k, 'v, 'id>, (. 'v, 'v) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'k, 'v, 'id>, t<'k, 'v, 'id>, ('v, 'v) => int) => int
-```
-
-`cmp(m0, m1, vcmp);`
-
-Total ordering of map given total ordering of value function.
-
-It will compare size first and each element following the order one by one.
-
-## eq
-
-```res sig
-let eqU: (t<'k, 'v, 'id>, t<'k, 'v, 'id>, (. 'v, 'v) => bool) => bool
-```
-
-`eq(m1, m2, veq)` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data. `veq` is the equality predicate used to compare the data associated with the keys.
-
-## eq
-
-```res sig
-let eq: (t<'k, 'v, 'id>, t<'k, 'v, 'id>, ('v, 'v) => bool) => bool
-```
-
-## findFirstByU
-
-```res sig
-let findFirstByU: (t<'k, 'v, 'id>, (. 'k, 'v) => bool) => option<('k, 'v)>
-```
-
-## findFirstBy
-
-```res sig
-let findFirstBy: (t<'k, 'v, 'id>, ('k, 'v) => bool) => option<('k, 'v)>
-```
-
-`findFirstBy(m, p)` uses function `f` to find the first key value pair to match predicate `p`.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-let s0 = Belt.Map.fromArray(~id=module(IntCmp), [(4, "4"), (1, "1"), (2, "2"), (3, "")])
-
-Belt.Map.findFirstBy(s0, (k, v) => k == 4) /* (4, "4") */
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'k, 'v, 'id>, (. 'k, 'v) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'k, 'v, 'id>, ('k, 'v) => unit) => unit
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the `'k` as first argument, and the associated value as second argument. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-let s0 = Belt.Map.fromArray(~id=module(IntCmp), [(4, "4"), (1, "1"), (2, "2"), (3, "")])
-
-let acc = ref(list{})
-
-Belt.Map.forEach(s0, (k, v) => acc := list{(k, v), ...acc.contents})
-
-acc.contents == list{(4, "4"), (3, "3"), (2, "2"), (1, "1")}
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t<'k, 'v, 'id>, 'acc, (. 'acc, 'k, 'v) => 'acc) => 'acc
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'k, 'v, 'id>, 'acc, ('acc, 'k, 'v) => 'acc) => 'acc
-```
-
-`reduce(m, a, f)` computes `(f(kN, dN) ... (f(k1, d1, a))...)`, where `k1 ... kN` are the keys of all bindings in m (in increasing order), and `d1 ... dN` are the associated data.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-let s0 = Belt.Map.fromArray(~id=module(IntCmp), [(4, "4"), (1, "1"), (2, "2"), (3, "3")])
-
-Belt.Map.reduce(s0, list{}, (acc, k, v) => list{
-  (k, v),
-  ...acc,
-}) /* [(4, "4"), (3, "3"), (2, "2"), (1, "1"), 0] */
-```
-
-## everyU
-
-```res sig
-let everyU: (t<'k, 'v, 'id>, (. 'k, 'v) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'k, 'v, 'id>, ('k, 'v) => bool) => bool
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. Order unspecified
-
-## someU
-
-```res sig
-let someU: (t<'k, 'v, 'id>, (. 'k, 'v) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'k, 'v, 'id>, ('k, 'v) => bool) => bool
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. Order unspecified
-
-## size
-
-```res sig
-let size: t<'k, 'v, 'id> => int
-```
-
-`size(s)`
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-Belt.Map.size(Belt.Map.fromArray([(2, "2"), (2, "1"), (3, "3")], ~id=module(IntCmp))) == 2
-```
-
-## toArray
-
-```res sig
-let toArray: t<'k, 'v, 'id> => array<('k, 'v)>
-```
-
-`toArray(s)`
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-Belt.Map.toArray(Belt.Map.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntCmp))) == [
-    (1, "1"),
-    (2, "2"),
-    (3, "3"),
-  ]
-```
-
-## toList
-
-```res sig
-let toList: t<'k, 'v, 'id> => list<('k, 'v)>
-```
-
-In increasing order.
-
-See `Belt.Map.toArray`
-
-## fromArray
-
-```res sig
-let fromArray: (array<('k, 'v)>, ~id: id<'k, 'id>) => t<'k, 'v, 'id>
-```
-
-`fromArray(kvs, ~id);`
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-Belt.Map.toArray(Belt.Map.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntCmp))) == [
-    (1, "1"),
-    (2, "2"),
-    (3, "3"),
-  ]
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'k, 'v, 'id> => array<'k>
-```
-
-`keysToArray(s);`
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-Belt.Map.keysToArray(Belt.Map.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntCmp))) == [
-    1,
-    2,
-    3,
-  ]
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'k, 'v, 'id> => array<'v>
-```
-
-`valuesToArray(s);`
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-Belt.Map.valuesToArray(
-  Belt.Map.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntCmp)),
-) == ["1", "2", "3"]
-```
-
-## minKey
-
-```res sig
-let minKey: t<'k, 'a, 'b> => option<'k>
-```
-
-`minKey(s)` returns the minimum key, None if not exist.
-
-## minKeyUndefined
-
-```res sig
-let minKeyUndefined: t<'k, 'a, 'b> => Js.undefined<'k>
-```
-
-See `Belt.Map.minKey`
-
-## maxKey
-
-```res sig
-let maxKey: t<'k, 'a, 'b> => option<'k>
-```
-
-`maxKey(s)` returns the maximum key, None if not exist.
-
-## maxKeyUndefined
-
-```res sig
-let maxKeyUndefined: t<'k, 'a, 'b> => Js.undefined<'k>
-```
-
-See `Belt.Map.maxKey`
-
-## minimum
-
-```res sig
-let minimum: t<'k, 'v, 'a> => option<('k, 'v)>
-```
-
-`minimum(s)` returns the minimum key value pair, None if not exist
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'k, 'v, 'a> => Js.undefined<('k, 'v)>
-```
-
-See `Belt.Map.minimum`
-
-## maximum
-
-```res sig
-let maximum: t<'k, 'v, 'a> => option<('k, 'v)>
-```
-
-`maximum(s)` returns the maximum key value pair, None if not exist.
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'k, 'v, 'a> => Js.undefined<('k, 'v)>
-```
-
-See `Belt.Map.maximum`
-
-## get
-
-```res sig
-let get: (t<'k, 'v, 'id>, 'k) => option<'v>
-```
-
-`get(s, k)`
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-Belt.Map.get(Belt.Map.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntCmp)), 2) ==
-  Some("2")
-
-Belt.Map.get(Belt.Map.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntCmp)), 2) == None
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'k, 'v, 'id>, 'k) => Js.undefined<'v>
-```
-
-See `Belt.Map.get`
-
-Returns `undefined` when not found
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (t<'k, 'v, 'id>, 'k, 'v) => 'v
-```
-
-`getWithDefault(s, k, default)`
-
-See `Belt.Map.get`
-
-Returns default when `k` is not found.
-
-## getExn
-
-```res sig
-let getExn: (t<'k, 'v, 'id>, 'k) => 'v
-```
-
-`getExn(s, k)`
-
-See `Belt.Map.getExn`
-
-raise when `k` not exist
-
-## remove
-
-```res sig
-let remove: (t<'k, 'v, 'id>, 'k) => t<'k, 'v, 'id>
-```
-
-`remove(m, x)` when `x` is not in `m`, `m` is returned reference unchanged.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-let s0 = Belt.Map.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntCmp))
-
-let s1 = Belt.Map.remove(s0, 1)
-
-let s2 = Belt.Map.remove(s1, 1)
-
-s1 === s2
-
-Belt.Map.keysToArray(s1) == [2, 3]
-```
-
-## removeMany
-
-```res sig
-let removeMany: (t<'k, 'v, 'id>, array<'k>) => t<'k, 'v, 'id>
-```
-
-`removeMany(s, xs)`
-
-Removing each of `xs` to `s`, note unlike `Belt.Map.remove`, the reference of return value might be changed even if none in `xs` exists `s`.
-
-## set
-
-```res sig
-let set: (t<'k, 'v, 'id>, 'k, 'v) => t<'k, 'v, 'id>
-```
-
-`set(m, x, y)` returns a map containing the same bindings as `m`, with a new binding of `x` to `y`. If `x` was already bound in `m`, its previous binding disappears.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-let s0 = Belt.Map.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntCmp))
-
-let s1 = Belt.Map.set(s0, 2, "3")
-
-Belt.Map.valuesToArray(s1) == ["1", "3", "3"]
-```
-
-## updateU
-
-```res sig
-let updateU: (t<'k, 'v, 'id>, 'k, (. option<'v>) => option<'v>) => t<'k, 'v, 'id>
-```
-
-## update
-
-```res sig
-let update: (t<'k, 'v, 'id>, 'k, option<'v> => option<'v>) => t<'k, 'v, 'id>
-```
-
-`update(m, x, f)` returns a map containing the same bindings as `m`, except for the binding of `x`. Depending on the value of `y` where `y` is `f(get(m, x))`, the binding of `x` is added, removed or updated. If `y` is `None`, the binding is removed if it exists; otherwise, if `y` is `Some(z)` then `x` is associated to `z` in the resulting map.
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'k, 'v, 'id>, array<('k, 'v)>) => t<'k, 'v, 'id>
-```
-
-`mergeMany(s, xs)`
-
-Adding each of `xs` to `s`, note unlike `add`, the reference of return value might be changed even if all values in `xs` exist `s`.
-
-## mergeU
-
-```res sig
-let mergeU: (
-  t<'k, 'v, 'id>,
-  t<'k, 'v2, 'id>,
-  (. 'k, option<'v>, option<'v2>) => option<'v3>,
-) => t<'k, 'v3, 'id>
-```
-
-## merge
-
-```res sig
-let merge: (
-  t<'k, 'v, 'id>,
-  t<'k, 'v2, 'id>,
-  ('k, option<'v>, option<'v2>) => option<'v3>,
-) => t<'k, 'v3, 'id>
-```
-
-`merge(m1, m2, f)` computes a map whose keys is a subset of keys of `m1` and of `m2`. The presence of each such binding, and the corresponding value, is determined with the function `f`.
-
-## keepU
-
-```res sig
-let keepU: (t<'k, 'v, 'id>, (. 'k, 'v) => bool) => t<'k, 'v, 'id>
-```
-
-## keep
-
-```res sig
-let keep: (t<'k, 'v, 'id>, ('k, 'v) => bool) => t<'k, 'v, 'id>
-```
-
-`keep(m, p)` returns the map with all the bindings in m that satisfy predicate `p`.
-
-## partitionU
-
-```res sig
-let partitionU: (t<'k, 'v, 'id>, (. 'k, 'v) => bool) => (t<'k, 'v, 'id>, t<'k, 'v, 'id>)
-```
-
-## partition
-
-```res sig
-let partition: (t<'k, 'v, 'id>, ('k, 'v) => bool) => (t<'k, 'v, 'id>, t<'k, 'v, 'id>)
-```
-
-`partition(m, p)` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `s` that satisfy the predicate `p`, and `m2` is the map with all the bindings of `s` that do not satisfy `p`.
-
-## split
-
-```res sig
-let split: (t<'k, 'v, 'id>, 'k) => ((t<'k, 'v, 'id>, t<'k, 'v, 'id>), option<'v>)
-```
-
-`split(x, m)` returns a tuple `(l, r)`, data, where `l` is the map with all the bindings of `m` whose 'k is strictly less than `x`; `r` is the map with all the bindings of m whose 'k is strictly greater than `x`; `data` is `None` if `m` contains no binding for `x`, or `Some(v)` if `m` binds `v` to `x`.
-
-## mapU
-
-```res sig
-let mapU: (t<'k, 'v, 'id>, (. 'v) => 'v2) => t<'k, 'v2, 'id>
-```
-
-## map
-
-```res sig
-let map: (t<'k, 'v, 'id>, 'v => 'v2) => t<'k, 'v2, 'id>
-```
-
-`map(m, f) returns a map with same domain as`m`, where the associated value`a`of all bindings of`m`has been replaced by the result of the application of`f`to`a`. The bindings are passed to`f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```res sig
-let mapWithKeyU: (t<'k, 'v, 'id>, (. 'k, 'v) => 'v2) => t<'k, 'v2, 'id>
-```
-
-## mapWithKey
-
-```res sig
-let mapWithKey: (t<'k, 'v, 'id>, ('k, 'v) => 'v2) => t<'k, 'v2, 'id>
-```
-
-`mapWithKey(m, f)`
-
-The same as `Belt.Map.map` except that `f` is supplied with one more argument: the key.
-
-## getData
-
-```res sig
-let getData: t<'k, 'v, 'id> => Belt_MapDict.t<'k, 'v, 'id>
-```
-
-`getData(s0)`
-
-Advanced usage only
-
-Returns the raw data (detached from comparator), but its type is still manifested, so that user can pass identity directly without boxing.
-
-## getId
-
-```res sig
-let getId: t<'k, 'v, 'id> => id<'k, 'id>
-```
-
-Advanced usage only
-
-Returns the identity of s0.
-
-## packIdData
-
-```res sig
-let packIdData: (~id: id<'k, 'id>, ~data: Belt_MapDict.t<'k, 'v, 'id>) => t<'k, 'v, 'id>
-```
-
-`packIdData(~id, ~data)`
-
-Advanced usage only
-
-Returns the packed collection.
diff --git a/pages/docs/manual/v10.0.0/api/belt/mutable-map-int.mdx b/pages/docs/manual/v10.0.0/api/belt/mutable-map-int.mdx
deleted file mode 100644
index 73fbcaaab..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/mutable-map-int.mdx
+++ /dev/null
@@ -1,299 +0,0 @@
-# MutableMapInt
-
-## key
-
-```res prelude
-type key = int
-```
-
-## t
-
-```res prelude
-type t<'a>
-```
-
-## make
-
-```res sig
-let make: unit => t<'a>
-```
-
-## clear
-
-```res sig
-let clear: t<'a> => unit
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a> => bool
-```
-
-## has
-
-```res sig
-let has: (t<'a>, key) => bool
-```
-
-## cmpU
-
-```res sig
-let cmpU: (t<'a>, t<'a>, (. 'a, 'a) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'a>, t<'a>, ('a, 'a) => int) => int
-```
-
-`cmp(m1, m2, cmp)` First compare by size, if size is the same, compare by key, value pair.
-
-## eqU
-
-```res sig
-let eqU: (t<'a>, t<'a>, (. 'a, 'a) => bool) => bool
-```
-
-## eq
-
-```res sig
-let eq: (t<'a>, t<'a>, ('a, 'a) => bool) => bool
-```
-
-`eq(m1, m2, cmp)`
-
-## forEachU
-
-```res sig
-let forEachU: (t<'a>, (. key, 'a) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'a>, (key, 'a) => unit) => unit
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the key as first argument, and the associated value as second argument. The application order of `f` is in increasing order.
-
-## reduceU
-
-```res sig
-let reduceU: (t<'a>, 'b, (. 'b, key, 'a) => 'b) => 'b
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'a>, 'b, ('b, key, 'a) => 'b) => 'b
-```
-
-`reduce(m, a, f), computes`(f(kN, dN) ... (f(k1, d1, a))...)`, where`k1 ... kN`are the keys of all bindings in`m`(in increasing order), and`d1 ... dN` are the associated data.
-
-## everyU
-
-```res sig
-let everyU: (t<'a>, (. key, 'a) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'a>, (key, 'a) => bool) => bool
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. The application order of `p` is unspecified.
-
-## someU
-
-```res sig
-let someU: (t<'a>, (. key, 'a) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'a>, (key, 'a) => bool) => bool
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. The application order of `p` is unspecified.
-
-## size
-
-```res sig
-let size: t<'a> => int
-```
-
-## toList
-
-```res sig
-let toList: t<'a> => list<(key, 'a)>
-```
-
-In increasing order
-
-## toArray
-
-```res sig
-let toArray: t<'a> => array<(key, 'a)>
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<(key, 'a)> => t<'a>
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'a> => array<key>
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'a> => array<'a>
-```
-
-## minKey
-
-```res sig
-let minKey: t<'a> => option<key>
-```
-
-## minKeyUndefined
-
-```res sig
-let minKeyUndefined: t<'a> => Js.undefined<key>
-```
-
-## maxKey
-
-```res sig
-let maxKey: t<'a> => option<key>
-```
-
-## maxKeyUndefined
-
-```res sig
-let maxKeyUndefined: t<'a> => Js.undefined<key>
-```
-
-## minimum
-
-```res sig
-let minimum: t<'a> => option<(key, 'a)>
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'a> => Js.undefined<(key, 'a)>
-```
-
-## maximum
-
-```res sig
-let maximum: t<'a> => option<(key, 'a)>
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'a> => Js.undefined<(key, 'a)>
-```
-
-## get
-
-```res sig
-let get: (t<'a>, key) => option<'a>
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'a>, key) => Js.undefined<'a>
-```
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (t<'a>, key, 'a) => 'a
-```
-
-## getExn
-
-```res sig
-let getExn: (t<'a>, key) => 'a
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t<'a> => unit
-```
-
-Raise when invariant is not held.
-
-## remove
-
-```res sig
-let remove: (t<'a>, key) => unit
-```
-
-`remove(m, x)` do the in-place modification.
-
-## removeMany
-
-```res sig
-let removeMany: (t<'a>, array<key>) => unit
-```
-
-## set
-
-```res sig
-let set: (t<'a>, key, 'a) => unit
-```
-
-`set(m, x, y)` do the in-place modification, return `m` for chaining. If `x` was already bound in `m`, its previous binding disappears.
-
-## updateU
-
-```res sig
-let updateU: (t<'a>, key, (. option<'a>) => option<'a>) => unit
-```
-
-## update
-
-```res sig
-let update: (t<'a>, key, option<'a> => option<'a>) => unit
-```
-
-## mapU
-
-```res sig
-let mapU: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-## map
-
-```res sig
-let map: (t<'a>, 'a => 'b) => t<'b>
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value a of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```res sig
-let mapWithKeyU: (t<'a>, (. key, 'a) => 'b) => t<'b>
-```
-
-## mapWithKey
-
-```res sig
-let mapWithKey: (t<'a>, (key, 'a) => 'b) => t<'b>
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/mutable-map-string.mdx b/pages/docs/manual/v10.0.0/api/belt/mutable-map-string.mdx
deleted file mode 100644
index cfc1d228d..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/mutable-map-string.mdx
+++ /dev/null
@@ -1,299 +0,0 @@
-# MutableMapString
-
-## key
-
-```res prelude
-type key = string
-```
-
-## t
-
-```res prelude
-type t<'a>
-```
-
-## make
-
-```res sig
-let make: unit => t<'a>
-```
-
-## clear
-
-```res sig
-let clear: t<'a> => unit
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a> => bool
-```
-
-## has
-
-```res sig
-let has: (t<'a>, key) => bool
-```
-
-## cmpU
-
-```res sig
-let cmpU: (t<'a>, t<'a>, (. 'a, 'a) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'a>, t<'a>, ('a, 'a) => int) => int
-```
-
-`cmp(m1, m2, cmp)` First compare by size, if size is the same, compare by key, value pair.
-
-## eqU
-
-```res sig
-let eqU: (t<'a>, t<'a>, (. 'a, 'a) => bool) => bool
-```
-
-## eq
-
-```res sig
-let eq: (t<'a>, t<'a>, ('a, 'a) => bool) => bool
-```
-
-`eq(m1, m2, cmp)`
-
-## forEachU
-
-```res sig
-let forEachU: (t<'a>, (. key, 'a) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'a>, (key, 'a) => unit) => unit
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the key as first argument, and the associated value as second argument. The application order of `f` is in increasing order.
-
-## reduceU
-
-```res sig
-let reduceU: (t<'a>, 'b, (. 'b, key, 'a) => 'b) => 'b
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'a>, 'b, ('b, key, 'a) => 'b) => 'b
-```
-
-`reduce(m, a, f), computes`(f(kN, dN) ... (f(k1, d1, a))...)`, where`k1 ... kN`are the keys of all bindings in`m`(in increasing order), and`d1 ... dN` are the associated data.
-
-## everyU
-
-```res sig
-let everyU: (t<'a>, (. key, 'a) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'a>, (key, 'a) => bool) => bool
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. The application order of `p` is unspecified.
-
-## someU
-
-```res sig
-let someU: (t<'a>, (. key, 'a) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'a>, (key, 'a) => bool) => bool
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. The application order of `p` is unspecified.
-
-## size
-
-```res sig
-let size: t<'a> => int
-```
-
-## toList
-
-```res sig
-let toList: t<'a> => list<(key, 'a)>
-```
-
-In increasing order
-
-## toArray
-
-```res sig
-let toArray: t<'a> => array<(key, 'a)>
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<(key, 'a)> => t<'a>
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'a> => array<key>
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'a> => array<'a>
-```
-
-## minKey
-
-```res sig
-let minKey: t<'a> => option<key>
-```
-
-## minKeyUndefined
-
-```res sig
-let minKeyUndefined: t<'a> => Js.undefined<key>
-```
-
-## maxKey
-
-```res sig
-let maxKey: t<'a> => option<key>
-```
-
-## maxKeyUndefined
-
-```res sig
-let maxKeyUndefined: t<'a> => Js.undefined<key>
-```
-
-## minimum
-
-```res sig
-let minimum: t<'a> => option<(key, 'a)>
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'a> => Js.undefined<(key, 'a)>
-```
-
-## maximum
-
-```res sig
-let maximum: t<'a> => option<(key, 'a)>
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'a> => Js.undefined<(key, 'a)>
-```
-
-## get
-
-```res sig
-let get: (t<'a>, key) => option<'a>
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'a>, key) => Js.undefined<'a>
-```
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (t<'a>, key, 'a) => 'a
-```
-
-## getExn
-
-```res sig
-let getExn: (t<'a>, key) => 'a
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t<'a> => unit
-```
-
-Raise when invariant is not held.
-
-## remove
-
-```res sig
-let remove: (t<'a>, key) => unit
-```
-
-`remove(m, x)` do the in-place modification.
-
-## removeMany
-
-```res sig
-let removeMany: (t<'a>, array<key>) => unit
-```
-
-## set
-
-```res sig
-let set: (t<'a>, key, 'a) => unit
-```
-
-`set(m, x, y)` do the in-place modification, return `m` for chaining. If `x` was already bound in `m`, its previous binding disappears.
-
-## updateU
-
-```res sig
-let updateU: (t<'a>, key, (. option<'a>) => option<'a>) => unit
-```
-
-## update
-
-```res sig
-let update: (t<'a>, key, option<'a> => option<'a>) => unit
-```
-
-## mapU
-
-```res sig
-let mapU: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-## map
-
-```res sig
-let map: (t<'a>, 'a => 'b) => t<'b>
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value a of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```res sig
-let mapWithKeyU: (t<'a>, (. key, 'a) => 'b) => t<'b>
-```
-
-## mapWithKey
-
-```res sig
-let mapWithKey: (t<'a>, (key, 'a) => 'b) => t<'b>
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/mutable-map.mdx b/pages/docs/manual/v10.0.0/api/belt/mutable-map.mdx
deleted file mode 100644
index 21ed52d60..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/mutable-map.mdx
+++ /dev/null
@@ -1,313 +0,0 @@
-# MutableMap
-
-<Intro>
-
-A mutable sorted map module which allows customize compare behavior.
-
-</Intro>
-
-Same as `Belt.Map`, but mutable.
-
-## t
-
-```res prelude
-type t<'k, 'v, 'id>
-```
-
-## id
-
-```res prelude
-type id<'key, 'id> = Belt_Id.comparable<'key, 'id>
-```
-
-## make
-
-```res sig
-let make: (~id: id<'k, 'id>) => t<'k, 'a, 'id>
-```
-
-## clear
-
-```res sig
-let clear: t<'a, 'b, 'c> => unit
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a, 'b, 'c> => bool
-```
-
-## has
-
-```res sig
-let has: (t<'k, 'a, 'b>, 'k) => bool
-```
-
-## cmpU
-
-```res sig
-let cmpU: (t<'k, 'a, 'id>, t<'k, 'a, 'id>, (. 'a, 'a) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'k, 'a, 'id>, t<'k, 'a, 'id>, ('a, 'a) => int) => int
-```
-
-`cmp(m1, m2, cmp)` First compare by size, if size is the same, compare by key, value pair.
-
-## eqU
-
-```res sig
-let eqU: (t<'k, 'a, 'id>, t<'k, 'a, 'id>, (. 'a, 'a) => bool) => bool
-```
-
-## eq
-
-```res sig
-let eq: (t<'k, 'a, 'id>, t<'k, 'a, 'id>, ('a, 'a) => bool) => bool
-```
-
-`eq(m1, m2, eqf)` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data. `eqf` is the equality predicate used to compare the data associated with the keys.
-
-## forEachU
-
-```res sig
-let forEachU: (t<'k, 'a, 'id>, (. 'k, 'a) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'k, 'a, 'id>, ('k, 'a) => unit) => unit
-```
-
-`forEach(m, f)` applies f to all bindings in map `m`. `f` receives the `'k` as first argument, and the associated value as second argument. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## reduceU
-
-```res sig
-let reduceU: (t<'k, 'a, 'id>, 'b, (. 'b, 'k, 'a) => 'b) => 'b
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'k, 'a, 'id>, 'b, ('b, 'k, 'a) => 'b) => 'b
-```
-
-`reduce(m, a, f), computes`(f(kN, dN) ... (f(k1, d1, a))...)`, where`k1 ... kN`are the keys of all bindings in`m`(in increasing order), and`d1 ... dN` are the associated data.
-
-## everyU
-
-```res sig
-let everyU: (t<'k, 'a, 'id>, (. 'k, 'a) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'k, 'a, 'id>, ('k, 'a) => bool) => bool
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`.
-
-## someU
-
-```res sig
-let someU: (t<'k, 'a, 'id>, (. 'k, 'a) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'k, 'a, 'id>, ('k, 'a) => bool) => bool
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`.
-
-## size
-
-```res sig
-let size: t<'k, 'a, 'id> => int
-```
-
-## toList
-
-```res sig
-let toList: t<'k, 'a, 'id> => list<('k, 'a)>
-```
-
-In increasing order.
-
-## toArray
-
-```res sig
-let toArray: t<'k, 'a, 'id> => array<('k, 'a)>
-```
-
-## fromArray
-
-```res sig
-let fromArray: (array<('k, 'a)>, ~id: id<'k, 'id>) => t<'k, 'a, 'id>
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'k, 'a, 'b> => array<'k>
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'b, 'a, 'c> => array<'a>
-```
-
-## minKey
-
-```res sig
-let minKey: t<'k, 'a, 'b> => option<'k>
-```
-
-## minKeyUndefined
-
-```res sig
-let minKeyUndefined: t<'k, 'a, 'b> => Js.undefined<'k>
-```
-
-## maxKey
-
-```res sig
-let maxKey: t<'k, 'a, 'b> => option<'k>
-```
-
-## maxKeyUndefined
-
-```res sig
-let maxKeyUndefined: t<'k, 'a, 'b> => Js.undefined<'k>
-```
-
-## minimum
-
-```res sig
-let minimum: t<'k, 'a, 'b> => option<('k, 'a)>
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'k, 'a, 'b> => Js.undefined<('k, 'a)>
-```
-
-## maximum
-
-```res sig
-let maximum: t<'k, 'a, 'b> => option<('k, 'a)>
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'k, 'a, 'b> => Js.undefined<('k, 'a)>
-```
-
-## get
-
-```res sig
-let get: (t<'k, 'a, 'id>, 'k) => option<'a>
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'k, 'a, 'id>, 'k) => Js.undefined<'a>
-```
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (t<'k, 'a, 'id>, 'k, 'a) => 'a
-```
-
-## getExn
-
-```res sig
-let getExn: (t<'k, 'a, 'id>, 'k) => 'a
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t<'a, 'b, 'c> => unit
-```
-
-Raise when invariant is not held.
-
-## remove
-
-```res sig
-let remove: (t<'k, 'a, 'id>, 'k) => unit
-```
-
-`remove(m, x)` do the in-place modification.
-
-## removeMany
-
-```res sig
-let removeMany: (t<'k, 'a, 'id>, array<'k>) => unit
-```
-
-## set
-
-```res sig
-let set: (t<'k, 'a, 'id>, 'k, 'a) => unit
-```
-
-`set(m, x, y)` do the in-place modification
-
-## updateU
-
-```res sig
-let updateU: (t<'k, 'a, 'id>, 'k, (. option<'a>) => option<'a>) => unit
-```
-
-## update
-
-```res sig
-let update: (t<'k, 'a, 'id>, 'k, option<'a> => option<'a>) => unit
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'k, 'a, 'id>, array<('k, 'a)>) => unit
-```
-
-## mapU
-
-```res sig
-let mapU: (t<'k, 'a, 'id>, (. 'a) => 'b) => t<'k, 'b, 'id>
-```
-
-## map
-
-```res sig
-let map: (t<'k, 'a, 'id>, 'a => 'b) => t<'k, 'b, 'id>
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value a of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```res sig
-let mapWithKeyU: (t<'k, 'a, 'id>, (. 'k, 'a) => 'b) => t<'k, 'b, 'id>
-```
-
-## mapWithKey
-
-```res sig
-let mapWithKey: (t<'k, 'a, 'id>, ('k, 'a) => 'b) => t<'k, 'b, 'id>
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/mutable-queue.mdx b/pages/docs/manual/v10.0.0/api/belt/mutable-queue.mdx
deleted file mode 100644
index 9efd21a4b..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/mutable-queue.mdx
+++ /dev/null
@@ -1,175 +0,0 @@
-# MutableQueue
-
-<Intro>
-
-An FIFO(first in first out) queue data structure.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a>
-```
-
-The type of queues containing elements of `type('a)`.
-
-## make
-
-```res sig
-let make: unit => t<'a>
-```
-
-Returns a new queue, initially empty.
-
-## clear
-
-```res sig
-let clear: t<'a> => unit
-```
-
-Discard all elements from the queue.
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a> => bool
-```
-
-Returns `true` if the given queue is empty, `false` otherwise.
-
-## fromArray
-
-```res sig
-let fromArray: array<'a> => t<'a>
-```
-
-`fromArray` a is equivalent to `Array.forEach(a, add(q, a));`
-
-## add
-
-```res sig
-let add: (t<'a>, 'a) => unit
-```
-
-`add(q, x)` adds the element `x` at the end of the queue `q`.
-
-## peek
-
-```res sig
-let peek: t<'a> => option<'a>
-```
-
-`peekOpt(q)` returns the first element in queue `q`, without removing it from the queue.
-
-## peekUndefined
-
-```res sig
-let peekUndefined: t<'a> => Js.undefined<'a>
-```
-
-`peekUndefined(q)` returns `undefined` if not found.
-
-## peekExn
-
-```res sig
-let peekExn: t<'a> => 'a
-```
-
-raise an exception if `q` is empty
-
-## pop
-
-```res sig
-let pop: t<'a> => option<'a>
-```
-
-`pop(q)` removes and returns the first element in queue `q`.
-
-## popUndefined
-
-```res sig
-let popUndefined: t<'a> => Js.undefined<'a>
-```
-
-`popUndefined(q)` removes and returns the first element in queue `q`. it will return `undefined` if it is already empty.
-
-## popExn
-
-```res sig
-let popExn: t<'a> => 'a
-```
-
-`popExn(q)` raise an exception if q is empty.
-
-## copy
-
-```res sig
-let copy: t<'a> => t<'a>
-```
-
-`copy(q)` returns a fresh queue.
-
-## size
-
-```res sig
-let size: t<'a> => int
-```
-
-Returns the number of elements in a queue.
-
-## mapU
-
-```res sig
-let mapU: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-## map
-
-```res sig
-let map: (t<'a>, 'a => 'b) => t<'b>
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'a>, (. 'a) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'a>, 'a => unit) => unit
-```
-
-`forEach(q, f) applies`f`in turn to all elements of`q`, from the least recently entered to the most recently entered. The queue itself is unchanged.
-
-## reduceU
-
-```res sig
-let reduceU: (t<'a>, 'b, (. 'b, 'a) => 'b) => 'b
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'a>, 'b, ('b, 'a) => 'b) => 'b
-```
-
-`reduce(q, accu, f)` is equivalent to `List.reduce(l, accu, f)`, where `l` is the list of `q`'s elements. The queue remains unchanged.
-
-## transfer
-
-```res sig
-let transfer: (t<'a>, t<'a>) => unit
-```
-
-`transfer(q1, q2)` adds all of `q1`'s elements at the end of the queue `q2`, then clears `q1`. It is equivalent to the sequence `forEach((x) => add(x, q2), q1);`; clear `q1`, but runs in constant time.
-
-## toArray
-
-```res sig
-let toArray: t<'a> => array<'a>
-```
-
-First added will be in the beginning of the array.
diff --git a/pages/docs/manual/v10.0.0/api/belt/mutable-set-int.mdx b/pages/docs/manual/v10.0.0/api/belt/mutable-set-int.mdx
deleted file mode 100644
index f4fd5a6ce..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/mutable-set-int.mdx
+++ /dev/null
@@ -1,559 +0,0 @@
-# MutableSetInt
-
-<Intro>
-
-This module is [Belt.MutableSet](mutable-set) specialized with key type to be a `int` type.
-It is more efficient in general, the API is the same with [Belt.MutableSet](mutable-set) except its key type is fixed, and identity is not needed (using the built-in one).
-
-</Intro>
-
-## value
-
-```res prelude
-type value = int
-```
-
-The type of the set elements
-
-## t
-
-```res prelude
-type t
-```
-
-Type of the sets.
-
-## make
-
-```res sig
-let make: unit => t
-```
-
-Returns empty set.
-
-```res example
-let set = Belt.MutableSet.Int.make()
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<value> => t
-```
-
-Creates new set from array of elements.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([1, 3, 2, 4])
-
-s0->Belt.MutableSet.Int.toArray /* [1, 2, 3, 4] */
-```
-
-## fromSortedArrayUnsafe
-
-```res sig
-let fromSortedArrayUnsafe: array<value> => t
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-Returns copy of a set.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([1, 3, 2, 4])
-
-let copied = s0->Belt.MutableSet.Int.copy
-copied->Belt.MutableSet.Int.toArray /* [1, 2, 3, 4] */
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t => bool
-```
-
-Checks if set is empty.
-
-```res example
-let empty = Belt.MutableSet.Int.fromArray([])
-let notEmpty = Belt.MutableSet.Int.fromArray([1])
-
-Belt.MutableSet.Int.isEmpty(empty) /* true */
-Belt.MutableSet.Int.isEmpty(notEmpty) /* false */
-```
-
-## has
-
-```res sig
-let has: (t, value) => bool
-```
-
-Checks if element exists in set.
-
-```res example
-let set = Belt.MutableSet.Int.fromArray([1, 4, 2, 5])
-
-set->Belt.MutableSet.Int.has(3) /* false */
-set->Belt.MutableSet.Int.has(1) /* true */
-```
-
-## add
-
-```res sig
-let add: (t, value) => unit
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.MutableSet.Int.make()
-s0->Belt.MutableSet.Int.add(1)
-s0->Belt.MutableSet.Int.add(2)
-s0->Belt.MutableSet.Int.add(2)
-
-s0->Belt.MutableSet.Int.toArray /* [1, 2] */
-```
-
-## addCheck
-
-```
-let addCheck: (t, value) => bool;
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t, array<value>) => unit
-```
-
-Adds each element of array to set. Unlike [add](#add), the reference of return value might be changed even if all values in array already exist in set
-
-```res example
-let set = Belt.MutableSet.Int.make()
-
-set->Belt.MutableSet.Int.mergeMany([5, 4, 3, 2, 1])
-set->Belt.MutableSet.Int.toArray /* [1, 2, 3, 4, 5] */
-```
-
-## remove
-
-```res sig
-let remove: (t, value) => unit
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([2, 3, 1, 4, 5])
-s0->Belt.MutableSet.Int.remove(1)
-s0->Belt.MutableSet.Int.remove(3)
-s0->Belt.MutableSet.Int.remove(3)
-
-s0->Belt.MutableSet.Int.toArray /* [2,4,5] */
-```
-
-## removeCheck
-
-```res sig
-let removeCheck: (t, value) => bool
-```
-
-## removeMany
-
-```res sig
-let removeMany: (t, array<value>) => unit
-```
-
-Removes each element of array from set.
-
-```res example
-let set = Belt.MutableSet.Int.fromArray([1, 2, 3, 4])
-
-set->Belt.MutableSet.Int.removeMany([5, 4, 3, 2, 1])
-set->Belt.MutableSet.Int.toArray /* [] */
-```
-
-## union
-
-```res sig
-let union: (t, t) => t
-```
-
-Returns union of two sets.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([5, 2, 3, 5, 6])
-let s1 = Belt.MutableSet.Int.fromArray([5, 2, 3, 1, 5, 4])
-let union = Belt.MutableSet.Int.union(s0, s1)
-union->Belt.MutableSet.Int.toArray /* [1,2,3,4,5,6] */
-```
-
-## intersect
-
-```res sig
-let intersect: (t, t) => t
-```
-
-Returns intersection of two sets.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([5, 2, 3, 5, 6])
-let s1 = Belt.MutableSet.Int.fromArray([5, 2, 3, 1, 5, 4])
-let intersect = Belt.MutableSet.Int.intersect(s0, s1)
-intersect->Belt.MutableSet.Int.toArray /* [2,3,5] */
-```
-
-## diff
-
-```res sig
-let diff: (t, t) => t
-```
-
-Returns elements from first set, not existing in second set.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([5, 2, 3, 5, 6])
-let s1 = Belt.MutableSet.Int.fromArray([5, 2, 3, 1, 5, 4])
-Belt.MutableSet.Int.toArray(Belt.MutableSet.Int.diff(s0, s1)) /* [6] */
-Belt.MutableSet.Int.toArray(Belt.MutableSet.Int.diff(s1, s0)) /* [1,4] */
-```
-
-## subset
-
-```res sig
-let subset: (t, t) => bool
-```
-
-Checks if second set is subset of first set.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([5, 2, 3, 5, 6])
-let s1 = Belt.MutableSet.Int.fromArray([5, 2, 3, 1, 5, 4])
-let s2 = Belt.MutableSet.Int.intersect(s0, s1)
-Belt.MutableSet.Int.subset(s2, s0) /* true */
-Belt.MutableSet.Int.subset(s2, s1) /* true */
-Belt.MutableSet.Int.subset(s1, s0) /* false */
-```
-
-## cmp
-
-```res sig
-let cmp: (t, t) => int
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```res sig
-let eq: (t, t) => bool
-```
-
-Checks if two sets are equal.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([5, 2, 3])
-let s1 = Belt.MutableSet.Int.fromArray([3, 2, 5])
-
-Belt.MutableSet.Int.eq(s0, s1) /* true */
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t, (. value) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t, value => unit) => unit
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([5, 2, 3, 5, 6])
-let acc = ref(list{})
-s0->Belt.MutableSet.Int.forEach(x => acc := Belt.List.add(acc.contents, x))
-acc /* [6,5,3,2] */
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t, 'a, (. 'a, value) => 'a) => 'a
-```
-
-## reduce
-
-```
-let reduce: (t, 'a, ('a, value) => 'a) => 'a;
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([5, 2, 3, 5, 6])
-s0->Belt.MutableSet.Int.reduce(list{}, (acc, element) =>
-  acc->Belt.List.add(element)
-) /* [6,5,3,2] */
-```
-
-## everyU
-
-```res sig
-let everyU: (t, (. value) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t, value => bool) => bool
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.MutableSet.Int.fromArray([2, 4, 6, 8])
-s0->Belt.MutableSet.Int.every(isEven) /* true */
-```
-
-## someU
-
-```res sig
-let someU: (t, (. value) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t, value => bool) => bool
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```res example
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.MutableSet.Int.fromArray([1, 2, 4, 6, 8])
-s0->Belt.MutableSet.Int.some(isOdd) /* true */
-```
-
-## keepU
-
-```res sig
-let keepU: (t, (. value) => bool) => t
-```
-
-## keep
-
-```res sig
-let keep: (t, value => bool) => t
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.MutableSet.Int.fromArray([1, 2, 3, 4, 5])
-let s1 = s0->Belt.MutableSet.Int.keep(isEven)
-
-s1->Belt.MutableSet.Int.toArray /* [2, 4] */
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t, (. value) => bool) => (t, t)
-```
-
-## partition
-
-```res sig
-let partition: (t, value => bool) => (t, t)
-```
-
-```res example
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.MutableSet.Int.fromArray([1, 2, 3, 4, 5])
-let (s1, s2) = s0->Belt.MutableSet.Int.partition(isOdd)
-
-s1->Belt.MutableSet.Int.toArray /* [1,3,5] */
-s2->Belt.MutableSet.Int.toArray /* [2,4] */
-```
-
-## size
-
-```res sig
-let size: t => int
-```
-
-Returns size of the set.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([1, 2, 3, 4])
-
-s0->Belt.MutableSet.Int.size /* 4 */
-```
-
-## toList
-
-```res sig
-let toList: t => list<value>
-```
-
-Returns list of ordered set elements.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.MutableSet.Int.toList /* [1,2,3,5] */
-```
-
-## toArray
-
-```res sig
-let toArray: t => array<value>
-```
-
-Returns array of ordered set elements.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.MutableSet.Int.toArray /* [1,2,3,5] */
-```
-
-## minimum
-
-```res sig
-let minimum: t => option<value>
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.MutableSet.Int.make()
-let s1 = Belt.MutableSet.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.MutableSet.Int.minimum /* None */
-s1->Belt.MutableSet.Int.minimum /* Some(1) */
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t => Js.undefined<value>
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.MutableSet.Int.make()
-let s1 = Belt.MutableSet.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.MutableSet.Int.minUndefined /* undefined */
-s1->Belt.MutableSet.Int.minUndefined /* 1 */
-```
-
-## maximum
-
-```res sig
-let maximum: t => option<value>
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.MutableSet.Int.make()
-let s1 = Belt.MutableSet.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.MutableSet.Int.maximum /* None */
-s1->Belt.MutableSet.Int.maximum /* Some(5) */
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t => Js.undefined<value>
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.MutableSet.Int.make()
-let s1 = Belt.MutableSet.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.MutableSet.Int.maxUndefined /* undefined */
-s1->Belt.MutableSet.Int.maxUndefined /* 5 */
-```
-
-## get
-
-```res sig
-let get: (t, value) => option<value>
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([1, 2, 3, 4, 5])
-
-s0->Belt.MutableSet.Int.get(3) /* Some(3) */
-s0->Belt.MutableSet.Int.get(20) /* None */
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t, value) => Js.undefined<value>
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```res sig
-let getExn: (t, value) => value
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```res sig
-let split: (t, value) => ((t, t), bool)
-```
-
-Returns a tuple `((smaller, larger), present)`, `present` is true when element exist in set.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([1, 2, 3, 4, 5])
-
-let ((smaller, larger), present) = s0->Belt.MutableSet.Int.split(3)
-
-present /* true */
-smaller->Belt.MutableSet.Int.toArray /* [1,2] */
-larger->Belt.MutableSet.Int.toArray /* [4,5] */
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t => unit
-```
-
-**raise** when invariant is not held
diff --git a/pages/docs/manual/v10.0.0/api/belt/mutable-set-string.mdx b/pages/docs/manual/v10.0.0/api/belt/mutable-set-string.mdx
deleted file mode 100644
index 2acd4467e..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/mutable-set-string.mdx
+++ /dev/null
@@ -1,561 +0,0 @@
-# MutableSetString
-
-<Intro>
-
-This module is [Belt.MutableSet](mutable-set) specialized with key type to be a `string` type.
-It is more efficient in general, the API is the same with [Belt.MutableSet](mutable-set) except its key type is fixed, and identity is not needed (using the built-in one)
-
-</Intro>
-
-## value
-
-```res prelude
-type value = string
-```
-
-The type of the set elements.
-
-## t
-
-```res prelude
-type t
-```
-
-The type of sets.
-
-## make
-
-```res sig
-let make: unit => t
-```
-
-Returns empty set.
-
-```res example
-let set = Belt.MutableSet.String.make()
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<value> => t
-```
-
-Creates new set from array of elements.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "orange", "banana"])
-
-s0->Belt.MutableSet.String.toArray /* ["apple", "banana", "orange"] */
-```
-
-## fromSortedArrayUnsafe
-
-```res sig
-let fromSortedArrayUnsafe: array<value> => t
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-Returns copy of a set.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["orange", "apple"])
-
-let copied = s0->Belt.MutableSet.String.copy
-copied->Belt.MutableSet.String.toArray /* ["apple", "orange"] */
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t => bool
-```
-
-Checks if set is empty.
-
-```res example
-let empty = Belt.MutableSet.String.fromArray([])
-let notEmpty = Belt.MutableSet.String.fromArray(["apple"])
-
-Belt.MutableSet.String.isEmpty(empty) /* true */
-Belt.MutableSet.String.isEmpty(notEmpty) /* false */
-```
-
-## has
-
-```res sig
-let has: (t, value) => bool
-```
-
-Checks if element exists in set.
-
-```res example
-let set = Belt.MutableSet.String.fromArray(["apple", "orange", "banana"])
-
-set->Belt.MutableSet.String.has("strawberry") /* false */
-set->Belt.MutableSet.String.has("apple") /* true */
-```
-
-## add
-
-```res sig
-let add: (t, value) => unit
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.MutableSet.String.make()
-s0->Belt.MutableSet.String.add("apple")
-s0->Belt.MutableSet.String.add("banana")
-s0->Belt.MutableSet.String.add("banana")
-
-s0->Belt.MutableSet.String.toArray /* ["apple", "banana"] */
-```
-
-## addCheck
-
-```res sig
-let addCheck: (t, value) => bool
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t, array<value>) => unit
-```
-
-Adds each element of array to set.
-
-```res example
-let set = Belt.MutableSet.String.make()
-
-set->Belt.MutableSet.String.mergeMany(["apple", "banana", "orange", "strawberry"])
-set->Belt.MutableSet.String.toArray /* ["apple", "banana", "orange", "strawberry"] */
-```
-
-## remove
-
-```res sig
-let remove: (t, value) => unit
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["orange", "banana", "apple"])
-s0->Belt.MutableSet.String.remove("apple")
-s0->Belt.MutableSet.String.remove("banana")
-s0->Belt.MutableSet.String.remove("banana")
-
-s0->Belt.MutableSet.String.toArray /* ["orange"] */
-```
-
-## removeCheck
-
-```res sig
-let removeCheck: (t, value) => bool
-```
-
-## removeMany
-
-```res sig
-let removeMany: (t, array<value>) => unit
-```
-
-Removes each element of array from set.
-
-```res example
-let set = Belt.MutableSet.String.fromArray(["apple", "banana", "orange"])
-
-set->Belt.MutableSet.String.removeMany(["strawberry", "apple", "banana", "orange"])
-set->Belt.MutableSet.String.toArray /* [] */
-```
-
-## union
-
-```res sig
-let union: (t, t) => t
-```
-
-Returns union of two sets.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "banana", "orange", "carrot"])
-let s1 = Belt.MutableSet.String.fromArray(["apple", "banana", "orange", "strawberry"])
-let union = Belt.MutableSet.String.union(s0, s1)
-union->Belt.MutableSet.String.toArray /* ["apple", "banana", "carrot", "orange", "strawberry"] */
-```
-
-## intersect
-
-```res sig
-let intersect: (t, t) => t
-```
-
-Returns intersection of two sets.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "banana", "orange", "carrot"])
-let s1 = Belt.MutableSet.String.fromArray(["apple", "banana", "orange", "strawberry"])
-let intersect = Belt.MutableSet.String.intersect(s0, s1)
-intersect->Belt.MutableSet.String.toArray /* ["apple", "banana", "orange"] */
-```
-
-## diff
-
-```res sig
-let diff: (t, t) => t
-```
-
-Returns elements from first set, not existing in second set.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "banana", "orange", "carrot"])
-let s1 = Belt.MutableSet.String.fromArray(["apple", "banana", "orange", "strawberry"])
-Belt.MutableSet.String.toArray(Belt.MutableSet.String.diff(s0, s1)) /* ["carrot"] */
-Belt.MutableSet.String.toArray(Belt.MutableSet.String.diff(s1, s0)) /* ["strawberry"] */
-```
-
-## subset
-
-```res sig
-let subset: (t, t) => bool
-```
-
-Checks if second set is subset of first set.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["5", "2", "3", "5", "6"])
-let s1 = Belt.MutableSet.String.fromArray(["5", "2", "3", "1", "5", "4"])
-let s2 = Belt.MutableSet.String.intersect(s0, s1)
-Belt.MutableSet.String.subset(s2, s0) /* true */
-Belt.MutableSet.String.subset(s2, s1) /* true */
-Belt.MutableSet.String.subset(s1, s0) /* false */
-```
-
-## cmp
-
-```res sig
-let cmp: (t, t) => int
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```res sig
-let eq: (t, t) => bool
-```
-
-Checks if two sets are equal.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "orange"])
-let s1 = Belt.MutableSet.String.fromArray(["orange", "apple"])
-
-Belt.MutableSet.String.eq(s0, s1) /* true */
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t, (. value) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t, value => unit) => unit
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["banana", "orange", "apple"])
-let acc = ref(list{})
-s0->Belt.MutableSet.String.forEach(x => acc := Belt.List.add(acc.contents, x))
-acc /* ["orange", "banana", "apple"] */
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t, 'a, (. 'a, value) => 'a) => 'a
-```
-
-## reduce
-
-```res sig
-let reduce: (t, 'a, ('a, value) => 'a) => 'a
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "orange"])
-s0->Belt.MutableSet.String.reduce(0, (acc, element) => acc + String.length(element)) /* 11 */
-```
-
-## everyU
-
-```res sig
-let everyU: (t, (. value) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t, value => bool) => bool
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```res example
-let hasAtLeastFiveChars = x => String.length(x) >= 5
-
-let s0 = Belt.MutableSet.String.fromArray(["apple", "carrot"])
-s0->Belt.MutableSet.String.every(hasAtLeastFiveChars) /* true */
-```
-
-## someU
-
-```res sig
-let someU: (t, (. value) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t, value => bool) => bool
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```res example
-let hasFiveChars = x => String.length(x) == 5
-
-let s0 = Belt.MutableSet.String.fromArray(["strawberry", "apple"])
-s0->Belt.MutableSet.String.some(hasFiveChars) /* true */
-```
-
-## keepU
-
-```res sig
-let keepU: (t, (. value) => bool) => t
-```
-
-## keep
-
-```res sig
-let keep: (t, value => bool) => t
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```res example
-let hasFiveChars = x => String.length(x) == 5
-
-let s0 = Belt.MutableSet.String.fromArray(["apple", "orange", "banana"])
-let s1 = s0->Belt.MutableSet.String.keep(hasFiveChars)
-
-s1->Belt.MutableSet.String.toArray /* ["apple"] */
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t, (. value) => bool) => (t, t)
-```
-
-## partition
-
-```res sig
-let partition: (t, value => bool) => (t, t)
-```
-
-Returns a pair of sets, where first is the set of all the elements of set that satisfy the predicate, and second is the set of all the elements of set that do not satisfy the predicate.
-
-```res example
-let hasFiveChars = x => String.length(x) == 5
-
-let s0 = Belt.MutableSet.String.fromArray(["apple", "carrot"])
-let (s1, s2) = s0->Belt.MutableSet.String.partition(hasFiveChars)
-
-s1->Belt.MutableSet.String.toArray /* ["apple"] */
-s2->Belt.MutableSet.String.toArray /* ["carrot"] */
-```
-
-## size
-
-```res sig
-let size: t => int
-```
-
-Returns size of the set.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple"])
-
-s0->Belt.MutableSet.String.size /* 1 */
-```
-
-## toList
-
-```res sig
-let toList: t => list<value>
-```
-
-Returns list of ordered set elements.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "watermelon"])
-
-s0->Belt.MutableSet.String.toList /* ["apple", "watermelon"] */
-```
-
-## toArray
-
-```res sig
-let toArray: t => array<value>
-```
-
-Returns array of ordered set elements.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "watermelon"])
-
-s0->Belt.MutableSet.String.toArray /* ["apple", "watermelon"] */
-```
-
-## minimum
-
-```res sig
-let minimum: t => option<value>
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.MutableSet.String.make()
-let s1 = Belt.MutableSet.String.fromArray(["apple", "orange"])
-
-s0->Belt.MutableSet.String.minimum /* None */
-s1->Belt.MutableSet.String.minimum /* Some("apple") */
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t => Js.undefined<value>
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.MutableSet.String.make()
-let s1 = Belt.MutableSet.String.fromArray(["apple", "orange"])
-
-s0->Belt.MutableSet.String.minUndefined /* undefined */
-s1->Belt.MutableSet.String.minUndefined /* "apple" */
-```
-
-## maximum
-
-```res sig
-let maximum: t => option<value>
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.MutableSet.String.make()
-let s1 = Belt.MutableSet.String.fromArray(["apple", "orange"])
-
-s0->Belt.MutableSet.String.maximum /* None */
-s1->Belt.MutableSet.String.maximum /* Some("orange") */
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t => Js.undefined<value>
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.MutableSet.String.make()
-let s1 = Belt.MutableSet.String.fromArray(["apple", "orange"])
-
-s0->Belt.MutableSet.String.maxUndefined /* undefined */
-s1->Belt.MutableSet.String.maxUndefined /* orange */
-```
-
-## get
-
-```res sig
-let get: (t, value) => option<value>
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "carrot"])
-
-s0->Belt.MutableSet.String.get("carrot") /* Some("carrot") */
-s0->Belt.MutableSet.String.get("watermelon") /* None */
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t, value) => Js.undefined<value>
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```res sig
-let getExn: (t, value) => value
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```res sig
-let split: (t, value) => ((t, t), bool)
-```
-
-Returns a tuple `((smaller, larger), present)`, `present` is true when element exist in set.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "banana", "orange"])
-
-let ((smaller, larger), present) = s0->Belt.MutableSet.String.split("banana")
-
-present /* true */
-smaller->Belt.MutableSet.String.toArray /* ["apple"] */
-larger->Belt.MutableSet.String.toArray /* ["orange"] */
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t => unit
-```
-
-**raise** when invariant is not held
diff --git a/pages/docs/manual/v10.0.0/api/belt/mutable-set.mdx b/pages/docs/manual/v10.0.0/api/belt/mutable-set.mdx
deleted file mode 100644
index 371f04de0..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/mutable-set.mdx
+++ /dev/null
@@ -1,711 +0,0 @@
-# MutableSet
-
-<Intro>
-
-A **mutable** sorted set module which allows customize compare behavior.
-The implementation uses balanced binary trees, and therefore searching and insertion take time logarithmic in the size of the map.
-
-It also has three specialized inner modules [Belt.MutableSet.Int](mutable-set-int) and [Belt.MutableSet.String](mutable-set-string) - This module separates data from function which is more verbose but slightly more efficient
-
-</Intro>
-
-```res example
-module PairComparator = Belt.Id.MakeComparable({
-  type t = (int, int)
-  let cmp = ((a0, a1), (b0, b1)) =>
-    switch Pervasives.compare(a0, b0) {
-    | 0 => Pervasives.compare(a1, b1)
-    | c => c
-    }
-})
-
-let mySet = Belt.MutableSet.make(~id=module(PairComparator))
-mySet->Belt.MutableSet.add((1, 2))
-```
-
-## t
-
-```res prelude
-type t<'value, 'id>
-```
-
-`'value` is the element type
-
-`'id` the identity of the collection
-
-## id
-
-```res prelude
-type id<'value, 'id> = Belt_Id.comparable<'value, 'id>
-```
-
-The identity needed for making a set from scratch
-
-## make
-
-```res sig
-let make: (~id: id<'value, 'id>) => t<'value, 'id>
-```
-
-Creates a new set by taking in the comparator
-
-## fromArray
-
-```res sig
-let fromArray: (array<'value>, ~id: id<'value, 'id>) => t<'value, 'id>
-```
-
-Creates new set from array of elements.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([1, 3, 2, 4], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.toArray /* [1, 2, 3, 4] */
-```
-
-## fromSortedArrayUnsafe
-
-```res sig
-let fromSortedArrayUnsafe: (array<'value>, ~id: id<'value, 'id>) => t<'value, 'id>
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## copy
-
-```res sig
-let copy: t<'value, 'id> => t<'value, 'id>
-```
-
-Returns copy of a set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([1, 3, 2, 4], ~id=module(IntCmp))
-
-let copied = s0->Belt.MutableSet.copy
-copied->Belt.MutableSet.toArray /* [1, 2, 3, 4] */
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a, 'b> => bool
-```
-
-Checks if set is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let empty = Belt.MutableSet.fromArray([], ~id=module(IntCmp))
-let notEmpty = Belt.MutableSet.fromArray([1], ~id=module(IntCmp))
-
-Belt.MutableSet.isEmpty(empty) /* true */
-Belt.MutableSet.isEmpty(notEmpty) /* false */
-```
-
-## has
-
-```res sig
-let has: (t<'value, 'a>, 'value) => bool
-```
-
-Checks if element exists in set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let set = Belt.MutableSet.fromArray([1, 4, 2, 5], ~id=module(IntCmp))
-
-set->Belt.MutableSet.has(3) /* false */
-set->Belt.MutableSet.has(1) /* true */
-```
-
-## add
-
-```res sig
-let add: (t<'value, 'id>, 'value) => unit
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.make(~id=module(IntCmp))
-s0->Belt.MutableSet.add(1)
-s0->Belt.MutableSet.add(2)
-s0->Belt.MutableSet.add(2)
-
-s0->Belt.MutableSet.toArray /* [1, 2] */
-```
-
-## addCheck
-
-```res sig
-let addCheck: (t<'value, 'id>, 'value) => bool
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'value, 'id>, array<'value>) => unit
-```
-
-Adds each element of array to set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let set = Belt.MutableSet.make(~id=module(IntCmp))
-
-set->Belt.MutableSet.mergeMany([5, 4, 3, 2, 1])
-set->Belt.MutableSet.toArray /* [1, 2, 3, 4, 5] */
-```
-
-## remove
-
-```res sig
-let remove: (t<'value, 'id>, 'value) => unit
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([2, 3, 1, 4, 5], ~id=module(IntCmp))
-s0->Belt.MutableSet.remove(1)
-s0->Belt.MutableSet.remove(3)
-s0->Belt.MutableSet.remove(3)
-
-s0->Belt.MutableSet.toArray /* [2,4,5] */
-```
-
-## removeCheck
-
-```res sig
-let removeCheck: (t<'value, 'id>, 'value) => bool
-```
-
-## removeMany
-
-```res sig
-let removeMany: (t<'value, 'id>, array<'value>) => unit
-```
-
-Removes each element of array from set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let set = Belt.MutableSet.fromArray([1, 2, 3, 4], ~id=module(IntCmp))
-
-set->Belt.MutableSet.removeMany([5, 4, 3, 2, 1])
-set->Belt.MutableSet.toArray /* [] */
-```
-
-## union
-
-```res sig
-let union: (t<'value, 'id>, t<'value, 'id>) => t<'value, 'id>
-```
-
-Returns union of two sets.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([5, 2, 3, 5, 6], ~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([5, 2, 3, 1, 5, 4], ~id=module(IntCmp))
-let union = Belt.MutableSet.union(s0, s1)
-union->Belt.MutableSet.toArray /* [1,2,3,4,5,6] */
-```
-
-## intersect
-
-```res sig
-let intersect: (t<'value, 'id>, t<'value, 'id>) => t<'value, 'id>
-```
-
-Returns intersection of two sets.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([5, 2, 3, 5, 6], ~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([5, 2, 3, 1, 5, 4], ~id=module(IntCmp))
-let intersect = Belt.MutableSet.intersect(s0, s1)
-intersect->Belt.MutableSet.toArray /* [2,3,5] */
-```
-
-## diff
-
-```res sig
-let diff: (t<'value, 'id>, t<'value, 'id>) => t<'value, 'id>
-```
-
-Returns elements from first set, not existing in second set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([5, 2, 3, 5, 6], ~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([5, 2, 3, 1, 5, 4], ~id=module(IntCmp))
-Belt.MutableSet.toArray(Belt.MutableSet.diff(s0, s1)) /* [6] */
-Belt.MutableSet.toArray(Belt.MutableSet.diff(s1, s0)) /* [1,4] */
-```
-
-## subset
-
-```res sig
-let subset: (t<'value, 'id>, t<'value, 'id>) => bool
-```
-
-Checks if second set is subset of first set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([5, 2, 3, 5, 6], ~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([5, 2, 3, 1, 5, 4], ~id=module(IntCmp))
-let s2 = Belt.MutableSet.intersect(s0, s1)
-Belt.MutableSet.subset(s2, s0) /* true */
-Belt.MutableSet.subset(s2, s1) /* true */
-Belt.MutableSet.subset(s1, s0) /* false */
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'value, 'id>, t<'value, 'id>) => int
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```res sig
-let eq: (t<'value, 'id>, t<'value, 'id>) => bool
-```
-
-Checks if two sets are equal.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([5, 2, 3], ~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([3, 2, 5], ~id=module(IntCmp))
-
-Belt.MutableSet.eq(s0, s1) /* true */
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'value, 'id>, (. 'value) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t<'value, 'id>, 'value => unit) => unit
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([5, 2, 3, 5, 6], ~id=module(IntCmp))
-let acc = ref(list{})
-s0->Belt.MutableSet.forEach(x => acc := Belt.List.add(acc.contents, x))
-acc /* [6,5,3,2] */
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t<'value, 'id>, 'a, (. 'a, 'value) => 'a) => 'a
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'value, 'id>, 'a, ('a, 'value) => 'a) => 'a
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([5, 2, 3, 5, 6], ~id=module(IntCmp))
-s0->Belt.MutableSet.reduce(list{}, (acc, element) => acc->Belt.List.add(element)) /* [6,5,3,2] */
-```
-
-## everyU
-
-```res sig
-let everyU: (t<'value, 'id>, (. 'value) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'value, 'id>, 'value => bool) => bool
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.MutableSet.fromArray([2, 4, 6, 8], ~id=module(IntCmp))
-s0->Belt.MutableSet.every(isEven) /* true */
-```
-
-## someU
-
-```res sig
-let someU: (t<'value, 'id>, (. 'value) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'value, 'id>, 'value => bool) => bool
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.MutableSet.fromArray([1, 2, 4, 6, 8], ~id=module(IntCmp))
-s0->Belt.MutableSet.some(isOdd) /* true */
-```
-
-## keepU
-
-```res sig
-let keepU: (t<'value, 'id>, (. 'value) => bool) => t<'value, 'id>
-```
-
-## keep
-
-```res sig
-let keep: (t<'value, 'id>, 'value => bool) => t<'value, 'id>
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.MutableSet.fromArray([1, 2, 3, 4, 5], ~id=module(IntCmp))
-let s1 = s0->Belt.MutableSet.keep(isEven)
-
-s1->Belt.MutableSet.toArray /* [2, 4] */
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t<'value, 'id>, (. 'value) => bool) => (t<'value, 'id>, t<'value, 'id>)
-```
-
-## partition
-
-```res sig
-let partition: (t<'value, 'id>, 'value => bool) => (t<'value, 'id>, t<'value, 'id>)
-```
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.MutableSet.fromArray([1, 2, 3, 4, 5], ~id=module(IntCmp))
-let (s1, s2) = s0->Belt.MutableSet.partition(isOdd)
-
-s1->Belt.MutableSet.toArray /* [1,3,5] */
-s2->Belt.MutableSet.toArray /* [2,4] */
-```
-
-## size
-
-```res sig
-let size: t<'value, 'id> => int
-```
-
-Returns size of the set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([1, 2, 3, 4], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.size /* 4 */
-```
-
-## toList
-
-```res sig
-let toList: t<'value, 'id> => list<'value>
-```
-
-Returns list of ordered set elements.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([3, 2, 1, 5], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.toList /* [1,2,3,5] */
-```
-
-## toArray
-
-```res sig
-let toArray: t<'value, 'id> => array<'value>
-```
-
-Returns array of ordered set elements.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([3, 2, 1, 5], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.toArray /* [1,2,3,5] */
-```
-
-## minimum
-
-```res sig
-let minimum: t<'value, 'id> => option<'value>
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.make(~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([3, 2, 1, 5], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.minimum /* None */
-s1->Belt.MutableSet.minimum /* Some(1) */
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'value, 'id> => Js.undefined<'value>
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.make(~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([3, 2, 1, 5], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.minUndefined /* undefined */
-s1->Belt.MutableSet.minUndefined /* 1 */
-```
-
-## maximum
-
-```res sig
-let maximum: t<'value, 'id> => option<'value>
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.make(~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([3, 2, 1, 5], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.maximum /* None */
-s1->Belt.MutableSet.maximum /* Some(5) */
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'value, 'id> => Js.undefined<'value>
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.make(~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([3, 2, 1, 5], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.maxUndefined /* undefined */
-s1->Belt.MutableSet.maxUndefined /* 5 */
-```
-
-## get
-
-```res sig
-let get: (t<'value, 'id>, 'value) => option<'value>
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([1, 2, 3, 4, 5], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.get(3) /* Some(3) */
-s0->Belt.MutableSet.get(20) /* None */
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'value, 'id>, 'value) => Js.undefined<'value>
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```res sig
-let getExn: (t<'value, 'id>, 'value) => 'value
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```res sig
-let split: (t<'value, 'id>, 'value) => ((t<'value, 'id>, t<'value, 'id>), bool)
-```
-
-Returns a tuple `((smaller, larger), present)`, `present` is true when element exist in set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([1, 2, 3, 4, 5], ~id=module(IntCmp))
-
-let ((smaller, larger), present) = s0->Belt.MutableSet.split(3)
-
-present /* true */
-smaller->Belt.MutableSet.toArray /* [1,2] */
-larger->Belt.MutableSet.toArray /* [4,5] */
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t<'a, 'b> => unit
-```
-
-**raise** when invariant is not held
diff --git a/pages/docs/manual/v10.0.0/api/belt/mutable-stack.mdx b/pages/docs/manual/v10.0.0/api/belt/mutable-stack.mdx
deleted file mode 100644
index d8c51f494..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/mutable-stack.mdx
+++ /dev/null
@@ -1,105 +0,0 @@
-# MutableStack
-
-<Intro>
-
-First in last out stack. This module implements stacks, with in-place modification.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a>
-```
-
-## make
-
-```res sig
-let make: unit => t<'a>
-```
-
-Returns a new stack, initially empty.
-
-## clear
-
-```res sig
-let clear: t<'a> => unit
-```
-
-Discard all elements from the stack.
-
-## copy
-
-```res sig
-let copy: t<'a> => t<'a>
-```
-
-`copy(x)` O(1) operation, return a new stack.
-
-## push
-
-```res sig
-let push: (t<'a>, 'a) => unit
-```
-
-## popUndefined
-
-```res sig
-let popUndefined: t<'a> => Js.undefined<'a>
-```
-
-## pop
-
-```res sig
-let pop: t<'a> => option<'a>
-```
-
-## topUndefined
-
-```res sig
-let topUndefined: t<'a> => Js.undefined<'a>
-```
-
-## top
-
-```res sig
-let top: t<'a> => option<'a>
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a> => bool
-```
-
-## size
-
-```res sig
-let size: t<'a> => int
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'a>, (. 'a) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'a>, 'a => unit) => unit
-```
-
-## dynamicPopIterU
-
-```res sig
-let dynamicPopIterU: (t<'a>, (. 'a) => unit) => unit
-```
-
-## dynamicPopIter
-
-```res sig
-let dynamicPopIter: (t<'a>, 'a => unit) => unit
-```
-
-`dynamicPopIter(s, f)` apply `f` to each element of `s`. The item is poped before applying `f`, `s` will be empty after this opeartion. This function is useful for worklist algorithm.
diff --git a/pages/docs/manual/v10.0.0/api/belt/option.mdx b/pages/docs/manual/v10.0.0/api/belt/option.mdx
deleted file mode 100644
index 4e80c7b89..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/option.mdx
+++ /dev/null
@@ -1,256 +0,0 @@
-# Option
-
-<Intro>
-
-In Belt we represent the existence and nonexistence of a value by wrapping it
-with the `option` type.  In order to make it a bit more convenient to work with
-option-types, Belt provides utility-functions for it.
-
-The `option` type is a part of the Reason / OCaml standard library which is defined like this:
-
-</Intro>
-
-```res sig
-type option<'a> = None | Some('a)
-```
-
-```res example
-let someString: option<string> = Some("hello")
-```
-
-## getExn
-
-```res sig
-let getExn: option<'a> => 'a
-```
-
-Raises an Error in case `None` is provided. Use with care.
-
-```res example
-Belt.Option.getExn(Some(3)) /* 3 */
-
-Belt.Option.getExn(None) /* Raises an Error */
-```
-
-## mapWithDefault
-
-```res sig
-let mapWithDefault: (option<'a>, 'b, 'a => 'b) => 'b
-```
-
-If `optionValue` is of `Some(value)`,
-this function returns that value applied with `f`, in other words `f(value)`.
-
-If `optionValue` is `None`, the default is returned.
-
-```res example
-let someValue = Some(3)
-someValue->Belt.Option.mapWithDefault(0, x => x + 5) /* 8 */
-
-let noneValue = None
-noneValue->Belt.Option.mapWithDefault(0, x => x + 5) /* 0 */
-```
-
-## mapWithDefaultU
-
-```res sig
-let mapWithDefaultU: (option<'a>, 'b, (. 'a) => 'b) => 'b
-```
-
-Uncurried version of [mapWithDefault](#mapWithDefault).
-
-## map
-
-```res sig
-let map: (option<'a>, 'a => 'b) => option<'b>
-```
-
-If `optionValue` is `Some(value)` this returns `f(value)`, otherwise it returns `None`.
-
-```res example
-Belt.Option.map(Some(3), x => x * x) /* Some(9) */
-
-Belt.Option.map(None, x => x * x) /* None */
-```
-
-## mapU
-
-```res sig
-let mapU: (option<'a>, (. 'a) => 'b) => option<'b>
-```
-
-Uncurried version of [map](#map).
-
-## flatMap
-
-```res sig
-let flatMap: (option<'a>, 'a => option<'b>) => option<'b>
-```
-
-If `optionValue` is `Some(value)`, returns `f(value)`, otherwise returns
-`None`.<br/>
-The function `f` must have a return type of `option<'b>`.
-
-```res example
-let addIfAboveOne = value =>
-  if (value > 1) {
-    Some(value + 1)
-  } else {
-    None
-  }
-
-Belt.Option.flatMap(Some(2), addIfAboveOne) /* Some(3) */
-
-Belt.Option.flatMap(Some(-4), addIfAboveOne) /* None */
-
-Belt.Option.flatMap(None, addIfAboveOne) /* None */
-```
-
-## flatMapU
-
-```res sig
-let flatMapU: (option<'a>, (. 'a) => option<'b>) => option<'b>
-```
-
-Uncurried version of flatMap.
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (option<'a>, 'a) => 'a
-```
-
-If `optionalValue` is `Some(value)`, returns `value`, otherwise default.
-
-```res example
-Belt.Option.getWithDefault(None, "Banana") /* Banana */
-
-Belt.Option.getWithDefault(Some("Apple"), "Banana") /* Apple */
-```
-
-```res example
-let greet = (firstName: option<string>) =>
-  "Greetings " ++ firstName->Belt.Option.getWithDefault("Anonymous")
-
-Some("Jane")->greet /* "Greetings Jane" */
-
-None->greet /* "Greetings Anonymous" */
-```
-
-```res example
-Belt.Option.getWithDefault(Some(1812), 1066) /* 1812 */
-
-Belt.Option.getWithDefault(None, 1066) /* 1066 */
-```
-
-## isSome
-
-```res sig
-let isSome: option<'a> => bool
-```
-
-Returns `true` if the argument is `Some(value)`, `false` otherwise.
-
-```res example
-Belt.Option.isSome(None) /* false */
-
-Belt.Option.isSome(Some(1)) /* true */
-```
-
-## isNone
-
-```res sig
-let isNone: option<'a> => bool
-```
-
-Returns `true` if the argument is `None`, `false` otherwise.
-
-```res example
-Belt.Option.isNone(None) /* true */
-
-Belt.Option.isNone(Some(1)) /* false */
-```
-
-## eq
-
-```res sig
-let eq: (option<'a>, option<'b>, ('a, 'b) => bool) => bool
-```
-
-Evaluates two optional values for equality with respect to a predicate
-function. If both `optValue1` and `optValue2` are `None`, returns `true`.
-If one of the arguments is `Some(value)` and the other is `None`, returns
-`false`.
-
-If arguments are `Some(value1)` and `Some(value2)`, returns the result of
-`predicate(value1, value2)`; the predicate function must return a bool.
-
-```res example
-let clockEqual = (a, b) => mod(a, 12) == mod(b, 12)
-
-open Belt.Option
-
-eq(Some(3), Some(15), clockEqual) /* true */
-
-eq(Some(3), None, clockEqual) /* false */
-
-eq(None, Some(3), clockEqual) /* false */
-
-eq(None, None, clockEqual) /* true */
-```
-
-## eqU
-
-```res sig
-let eqU: (option<'a>, option<'b>, (.'a, 'b) => bool) => bool
-```
-
-Uncurried version of [eq](#eq).
-
-## cmp
-
-```res sig
-let cmp: (option<'a>, option<'b>, ('a, 'b) => int) => int
-```
-
-`cmp(optValue1, optValue2, comparisonFunction)` compares two optional values
-with respect to given `comparisonFunction`.
-
-If both `optValue1` and `optValue2` are `None`, it returns `0`.
-
-If the first argument is `Some(value1)` and the second is `None`, returns `1`
-(something is greater than nothing).
-
-If the first argument is `None` and the second is `Some(value2)`, returns `-1`
-(nothing is less than something).
-
-If the arguments are `Some(value1)` and `Some(value2)`, returns the result of
-`comparisonFunction(value1, value2)`; comparisonFunction takes two arguments
-and returns `-1` if the first argument is less than the second, `0` if the
-arguments are equal, and `1` if the first argument is greater than the second.
-
-```res example
-let clockCompare = (a, b) => compare(mod(a, 12), mod(b, 12))
-
-open Belt.Option
-
-cmp(Some(3), Some(15), clockCompare) /* 0 */
-
-cmp(Some(3), Some(14), clockCompare) /* 1 */
-
-cmp(Some(2), Some(15), clockCompare) /* (-1) */
-
-cmp(None, Some(15), clockCompare) /* (-1) */
-
-cmp(Some(14), None, clockCompare) /* 1 */
-
-cmp(None, None, clockCompare) /* 0 */
-```
-
-## cmpU
-
-```res sig
-let cmpU: (option<'a>, option<'b>, ((.'a, 'b) => int)) => int
-```
-
-Uncurried version of [cmp](#cmp).
diff --git a/pages/docs/manual/v10.0.0/api/belt/range.mdx b/pages/docs/manual/v10.0.0/api/belt/range.mdx
deleted file mode 100644
index 9223d2dc7..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/range.mdx
+++ /dev/null
@@ -1,130 +0,0 @@
-# Range
-
-<Intro>
-
-A small utility module to provide inclusive range operations for `[start,
-finish]`.  Internally it is relying on loops instead of creating new arrays,
-which makes it pretty performant and memory friendly.
-
-</Intro>
-
-## forEachU
-
-```res sig
-let forEachU: (int, int, (. int) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (int, int, int => unit) => unit
-```
-
-`forEach(start, finish, action)`
-
-equivalent to `Belt.Array.(forEach(range(start, finish), action))`
-
-```res example
-Belt.Range.forEach(0, 4, (i) => Js.log(i))
-
-/*
- * prints:
- *   0
- *   1
- *   2
- *   3
- *   4
- */
-```
-
-## everyU
-
-```res sig
-let everyU: (int, int, (. int) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (int, int, int => bool) => bool
-```
-
-`every(start, finish, p)`
-
-equivalent to `Belt.Array.(every(range(start, finish), p))`
-
-```res example
-Belt.Range.every(0, 4, (i) => i < 5) /* true */
-
-Belt.Range.every(0, 4, (i) => i < 4) /* false */
-```
-
-## everyByU
-
-```res sig
-let everyByU: (int, int, ~step: int, (. int) => bool) => bool
-```
-
-## everyBy
-
-```res sig
-let everyBy: (int, int, ~step: int, int => bool) => bool
-```
-
-`everyBy(start, finish, ~step, p)`
-
-See `Belt_Array.rangeBy`
-
-equivalent to `Belt.Array.(every(rangeBy(start, finish, ~step), p))`
-
-```res example
-Belt.Range.everyBy(0, 4, ~step=1, (i) => mod(i, 2) === 0) /* false */
-
-Belt.Range.everyBy(0, 4, ~step=2, (i) => mod(i, 2) === 0) /* true */
-```
-
-## someU
-
-```res sig
-let someU: (int, int, (. int) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (int, int, int => bool) => bool
-```
-
-`some(start, finish, p)`
-
-equivalent to `Belt.Array.(some(range(start, finish), p))`
-
-```res example
-Belt.Range.some(0, 4, (i) => i > 5) /* false */
-
-Belt.Range.some(0, 4, (i) => i > 2) /* true */
-```
-
-## someByU
-
-```res sig
-let someByU: (int, int, ~step: int, (. int) => bool) => bool
-```
-
-## someBy
-
-```res sig
-let someBy: (int, int, ~step: int, int => bool) => bool
-```
-
-`someBy(start, finish, ~step, p)`
-
-See `Belt_Array.rangeBy`
-
-equivalent to `Belt.Array.(some(rangeBy(start, finish, ~step), p))`
-
-```res example
-Belt.Range.someBy(1, 5, ~step=2, (i) => mod(i, 2) === 0) /* false */
-
-Belt.Range.someBy(0, 4, ~step=2, (i) => mod(i, 2) === 0) /* true */
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/result.mdx b/pages/docs/manual/v10.0.0/api/belt/result.mdx
deleted file mode 100644
index a6106ed33..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/result.mdx
+++ /dev/null
@@ -1,242 +0,0 @@
-# Result
-
-<Intro>
-
-Result types are really useful to describe the result of a certain operation
-without relying on exceptions or `option` types.
-
-This module gives you useful utilities to create and combine `Result` data.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a, 'b> =
-  | Ok('a)
-  | Error('b)
-```
-
-The type `Result.t<result, err>` describes a variant of two states:
-`Ok(someResult)` represents a successful operation, whereby
-``Error(someError)` signals an erronous operation.
-
-In this concrete example, we are defining our own `Result` type to reflect an HTTP like
-query operation:
-
-```res example
-type responseError = NotAvailable | NotFound
-type queryResult = t<string, responseError>
-
-let failQueryUser = (username: string): queryResult => {
-  Error(NotAvailable)
-}
-```
-
-## getExn
-
-```res sig
-let getExn: t<'a, 'b> => 'a
-```
-
-`getExn(res)`: when `res` is `Ok(n)`, returns `n` when `res` is `Error(m)`, raise an exception
-
-```res example
-Belt.Result.getExn(Belt.Result.Ok(42)) == 42
-
-Belt.Result.getExn(Belt.Result.Error("Invalid data")) /* raises exception */
-```
-
-## mapWithDefaultU
-
-```res sig
-let mapWithDefaultU: (t<'a, 'c>, 'b, (. 'a) => 'b) => 'b
-```
-
-## mapWithDefault
-
-```res sig
-let mapWithDefault: (t<'a, 'c>, 'b, 'a => 'b) => 'b
-```
-
-`mapWithDefault(res, default, f)`: When res is `Ok(n)`, returns `f(n)`,
-otherwise `default`.
-
-```res example
-let ok = Belt.Result.Ok(42)
-Belt.Result.mapWithDefault(ok, 0, (x) => x / 2) == 21
-
-let error = Belt.Result.Error("Invalid data")
-Belt.Result.mapWithDefault(error, 0, (x) => x / 2) == 0
-```
-
-## mapU
-
-```res sig
-let mapU: (t<'a, 'c>, (. 'a) => 'b) => t<'b, 'c>
-```
-
-## map
-
-```res sig
-let map: (t<'a, 'c>, 'a => 'b) => t<'b, 'c>
-```
-
-`map(res, f)`: When res is `Ok(n)`, returns `Ok(f(n))`. Otherwise returns res
-unchanged. Function `f` takes a value of the same type as `n` and returns an
-ordinary value.
-
-```res example
-let f = (x) => sqrt(Belt.Int.toFloat(x))
-
-Belt.Result.map(Ok(64), f) == Ok(8.0)
-
-Belt.Result.map(Error("Invalid data"), f) == Error("Invalid data")
-```
-
-## flatMapU
-
-```res sig
-let flatMapU: (t<'a, 'c>, (. 'a) => t<'b, 'c>) => t<'b, 'c>
-```
-
-## flatMap
-
-```res sig
-let flatMap: (t<'a, 'c>, 'a => t<'b, 'c>) => t<'b, 'c>
-```
-
-`flatMap(res, f)`: When res is `Ok(n)`, returns `f(n)`. Otherwise, returns res
-unchanged. Function `f` takes a value of the same type as `n` and returns a
-`Belt.Result`.
-
-```res example
-let recip = (x) =>
-  if (x !== 0.0) {
-    Belt.Result.Ok(1.0 /. x)
-  } else {
-    Belt.Result.Error("Divide by zero")
-  }
-
-Belt.Result.flatMap(Ok(2.0), recip) == Ok(0.5)
-
-Belt.Result.flatMap(Ok(0.0), recip) == Error("Divide by zero")
-
-Belt.Result.flatMap(Error("Already bad"), recip) == Error("Already bad")
-```
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (t<'a, 'b>, 'a) => 'a
-```
-
-`getWithDefault(res, defaultValue)`: If `res` is `Ok(n)`, returns `n`,
-otherwise `default`
-
-```res example
-Belt.Result.getWithDefault(Ok(42), 0) == 42
-
-Belt.Result.getWithDefault(Error("Invalid Data"), 0) == 0
-```
-
-## isOk
-
-```res sig
-let isOk: t<'a, 'b> => bool
-```
-
-`isOk(res)`: Returns `true` if `res` is of the form `Ok(n)`, `false` if it is
-the `Error(e)` variant.
-
-## isError
-
-```res sig
-let isError: t<'a, 'b> => bool
-```
-
-`isError(res)`: Returns `true` if `res` is of the form `Error(e)`, `false` if
-it is the `Ok(n)` variant.
-
-## eqU
-
-```res sig
-let eqU: (t<'a, 'c>, t<'b, 'd>, (. 'a, 'b) => bool) => bool
-```
-
-## eq
-
-```res sig
-let eq: (t<'a, 'c>, t<'b, 'd>, ('a, 'b) => bool) => bool
-```
-
-`eq(res1, res2, f)`: Determine if two `Belt.Result` variables are equal with
-respect to an equality function. If `res1` and `res2` are of the form `Ok(n)`
-and `Ok(m)`, return the result of `f(n, m)`. If one of `res1` and `res2` are of
-the form `Error(e)`, return false If both `res1` and `res2` are of the form
-`Error(e)`, return true
-
-```res example
-let good1 = Belt.Result.Ok(42)
-
-let good2 = Belt.Result.Ok(32)
-
-let bad1 = Belt.Result.Error("invalid")
-
-let bad2 = Belt.Result.Error("really invalid")
-
-let mod10equal = (a, b) => mod(a, 10) === mod(b, 10)
-
-Belt.Result.eq(good1, good2, mod10equal) == true
-
-Belt.Result.eq(good1, bad1, mod10equal) == false
-
-Belt.Result.eq(bad2, good2, mod10equal) == false
-
-Belt.Result.eq(bad1, bad2, mod10equal) == true
-```
-
-## cmpU
-
-```res sig
-let cmpU: (t<'a, 'c>, t<'b, 'd>, (. 'a, 'b) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'a, 'c>, t<'b, 'd>, ('a, 'b) => int) => int
-```
-
-`cmp(res1, res2, f)`: Compare two `Belt.Result` variables with respect to a
-comparison function. The comparison function returns -1 if the first variable
-is "less than" the second, 0 if the two variables are equal, and 1 if the first
-is "greater than" the second.
-
-If `res1` and `res2` are of the form `Ok(n)` and `Ok(m)`, return the result of
-`f(n, m)`. If `res1` is of the form `Error(e)` and `res2` of the form `Ok(n)`,
-return -1 (nothing is less than something) If `res1` is of the form `Ok(n)` and
-`res2` of the form `Error(e)`, return 1 (something is greater than nothing) If
-both `res1` and `res2` are of the form `Error(e)`, return 0 (equal)
-
-```res example
-let good1 = Belt.Result.Ok(59)
-
-let good2 = Belt.Result.Ok(37)
-
-let bad1 = Belt.Result.Error("invalid")
-
-let bad2 = Belt.Result.Error("really invalid")
-
-let mod10cmp = (a, b) => Pervasives.compare(mod(a, 10), mod(b, 10))
-
-Belt.Result.cmp(Ok(39), Ok(57), mod10cmp) == 1
-
-Belt.Result.cmp(Ok(57), Ok(39), mod10cmp) == (-1)
-
-Belt.Result.cmp(Ok(39), Error("y"), mod10cmp) == 1
-
-Belt.Result.cmp(Error("x"), Ok(57), mod10cmp) == (-1)
-
-Belt.Result.cmp(Error("x"), Error("y"), mod10cmp) == 0
-```
diff --git a/pages/docs/manual/v10.0.0/api/belt/set-dict.mdx b/pages/docs/manual/v10.0.0/api/belt/set-dict.mdx
deleted file mode 100644
index c5b4f893e..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/set-dict.mdx
+++ /dev/null
@@ -1,680 +0,0 @@
-# SetDict
-
-<Intro>
-
-This module separates identity from data. It is a bit more verbose but slightly more efficient due to the fact that there is no need to pack identity and data back after each operation.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'value, 'identity>
-```
-
-`'value` is the element type
-
-`'identity` the identity of the collection
-
-## cmp
-
-```res prelude
-type cmp<'value, 'id> = Belt.Id.cmp<'value, 'id>
-```
-
-Type of compare function.
-
-## empty
-
-```res sig
-let empty: t<'value, 'id>
-```
-
-```res example
-let s0 = Belt.Set.Dict.empty
-```
-
-## fromArray
-
-```res sig
-let fromArray: (array<'value>, ~cmp: cmp<'value, 'id>) => t<'value, 'id>
-```
-
-Creates new set from array of elements.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([1, 3, 2, 4], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.toArray /* [1, 2, 3, 4] */
-```
-
-## fromSortedArrayUnsafe
-
-```res sig
-let fromSortedArrayUnsafe: array<'value> => t<'value, 'id>
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a, 'b> => bool
-```
-
-Checks if set is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let empty = Belt.Set.Dict.fromArray([], ~cmp=IntCmp.cmp)
-let notEmpty = Belt.Set.Dict.fromArray([1], ~cmp=IntCmp.cmp)
-
-Belt.Set.Dict.isEmpty(empty) /* true */
-Belt.Set.Dict.isEmpty(notEmpty) /* false */
-```
-
-## has
-
-```res sig
-let has: (t<'value, 'id>, 'value, ~cmp: cmp<'value, 'id>) => bool
-```
-
-Checks if an element exists in the set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let set = Belt.Set.Dict.fromArray([1, 4, 2, 5], ~cmp=IntCmp.cmp)
-
-set->Belt.Set.Dict.has(3, ~cmp=IntCmp.cmp) /* false */
-set->Belt.Set.Dict.has(1, ~cmp=IntCmp.cmp) /* true */
-```
-
-## add
-
-```res sig
-let add: (t<'value, 'id>, 'value, ~cmp: cmp<'value, 'id>) => t<'value, 'id>
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.empty
-let s1 = s0->Belt.Set.Dict.add(1, ~cmp=IntCmp.cmp)
-let s2 = s1->Belt.Set.Dict.add(2, ~cmp=IntCmp.cmp)
-let s3 = s2->Belt.Set.Dict.add(2, ~cmp=IntCmp.cmp)
-s0->Belt.Set.Dict.toArray /* [] */
-s1->Belt.Set.Dict.toArray /* [1] */
-s2->Belt.Set.Dict.toArray /* [1, 2] */
-s3->Belt.Set.Dict.toArray /* [1,2 ] */
-s2 == s3 /* true */
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'value, 'id>, array<'value>, ~cmp: cmp<'value, 'id>) => t<'value, 'id>
-```
-
-Adds each element of array to set. Unlike [add](#add), the reference of return value might be changed even if all values in array already exist in set
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let set = Belt.Set.Dict.empty
-
-let newSet = set->Belt.Set.Dict.mergeMany([5, 4, 3, 2, 1], ~cmp=IntCmp.cmp)
-newSet->Belt.Set.Dict.toArray /* [1, 2, 3, 4, 5] */
-```
-
-## remove
-
-```res sig
-let remove: (t<'value, 'id>, 'value, ~cmp: cmp<'value, 'id>) => t<'value, 'id>
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([2, 3, 1, 4, 5], ~cmp=IntCmp.cmp)
-let s1 = s0->Belt.Set.Dict.remove(1, ~cmp=IntCmp.cmp)
-let s2 = s1->Belt.Set.Dict.remove(3, ~cmp=IntCmp.cmp)
-let s3 = s2->Belt.Set.Dict.remove(3, ~cmp=IntCmp.cmp)
-
-s1->Belt.Set.Dict.toArray /* [2,3,4,5] */
-s2->Belt.Set.Dict.toArray /* [2,4,5] */
-s2 == s3 /* true */
-```
-
-## removeMany
-
-```res sig
-let removeMany: (t<'value, 'id>, array<'value>, ~cmp: cmp<'value, 'id>) => t<'value, 'id>
-```
-
-Removes each element of array from set. Unlike [remove](#remove), the reference of return value might be changed even if any values in array not existed in set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let set = Belt.Set.Dict.fromArray([1, 2, 3, 4], ~cmp=IntCmp.cmp)
-
-let newSet = set->Belt.Set.Dict.removeMany([5, 4, 3, 2, 1], ~cmp=IntCmp.cmp)
-newSet->Belt.Set.Dict.toArray /* [] */
-```
-
-## union
-
-```res sig
-let union: (t<'value, 'id>, t<'value, 'id>, ~cmp: cmp<'value, 'id>) => t<'value, 'id>
-```
-
-Returns union of two sets.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([5, 2, 3, 5, 6], ~cmp=IntCmp.cmp)
-let s1 = Belt.Set.Dict.fromArray([5, 2, 3, 1, 5, 4], ~cmp=IntCmp.cmp)
-let union = Belt.Set.Dict.union(s0, s1, ~cmp=IntCmp.cmp)
-union->Belt.Set.Dict.toArray /* [1,2,3,4,5,6] */
-```
-
-## intersect
-
-```res sig
-let intersect: (t<'value, 'id>, t<'value, 'id>, ~cmp: cmp<'value, 'id>) => t<'value, 'id>
-```
-
-Returns intersection of two sets.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([5, 2, 3, 5, 6], ~cmp=IntCmp.cmp)
-let s1 = Belt.Set.Dict.fromArray([5, 2, 3, 1, 5, 4], ~cmp=IntCmp.cmp)
-let intersect = Belt.Set.Dict.intersect(s0, s1, ~cmp=IntCmp.cmp)
-intersect->Belt.Set.Dict.toArray /* [2,3,5] */
-```
-
-## diff
-
-```res sig
-let diff: (t<'value, 'id>, t<'value, 'id>, ~cmp: cmp<'value, 'id>) => t<'value, 'id>
-```
-
-Returns elements from first set, not existing in second set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([5, 2, 3, 5, 6], ~cmp=IntCmp.cmp)
-let s1 = Belt.Set.Dict.fromArray([5, 2, 3, 1, 5, 4], ~cmp=IntCmp.cmp)
-
-let diff1 = Belt.Set.Dict.diff(s0, s1, ~cmp=IntCmp.cmp)
-let diff2 = Belt.Set.Dict.diff(s1, s0, ~cmp=IntCmp.cmp)
-
-diff1->Belt.Set.Dict.toArray /* [6] */
-diff2->Belt.Set.Dict.toArray /* [1,4] */
-```
-
-## subset
-
-```res sig
-let subset: (t<'value, 'id>, t<'value, 'id>, ~cmp: cmp<'value, 'id>) => bool
-```
-
-Checks if second set is subset of first set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([5, 2, 3, 5, 6], ~cmp=IntCmp.cmp)
-let s1 = Belt.Set.Dict.fromArray([5, 2, 3, 1, 5, 4], ~cmp=IntCmp.cmp)
-let s2 = Belt.Set.Dict.intersect(s0, s1, ~cmp=IntCmp.cmp)
-Belt.Set.Dict.subset(s2, s0, ~cmp=IntCmp.cmp) /* true */
-Belt.Set.Dict.subset(s2, s1, ~cmp=IntCmp.cmp) /* true */
-Belt.Set.Dict.subset(s1, s0, ~cmp=IntCmp.cmp) /* false */
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'value, 'id>, t<'value, 'id>, ~cmp: cmp<'value, 'id>) => int
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```res sig
-let eq: (t<'value, 'id>, t<'value, 'id>, ~cmp: cmp<'value, 'id>) => bool
-```
-
-Checks if two sets are equal.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([5, 2, 3], ~cmp=IntCmp.cmp)
-let s1 = Belt.Set.Dict.fromArray([3, 2, 5], ~cmp=IntCmp.cmp)
-
-Belt.Set.Dict.eq(s0, s1, ~cmp=IntCmp.cmp) /* true */
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'value, 'id>, (. 'value) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t<'value, 'id>, 'value => unit) => unit
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([5, 2, 3, 5, 6], ~cmp=IntCmp.cmp)
-let acc = ref(list{})
-s0->Belt.Set.Dict.forEach(x => acc := Belt.List.add(acc.contents, x))
-acc /* [6,5,3,2] */
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t<'value, 'id>, 'a, (. 'a, 'value) => 'a) => 'a
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'value, 'id>, 'a, ('a, 'value) => 'a) => 'a
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([5, 2, 3, 5, 6], ~cmp=IntCmp.cmp)
-s0->Belt.Set.Dict.reduce(list{}, (acc, element) => acc->Belt.List.add(element)) /* [6,5,3,2] */
-```
-
-## everyU
-
-```res sig
-let everyU: (t<'value, 'id>, (. 'value) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'value, 'id>, 'value => bool) => bool
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.Set.Dict.fromArray([2, 4, 6, 8], ~cmp=IntCmp.cmp)
-s0->Belt.Set.Dict.every(isEven) /* true */
-```
-
-## someU
-
-```res sig
-let someU: (t<'value, 'id>, (. 'value) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'value, 'id>, 'value => bool) => bool
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.Set.Dict.fromArray([1, 2, 4, 6, 8], ~cmp=IntCmp.cmp)
-s0->Belt.Set.Dict.some(isOdd) /* true */
-```
-
-## keepU
-
-```res sig
-let keepU: (t<'value, 'id>, (. 'value) => bool) => t<'value, 'id>
-```
-
-## keep
-
-```res sig
-let keep: (t<'value, 'id>, 'value => bool) => t<'value, 'id>
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.Set.Dict.fromArray([1, 2, 3, 4, 5], ~cmp=IntCmp.cmp)
-let s1 = s0->Belt.Set.Dict.keep(isEven)
-
-s1->Belt.Set.Dict.toArray /* [2,4] */
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t<'value, 'id>, (. 'value) => bool) => (t<'value, 'id>, t<'value, 'id>)
-```
-
-## partition
-
-```res sig
-let partition: (t<'value, 'id>, 'value => bool) => (t<'value, 'id>, t<'value, 'id>)
-```
-
-Returns a pair of sets, where first is the set of all the elements of set that satisfy the predicate, and second is the set of all the elements of set that do not satisfy the predicate.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.Set.Dict.fromArray([1, 2, 3, 4, 5], ~cmp=IntCmp.cmp)
-let (s1, s2) = s0->Belt.Set.Dict.partition(isOdd)
-
-s1->Belt.Set.Dict.toArray /* [1,3,5] */
-s2->Belt.Set.Dict.toArray /* [2,4] */
-```
-
-## size
-
-```res sig
-let size: t<'value, 'id> => int
-```
-
-Returns size of the set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([1, 2, 3, 4], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.size /* 4 */
-```
-
-## toList
-
-```res sig
-let toList: t<'value, 'id> => list<'value>
-```
-
-Returns list of ordered set elements.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([3, 2, 1, 5], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.toList /* [1,2,3,5] */
-```
-
-## toArray
-
-```res sig
-let toArray: t<'value, 'id> => array<'value>
-```
-
-Returns array of ordered set elements.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([3, 2, 1, 5], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.toArray /* [1,2,3,5] */
-```
-
-## minimum
-
-```res sig
-let minimum: t<'value, 'id> => option<'value>
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.empty
-let s1 = Belt.Set.Dict.fromArray([3, 2, 1, 5], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.minimum /* None */
-s1->Belt.Set.Dict.minimum /* Some(1) */
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'value, 'id> => Js.undefined<'value>
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.empty
-let s1 = Belt.Set.Dict.fromArray([3, 2, 1, 5], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.minUndefined /* undefined */
-s1->Belt.Set.Dict.minUndefined /* 1 */
-```
-
-## maximum
-
-```res sig
-let maximum: t<'value, 'id> => option<'value>
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.empty
-let s1 = Belt.Set.Dict.fromArray([3, 2, 1, 5], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.maximum /* None */
-s1->Belt.Set.Dict.maximum /* Some(5) */
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'value, 'id> => Js.undefined<'value>
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.empty
-let s1 = Belt.Set.Dict.fromArray([3, 2, 1, 5], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.maxUndefined /* undefined */
-s1->Belt.Set.Dict.maxUndefined /* 5 */
-```
-
-## get
-
-```res sig
-let get: (t<'value, 'id>, 'value, ~cmp: cmp<'value, 'id>) => option<'value>
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([1, 2, 3, 4, 5], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.get(3, ~cmp=IntCmp.cmp) /* Some(3) */
-s0->Belt.Set.Dict.get(20, ~cmp=IntCmp.cmp) /* None */
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'value, 'id>, 'value, ~cmp: cmp<'value, 'id>) => Js.undefined<'value>
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```res sig
-let getExn: (t<'value, 'id>, 'value, ~cmp: cmp<'value, 'id>) => 'value
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```res sig
-let split: (
-  t<'value, 'id>,
-  'value,
-  ~cmp: cmp<'value, 'id>,
-) => ((t<'value, 'id>, t<'value, 'id>), bool)
-```
-
-Returns a tuple `((smaller, larger), present)`, `present` is true when element exist in set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([1, 2, 3, 4, 5], ~cmp=IntCmp.cmp)
-
-let ((smaller, larger), present) = s0->Belt.Set.Dict.split(3, ~cmp=IntCmp.cmp)
-
-present /* true */
-smaller->Belt.Set.Dict.toArray /* [1,2] */
-larger->Belt.Set.Dict.toArray /* [4,5] */
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t<'a, 'b> => unit
-```
-
-**raise** when invariant is not held
-
diff --git a/pages/docs/manual/v10.0.0/api/belt/set-int.mdx b/pages/docs/manual/v10.0.0/api/belt/set-int.mdx
deleted file mode 100644
index 24e865e32..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/set-int.mdx
+++ /dev/null
@@ -1,537 +0,0 @@
-# SetInt
-
-<Intro>
-
-Specialized when value type is `int`, more efficient than the generic type, its compare behavior is fixed using the built-in comparison.
-
-</Intro>
-
-## value
-
-```res prelude
-type value = int
-```
-
-The type of the set elements.
-
-## t
-
-```res prelude
-type t
-```
-
-Type of the sets.
-
-## empty
-
-```res sig
-let empty: t
-```
-
-Empty set
-
-```res example
-let s0 = Belt.Set.Int.empty
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<value> => t
-```
-
-Creates new set from array of elements.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([1, 3, 2, 4])
-
-s0->Belt.Set.Int.toArray /* [1, 2, 3, 4] */
-```
-
-## fromSortedArrayUnsafe
-
-```res sig
-let fromSortedArrayUnsafe: array<value> => t
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## isEmpty
-
-```res sig
-let isEmpty: t => bool
-```
-
-Checks if set is empty.
-
-```res example
-let empty = Belt.Set.Int.fromArray([])
-let notEmpty = Belt.Set.Int.fromArray([1])
-
-Belt.Set.Int.isEmpty(empty) /* true */
-Belt.Set.Int.isEmpty(notEmpty) /* false */
-```
-
-## has
-
-```res sig
-let has: (t, value) => bool
-```
-
-Checks if element exists in set.
-
-```res example
-let set = Belt.Set.Int.fromArray([1, 4, 2, 5])
-
-set->Belt.Set.Int.has(3) /* false */
-set->Belt.Set.Int.has(1) /* true */
-```
-
-## add
-
-```res sig
-let add: (t, value) => t
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.Set.Int.empty
-let s1 = s0->Belt.Set.Int.add(1)
-let s2 = s1->Belt.Set.Int.add(2)
-let s3 = s2->Belt.Set.Int.add(2)
-s0->Belt.Set.Int.toArray /* [] */
-s1->Belt.Set.Int.toArray /* [1] */
-s2->Belt.Set.Int.toArray /* [1, 2] */
-s3->Belt.Set.Int.toArray /* [1,2 ] */
-s2 == s3 /* true */
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t, array<value>) => t
-```
-
-Adds each element of array to set. Unlike [add](#add), the reference of return value might be changed even if all values in array already exist in set
-
-```res example
-let set = Belt.Set.Int.empty
-
-let newSet = set->Belt.Set.Int.mergeMany([5, 4, 3, 2, 1])
-newSet->Belt.Set.Int.toArray /* [1, 2, 3, 4, 5] */
-```
-
-## remove
-
-```res sig
-let remove: (t, value) => t
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([2, 3, 1, 4, 5])
-let s1 = s0->Belt.Set.Int.remove(1)
-let s2 = s1->Belt.Set.Int.remove(3)
-let s3 = s2->Belt.Set.Int.remove(3)
-
-s1->Belt.Set.Int.toArray /* [2,3,4,5] */
-s2->Belt.Set.Int.toArray /* [2,4,5] */
-s2 == s3 /* true */
-```
-
-## removeMany
-
-```res sig
-let removeMany: (t, array<value>) => t
-```
-
-Removes each element of array from set. Unlike [remove](#remove), the reference of return value might be changed even if any values in array not existed in set.
-
-```res example
-let set = Belt.Set.Int.fromArray([1, 2, 3, 4])
-
-let newSet = set->Belt.Set.Int.removeMany([5, 4, 3, 2, 1])
-newSet->Belt.Set.Int.toArray /* [] */
-```
-
-## union
-
-```res sig
-let union: (t, t) => t
-```
-
-Returns union of two sets.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([5, 2, 3, 5, 6])
-let s1 = Belt.Set.Int.fromArray([5, 2, 3, 1, 5, 4])
-let union = Belt.Set.Int.union(s0, s1)
-union->Belt.Set.Int.toArray /* [1,2,3,4,5,6] */
-```
-
-## intersect
-
-```res sig
-let intersect: (t, t) => t
-```
-
-Returns intersection of two sets.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([5, 2, 3, 5, 6])
-let s1 = Belt.Set.Int.fromArray([5, 2, 3, 1, 5, 4])
-let intersect = Belt.Set.Int.intersect(s0, s1)
-intersect->Belt.Set.Int.toArray /* [2,3,5] */
-```
-
-## diff
-
-```res sig
-let diff: (t, t) => t
-```
-
-Returns elements from first set, not existing in second set.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([5, 2, 3, 5, 6])
-let s1 = Belt.Set.Int.fromArray([5, 2, 3, 1, 5, 4])
-Belt.Set.Int.toArray(Belt.Set.Int.diff(s0, s1)) /* [6] */
-Belt.Set.Int.toArray(Belt.Set.Int.diff(s1, s0)) /* [1,4] */
-```
-
-## subset
-
-```res sig
-let subset: (t, t) => bool
-```
-
-Checks if second set is subset of first set.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([5, 2, 3, 5, 6])
-let s1 = Belt.Set.Int.fromArray([5, 2, 3, 1, 5, 4])
-let s2 = Belt.Set.Int.intersect(s0, s1)
-Belt.Set.Int.subset(s2, s0) /* true */
-Belt.Set.Int.subset(s2, s1) /* true */
-Belt.Set.Int.subset(s1, s0) /* false */
-```
-
-## cmp
-
-```res sig
-let cmp: (t, t) => int
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```res sig
-let eq: (t, t) => bool
-```
-
-Checks if two sets are equal.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([5, 2, 3])
-let s1 = Belt.Set.Int.fromArray([3, 2, 5])
-
-Belt.Set.Int.eq(s0, s1) /* true */
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t, (. value) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t, value => unit) => unit
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([5, 2, 3, 5, 6])
-let acc = ref(list{})
-s0->Belt.Set.Int.forEach(x => acc := Belt.List.add(acc.contents, x))
-acc /* [6,5,3,2] */
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t, 'a, (. 'a, value) => 'a) => 'a
-```
-
-## reduce
-
-```res sig
-let reduce: (t, 'a, ('a, value) => 'a) => 'a
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([5, 2, 3, 5, 6])
-s0->Belt.Set.Int.reduce(list{}, (acc, element) => acc->Belt.List.add(element)) /* [6,5,3,2] */
-```
-
-## everyU
-
-```res sig
-let everyU: (t, (. value) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t, value => bool) => bool
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.Set.Int.fromArray([2, 4, 6, 8])
-s0->Belt.Set.Int.every(isEven) /* true */
-```
-
-## someU
-
-```res sig
-let someU: (t, (. value) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t, value => bool) => bool
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```res example
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.Set.Int.fromArray([1, 2, 4, 6, 8])
-s0->Belt.Set.Int.some(isOdd) /* true */
-```
-
-## keepU
-
-```res sig
-let keepU: (t, (. value) => bool) => t
-```
-
-## keep
-
-```res sig
-let keep: (t, value => bool) => t
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.Set.Int.fromArray([1, 2, 3, 4, 5])
-let s1 = s0->Belt.Set.Int.keep(isEven)
-
-s1->Belt.Set.Int.toArray /* [2,4] */
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t, (. value) => bool) => (t, t)
-```
-
-## partition
-
-```res sig
-let partition: (t, value => bool) => (t, t)
-```
-
-Returns a pair of sets, where first is the set of all the elements of set that satisfy the predicate, and second is the set of all the elements of set that do not satisfy the predicate.
-
-```res example
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.Set.Int.fromArray([1, 2, 3, 4, 5])
-let (s1, s2) = s0->Belt.Set.Int.partition(isOdd)
-
-s1->Belt.Set.Int.toArray /* [1,3,5] */
-s2->Belt.Set.Int.toArray /* [2,4] */
-```
-
-## size
-
-```res sig
-let size: t => int
-```
-
-Returns size of the set.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([1, 2, 3, 4])
-
-s0->Belt.Set.Int.size /* 4 */
-```
-
-## toList
-
-```res sig
-let toList: t => list<value>
-```
-
-Returns list of ordered set elements.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.Set.Int.toList /* [1,2,3,5] */
-```
-
-## toArray
-
-```res sig
-let toArray: t => array<value>
-```
-
-Returns array of ordered set elements.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.Set.Int.toArray /* [1,2,3,5] */
-```
-
-## minimum
-
-```res sig
-let minimum: t => option<value>
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.Set.Int.empty
-let s1 = Belt.Set.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.Set.Int.minimum /* None */
-s1->Belt.Set.Int.minimum /* Some(1) */
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t => Js.undefined<value>
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.Set.Int.empty
-let s1 = Belt.Set.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.Set.Int.minUndefined /* undefined */
-s1->Belt.Set.Int.minUndefined /* 1 */
-```
-
-## maximum
-
-```res sig
-let maximum: t => option<value>
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.Set.Int.empty
-let s1 = Belt.Set.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.Set.Int.maximum /* None */
-s1->Belt.Set.Int.maximum /* Some(5) */
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t => Js.undefined<value>
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.Set.Int.empty
-let s1 = Belt.Set.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.Set.Int.maxUndefined /* undefined */
-s1->Belt.Set.Int.maxUndefined /* 5 */
-```
-
-## get
-
-```res sig
-let get: (t, value) => option<value>
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([1, 2, 3, 4, 5])
-
-s0->Belt.Set.Int.get(3) /* Some(3) */
-s0->Belt.Set.Int.get(20) /* None */
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t, value) => Js.undefined<value>
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```res sig
-let getExn: (t, value) => value
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```res sig
-let split: (t, value) => ((t, t), bool)
-```
-
-Returns a tuple `((l, r), present)`, where `l` is the set of elements of set that are strictly less than value, `r` is the set of elements of set that are strictly greater than value, `present` is `false` if set contains no element equal to value, or `true` if set contains an element equal to value.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([1, 2, 3, 4, 5])
-
-let ((smaller, larger), present) = s0->Belt.Set.Int.split(3)
-
-present /* true */
-smaller->Belt.Set.Int.toArray /* [1,2] */
-larger->Belt.Set.Int.toArray /* [4,5] */
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t => unit
-```
-
-**raise** when invariant is not held
-
diff --git a/pages/docs/manual/v10.0.0/api/belt/set-string.mdx b/pages/docs/manual/v10.0.0/api/belt/set-string.mdx
deleted file mode 100644
index 8fbfff26d..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/set-string.mdx
+++ /dev/null
@@ -1,538 +0,0 @@
-# SetString
-
-<Intro>
-
-Specialized when value type is `string`, more efficient than the generic type, its compare behavior is fixed using the built-in comparison.
-
-</Intro>
-
-## value
-
-```res prelude
-type value = string
-```
-
-The type of the set elements.
-
-## t
-
-```res prelude
-type t
-```
-
-The type of sets.
-
-## empty
-
-```res sig
-let empty: t
-```
-
-Empty set
-
-```res example
-let s0 = Belt.Set.String.empty
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<value> => t
-```
-
-Creates new set from array of elements.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "orange", "banana"])
-
-s0->Belt.Set.String.toArray /* ["apple", "banana", "orange"] */
-```
-
-## fromSortedArrayUnsafe
-
-```res sig
-let fromSortedArrayUnsafe: array<value> => t
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## isEmpty
-
-```res sig
-let isEmpty: t => bool
-```
-
-Checks if set is empty.
-
-```res example
-let empty = Belt.Set.String.fromArray([])
-let notEmpty = Belt.Set.String.fromArray(["apple"])
-
-Belt.Set.String.isEmpty(empty) /* true */
-Belt.Set.String.isEmpty(notEmpty) /* false */
-```
-
-## has
-
-```res sig
-let has: (t, value) => bool
-```
-
-Checks if element exists in set.
-
-```res example
-let set = Belt.Set.String.fromArray(["apple", "orange", "banana"])
-
-set->Belt.Set.String.has("strawberry") /* false */
-set->Belt.Set.String.has("apple") /* true */
-```
-
-## add
-
-```res sig
-let add: (t, value) => t
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.Set.String.empty
-let s1 = s0->Belt.Set.String.add("apple")
-let s2 = s1->Belt.Set.String.add("banana")
-let s3 = s2->Belt.Set.String.add("banana")
-s0->Belt.Set.String.toArray /* [] */
-s1->Belt.Set.String.toArray /* ["apple"] */
-s2->Belt.Set.String.toArray /* ["apple", "banana"] */
-s3->Belt.Set.String.toArray /* ["apple", "banana"] */
-s2 == s3 /* true */
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t, array<value>) => t
-```
-
-Adds each element of array to set. Unlike [add](#add), the reference of return value might be changed even if all values in array already exist in set
-
-```res example
-let set = Belt.Set.String.empty
-
-let newSet = set->Belt.Set.String.mergeMany(["apple", "banana", "orange", "strawberry"])
-
-newSet->Belt.Set.String.toArray /* ["apple", "banana", "orange", "strawberry"] */
-```
-
-## remove
-
-```res sig
-let remove: (t, value) => t
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["orange", "banana", "apple"])
-let s1 = s0->Belt.Set.String.remove("apple")
-let s2 = s1->Belt.Set.String.remove("banana")
-let s3 = s2->Belt.Set.String.remove("banana")
-
-s1->Belt.Set.String.toArray /* ["orange", "banana"] */
-s2->Belt.Set.String.toArray /* ["orange"] */
-s2 == s3 /* true */
-```
-
-## removeMany
-
-```res sig
-let removeMany: (t, array<value>) => t
-```
-
-Removes each element of array from set. Unlike [remove](#remove), the reference of return value might be changed even if any values in array not existed in set.
-
-```res example
-let set = Belt.Set.String.fromArray(["apple", "banana", "orange"])
-
-let newSet = set->Belt.Set.String.removeMany(["strawberry", "apple", "banana", "orange"])
-newSet->Belt.Set.String.toArray /* [] */
-```
-
-## union
-
-```res sig
-let union: (t, t) => t
-```
-
-Returns union of two sets.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "banana", "orange", "carrot"])
-let s1 = Belt.Set.String.fromArray(["apple", "banana", "orange", "strawberry"])
-let union = Belt.Set.String.union(s0, s1)
-union->Belt.Set.String.toArray /* ["apple", "banana", "carrot", "orange", "strawberry"] */
-```
-
-## intersect
-
-```res sig
-let intersect: (t, t) => t
-```
-
-Returns intersection of two sets.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "banana", "orange", "carrot"])
-let s1 = Belt.Set.String.fromArray(["apple", "banana", "orange", "strawberry"])
-let intersect = Belt.Set.String.intersect(s0, s1)
-intersect->Belt.Set.String.toArray /* ["apple", "banana", "orange"] */
-```
-
-## diff
-
-```res sig
-let diff: (t, t) => t
-```
-
-Returns elements from first set, not existing in second set.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "banana", "orange", "carrot"])
-let s1 = Belt.Set.String.fromArray(["apple", "banana", "orange", "strawberry"])
-Belt.Set.String.toArray(Belt.Set.String.diff(s0, s1)) /* ["carrot"] */
-Belt.Set.String.toArray(Belt.Set.String.diff(s1, s0)) /* ["strawberry"] */
-```
-
-## subset
-
-```res sig
-let subset: (t, t) => bool
-```
-
-Checks if second set is subset of first set.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["5", "2", "3", "5", "6"])
-let s1 = Belt.Set.String.fromArray(["5", "2", "3", "1", "5", "4"])
-let s2 = Belt.Set.String.intersect(s0, s1)
-Belt.Set.String.subset(s2, s0) /* true */
-Belt.Set.String.subset(s2, s1) /* true */
-Belt.Set.String.subset(s1, s0) /* false */
-```
-
-## cmp
-
-```res sig
-let cmp: (t, t) => int
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```res sig
-let eq: (t, t) => bool
-```
-
-Checks if two sets are equal.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "orange"])
-let s1 = Belt.Set.String.fromArray(["orange", "apple"])
-
-Belt.Set.String.eq(s0, s1) /* true */
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t, (. value) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t, value => unit) => unit
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["banana", "orange", "apple"])
-let acc = ref(list{})
-s0->Belt.Set.String.forEach(x => acc := Belt.List.add(acc.contents, x))
-acc /* ["orange", "banana", "apple"] */
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t, 'a, (. 'a, value) => 'a) => 'a
-```
-
-## reduce
-
-```res sig
-let reduce: (t, 'a, ('a, value) => 'a) => 'a
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "orange"])
-s0->Belt.Set.String.reduce(0, (acc, element) => acc + String.length(element)) /* 11 */
-```
-
-## everyU
-
-```res sig
-let everyU: (t, (. value) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t, value => bool) => bool
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```res example
-let hasAtLeastFiveChars = x => String.length(x) >= 5
-
-let s0 = Belt.Set.String.fromArray(["apple", "carrot"])
-s0->Belt.Set.String.every(hasAtLeastFiveChars) /* true */
-```
-
-## someU
-
-```res sig
-let someU: (t, (. value) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t, value => bool) => bool
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```res example
-let hasFiveChars = x => String.length(x) == 5
-
-let s0 = Belt.Set.String.fromArray(["strawberry", "apple"])
-s0->Belt.Set.String.some(hasFiveChars) /* true */
-```
-
-## keepU
-
-```res sig
-let keepU: (t, (. value) => bool) => t
-```
-
-## keep
-
-```res sig
-let keep: (t, value => bool) => t
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```res example
-let hasFiveChars = x => String.length(x) == 5
-
-let s0 = Belt.Set.String.fromArray(["apple", "orange", "banana"])
-let s1 = s0->Belt.Set.String.keep(hasFiveChars)
-
-s1->Belt.Set.String.toArray /* ["apple"] */
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t, (. value) => bool) => (t, t)
-```
-
-## partition
-
-```res sig
-let partition: (t, value => bool) => (t, t)
-```
-
-Returns a pair of sets, where first is the set of all the elements of set that satisfy the predicate, and second is the set of all the elements of set that do not satisfy the predicate.
-
-```res example
-let hasFiveChars = x => String.length(x) == 5
-
-let s0 = Belt.Set.String.fromArray(["apple", "carrot"])
-let (s1, s2) = s0->Belt.Set.String.partition(hasFiveChars)
-
-s1->Belt.Set.String.toArray /* ["apple"] */
-s2->Belt.Set.String.toArray /* ["carrot"] */
-```
-
-## size
-
-```res sig
-let size: t => int
-```
-
-Returns size of the set.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple"])
-
-s0->Belt.Set.String.size /* 1 */
-```
-
-## toList
-
-```res sig
-let toList: t => list<value>
-```
-
-Returns list of ordered set elements.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "watermelon"])
-
-s0->Belt.Set.String.toList /* ["apple", "watermelon"] */
-```
-
-## toArray
-
-```res sig
-let toArray: t => array<value>
-```
-
-Returns array of ordered set elements.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "watermelon"])
-
-s0->Belt.Set.String.toArray /* ["apple", "watermelon"] */
-```
-
-## minimum
-
-```res sig
-let minimum: t => option<value>
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.Set.String.empty
-let s1 = Belt.Set.String.fromArray(["apple", "orange"])
-
-s0->Belt.Set.String.minimum /* None */
-s1->Belt.Set.String.minimum /* Some("apple") */
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t => Js.undefined<value>
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.Set.String.empty
-let s1 = Belt.Set.String.fromArray(["apple", "orange"])
-
-s0->Belt.Set.String.minUndefined /* undefined */
-s1->Belt.Set.String.minUndefined /* "apple" */
-```
-
-## maximum
-
-```res sig
-let maximum: t => option<value>
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.Set.String.empty
-let s1 = Belt.Set.String.fromArray(["apple", "orange"])
-
-s0->Belt.Set.String.maximum /* None */
-s1->Belt.Set.String.maximum /* Some("orange") */
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t => Js.undefined<value>
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.Set.String.empty
-let s1 = Belt.Set.String.fromArray(["apple", "orange"])
-
-s0->Belt.Set.String.maxUndefined /* undefined */
-s1->Belt.Set.String.maxUndefined /* orange */
-```
-
-## get
-
-```res sig
-let get: (t, value) => option<value>
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "carrot"])
-
-s0->Belt.Set.String.get("carrot") /* Some("carrot") */
-s0->Belt.Set.String.get("watermelon") /* None */
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t, value) => Js.undefined<value>
-```
-
-See [get](#get) - returns `undefined` when element does not exist.
-
-## getExn
-
-```res sig
-let getExn: (t, value) => value
-```
-
-See [get](#get) - raise when element does not exist.
-
-## split
-
-```res sig
-let split: (t, value) => ((t, t), bool)
-```
-
-Returns a triple `((l, r), present)`, where `l` is the set of elements of set that are strictly less than value, `r` is the set of elements of set that are strictly greater than value, `present` is `false` if set contains no element equal to value, or `true` if set contains an element equal to value.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "banana", "orange"])
-
-let ((smaller, larger), present) = s0->Belt.Set.String.split("banana")
-
-present /* true */
-smaller->Belt.Set.String.toArray /* ["apple"] */
-larger->Belt.Set.String.toArray /* ["orange"] */
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t => unit
-```
-
-**raise** when invariant is not held
-
diff --git a/pages/docs/manual/v10.0.0/api/belt/set.mdx b/pages/docs/manual/v10.0.0/api/belt/set.mdx
deleted file mode 100644
index 173cdd865..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/set.mdx
+++ /dev/null
@@ -1,590 +0,0 @@
-# Set
-
-<Intro>
-
-A **immutable** sorted set module which allows customize compare behavior.
-The implementation uses balanced binary trees, and therefore searching and insertion take time logarithmic in the size of the map.
-
-It also has three specialized inner modules [Belt.Set.Int](set-int), [Belt.Set.String](set-string) and [Belt.Set.Dict](set-dict) - This module separates data from function which is more verbose but slightly more efficient
-
-</Intro>
-
-```res example
-module PairComparator =
-  Belt.Id.MakeComparable({
-    type t = (int, int)
-    let cmp = ((a0, a1), (b0, b1)) =>
-      switch (Pervasives.compare(a0, b0)) {
-      | 0 => Pervasives.compare(a1, b1)
-      | c => c
-      }
-  })
-
-let mySet = Belt.Set.make(~id=module(PairComparator))
-let mySet2 = Belt.Set.add(mySet, (1, 2))
-```
-
-**Note:** This module's examples will assume a predeclared module for integers
-called `IntCmp`. It is declared like this:
-
-```res prelude
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int
-    let cmp = Pervasives.compare
-  })
-```
-
-## t
-
-```res prelude
-type t<'value, 'identity>
-```
-
-`'value` is the element type
-
-`'identity` the identity of the collection
-
-## id
-
-```res prelude
-type id<'value, 'id> = Belt_Id.comparable<'value, 'id>
-```
-
-The identity needed for making a set from scratch
-
-## make
-
-```res sig
-let make: (~id: id<'value, 'id>) => t<'value, 'id>
-```
-
-Creates a new set by taking in the comparator
-
-```res example
-let set = Belt.Set.make(~id=module(IntCmp))
-```
-
-## fromArray
-
-```res sig
-let fromArray: (array<'value>, ~id: id<'value, 'id>) => t<'value, 'id>
-```
-
-Creates new set from array of elements.
-
-```res example
-let s0 = Belt.Set.fromArray([1, 3, 2, 4], ~id=module(IntCmp))
-
-s0->Belt.Set.toArray /* [1, 2, 3, 4] */
-```
-
-## fromSortedArrayUnsafe
-
-```res sig
-let fromSortedArrayUnsafe: (array<'value>, ~id: id<'value, 'id>) => t<'value, 'id>
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a, 'b> => bool
-```
-
-Checks if set is empty.
-
-```res example
-let empty = Belt.Set.fromArray([], ~id=module(IntCmp))
-let notEmpty = Belt.Set.fromArray([1],~id=module(IntCmp))
-
-Belt.Set.isEmpty(empty) /* true */
-Belt.Set.isEmpty(notEmpty) /* false */
-```
-
-## has
-
-```res sig
-let has: (t<'value, 'id>, 'value) => bool
-```
-
-Checks if element exists in set.
-
-```res example
-let set = Belt.Set.fromArray([1, 4, 2, 5], ~id=module(IntCmp))
-
-set->Belt.Set.has(3) /* false */
-set->Belt.Set.has(1) /* true */
-```
-
-## add
-
-```res sig
-let add: (t<'value, 'id>, 'value) => t<'value, 'id>
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.Set.make(~id=module(IntCmp))
-let s1 = s0->Belt.Set.add(1)
-let s2 = s1->Belt.Set.add(2)
-let s3 = s2->Belt.Set.add(2)
-s0->Belt.Set.toArray /* [] */
-s1->Belt.Set.toArray /* [1] */
-s2->Belt.Set.toArray /* [1, 2] */
-s3->Belt.Set.toArray /* [1,2 ] */
-s2 == s3 /* true */
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'value, 'id>, array<'value>) => t<'value, 'id>
-```
-
-Adds each element of array to set. Unlike [add](#add), the reference of return value might be changed even if all values in array already exist in set
-
-```res example
-let set = Belt.Set.make(~id=module(IntCmp))
-
-let newSet = set->Belt.Set.mergeMany([5, 4, 3, 2, 1])
-newSet->Belt.Set.toArray /* [1, 2, 3, 4, 5] */
-```
-
-## remove
-
-```res sig
-let remove: (t<'value, 'id>, 'value) => t<'value, 'id>
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.Set.fromArray([2,3,1,4,5], ~id=module(IntCmp))
-let s1 = s0->Belt.Set.remove(1)
-let s2 = s1->Belt.Set.remove(3)
-let s3 = s2->Belt.Set.remove(3)
-
-s1->Belt.Set.toArray /* [2,3,4,5] */
-s2->Belt.Set.toArray /* [2,4,5] */
-s2 == s3 /* true */
-```
-
-## removeMany
-
-```res sig
-let removeMany: (t<'value, 'id>, array<'value>) => t<'value, 'id>
-```
-
-Removes each element of array from set. Unlike [remove](#remove), the reference of return value might be changed even if any values in array not existed in set.
-
-```res example
-let set = Belt.Set.fromArray([1, 2, 3, 4],~id=module(IntCmp))
-
-let newSet = set->Belt.Set.removeMany([5, 4, 3, 2, 1])
-newSet->Belt.Set.toArray /* [] */
-```
-
-## union
-
-```res sig
-let union: (t<'value, 'id>, t<'value, 'id>) => t<'value, 'id>
-```
-
-Returns union of two sets.
-
-```res example
-let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([5,2,3,1,5,4], ~id=module(IntCmp))
-let union = Belt.Set.union(s0, s1)
-union->Belt.Set.toArray /* [1,2,3,4,5,6] */
-```
-
-## intersect
-
-```res sig
-let intersect: (t<'value, 'id>, t<'value, 'id>) => t<'value, 'id>
-```
-
-Returns intersection of two sets.
-
-```res example
-let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([5,2,3,1,5,4], ~id=module(IntCmp))
-let intersect = Belt.Set.intersect(s0, s1)
-intersect->Belt.Set.toArray /* [2,3,5] */
-```
-
-## diff
-
-```res sig
-let diff: (t<'value, 'id>, t<'value, 'id>) => t<'value, 'id>
-```
-
-Returns elements from first set, not existing in second set.
-
-```res example
-let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([5,2,3,1,5,4], ~id=module(IntCmp))
-Belt.Set.toArray(Belt.Set.diff(s0, s1)) /* [6] */
-Belt.Set.toArray(Belt.Set.diff(s1,s0)) /* [1,4] */
-```
-
-## subset
-
-```res sig
-let subset: (t<'value, 'id>, t<'value, 'id>) => bool
-```
-
-Checks if second set is subset of first set.
-
-```res example
-let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([5,2,3,1,5,4], ~id=module(IntCmp))
-let s2 = Belt.Set.intersect(s0, s1)
-Belt.Set.subset(s2, s0) /* true */
-Belt.Set.subset(s2, s1) /* true */
-Belt.Set.subset(s1, s0) /* false */
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'value, 'id>, t<'value, 'id>) => int
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```res sig
-let eq: (t<'value, 'id>, t<'value, 'id>) => bool
-```
-
-Checks if two sets are equal.
-
-```res example
-let s0 = Belt.Set.fromArray([5,2,3], ~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([3,2,5], ~id=module(IntCmp))
-
-Belt.Set.eq(s0, s1) /* true */
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'value, 'id>, (. 'value) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t<'value, 'id>, 'value => unit) => unit
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```res example
-let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
-let acc = ref(list{})
-s0->Belt.Set.forEach(x => {
-  acc := Belt.List.add(acc.contents, x)
-})
-acc /* [6,5,3,2] */
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t<'value, 'id>, 'a, (. 'a, 'value) => 'a) => 'a
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'value, 'id>, 'a, ('a, 'value) => 'a) => 'a
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```res example
-let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
-s0->Belt.Set.reduce(list{}, (acc, element) =>
-  acc->Belt.List.add(element)
-) /* [6,5,3,2] */
-```
-
-## everyU
-
-```res sig
-let everyU: (t<'value, 'id>, (. 'value) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'value, 'id>, 'value => bool) => bool
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.Set.fromArray([2,4,6,8], ~id=module(IntCmp))
-s0->Belt.Set.every(isEven) /* true */
-```
-
-## someU
-
-```res sig
-let someU: (t<'value, 'id>, (. 'value) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'value, 'id>, 'value => bool) => bool
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```res example
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.Set.fromArray([1,2,4,6,8], ~id=module(IntCmp))
-s0->Belt.Set.some(isOdd) /* true */
-```
-
-## keepU
-
-```res sig
-let keepU: (t<'value, 'id>, (. 'value) => bool) => t<'value, 'id>
-```
-
-## keep
-
-```res sig
-let keep: (t<'value, 'id>, 'value => bool) => t<'value, 'id>
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.Set.fromArray([1,2,3,4,5], ~id=module(IntCmp))
-let s1 = s0->Belt.Set.keep(isEven)
-
-s1->Belt.Set.toArray /* [2,4] */
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t<'value, 'id>, (. 'value) => bool) => (t<'value, 'id>, t<'value, 'id>)
-```
-
-## partition
-
-```res sig
-let partition: (t<'value, 'id>, 'value => bool) => (t<'value, 'id>, t<'value, 'id>)
-```
-
-Returns a pair of sets, where first is the set of all the elements of set that satisfy the predicate, and second is the set of all the elements of set that do not satisfy the predicate.
-
-```res example
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.Set.fromArray([1,2,3,4,5], ~id=module(IntCmp))
-let (s1, s2) = s0->Belt.Set.partition(isOdd)
-
-s1->Belt.Set.toArray /* [1,3,5] */
-s2->Belt.Set.toArray /* [2,4] */
-```
-
-## size
-
-```res sig
-let size: t<'value, 'id> => int
-```
-
-Returns size of the set.
-
-```res example
-let s0 = Belt.Set.fromArray([1,2,3,4], ~id=module(IntCmp))
-
-s0->Belt.Set.size /* 4 */
-```
-
-## toArray
-
-```res sig
-let toArray: t<'value, 'id> => array<'value>
-```
-
-Returns array of ordered set elements.
-
-```res example
-let s0 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))
-
-s0->Belt.Set.toArray /* [1,2,3,5] */
-```
-
-## toList
-
-```res sig
-let toList: t<'value, 'id> => list<'value>
-```
-
-Returns list of ordered set elements.
-
-```res example
-let s0 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))
-
-s0->Belt.Set.toList /* [1,2,3,5] */
-```
-
-## minimum
-
-```res sig
-let minimum: t<'value, 'id> => option<'value>
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.Set.make(~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))
-
-s0->Belt.Set.minimum /* None */
-s1->Belt.Set.minimum /* Some(1) */
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'value, 'id> => Js.undefined<'value>
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.Set.make(~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))
-
-s0->Belt.Set.minUndefined /* undefined */
-s1->Belt.Set.minUndefined /* 1 */
-```
-
-## maximum
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.Set.make(~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))
-
-s0->Belt.Set.maximum /* None */
-s1->Belt.Set.maximum /* Some(5) */
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'value, 'id> => Js.undefined<'value>
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.Set.make(~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))
-
-s0->Belt.Set.maxUndefined /* undefined */
-s1->Belt.Set.maxUndefined /* 5 */
-```
-
-## get
-
-```res sig
-let get: (t<'value, 'id>, 'value) => option<'value>
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```res example
-let s0 = Belt.Set.fromArray([1,2,3,4,5], ~id=module(IntCmp))
-
-s0->Belt.Set.get(3) /* Some(3) */
-s0->Belt.Set.get(20) /* None */
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'value, 'id>, 'value) => Js.undefined<'value>
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```res sig
-let getExn: (t<'value, 'id>, 'value) => 'value
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```res sig
-let split: (t<'value, 'id>, 'value) => ((t<'value, 'id>, t<'value, 'id>), bool)
-```
-
-Returns a tuple `((smaller, larger), present)`, `present` is true when element exist in set.
-
-```res example
-let s0 = Belt.Set.fromArray([1,2,3,4,5], ~id=module(IntCmp))
-
-let ((smaller, larger), present) = s0->Belt.Set.split(3)
-
-present /* true */
-smaller->Belt.Set.toArray /* [1,2] */
-larger->Belt.Set.toArray /* [4,5] */
-
-```
-
-## getData
-
-```res sig
-let getData: t<'value, 'id> => Belt_SetDict.t<'value, 'id>
-```
-
-**Advanced usage only**
-
-Returns the raw data (detached from comparator), but its type is still manifested, so that user can pass identity directly without boxing.
-
-## getId
-
-```res sig
-let getId: t<'value, 'id> => id<'value, 'id>
-```
-
-**Advanced usage only**
-
-Returns the identity of set.
-
-## packIdData
-
-```res sig
-let packIdData: (~id: id<'value, 'id>, ~data: Belt_SetDict.t<'value, 'id>) => t<'value, 'id>
-```
-
-**Advanced usage only**
-
-Returns the packed collection.
diff --git a/pages/docs/manual/v10.0.0/api/belt/sort-array-int.mdx b/pages/docs/manual/v10.0.0/api/belt/sort-array-int.mdx
deleted file mode 100644
index 15fc2dc4c..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/sort-array-int.mdx
+++ /dev/null
@@ -1,59 +0,0 @@
-# SortArrayInt
-
-<Intro>
-
-This is a specialized module for `Belt.SortArray`, the docs in that module also applies here, except the comparator is fixed and inlined.
-
-</Intro>
-
-## element
-
-```res prelude
-type element = int
-```
-
-## strictlySortedLength
-
-```res sig
-let strictlySortedLength: array<element> => int
-```
-
-The same as `Belt.SortArray.strictlySortedLength` except the comparator is fixed.
-
-Returns `+n` means increasing order `-n` means negative order.
-
-## isSorted
-
-```res sig
-let isSorted: array<element> => bool
-```
-
-`sorted(xs)` return true if `xs` is in non strict increasing order.
-
-## stableSortInPlace
-
-```res sig
-let stableSortInPlace: array<element> => unit
-```
-
-The same as `Belt.SortArray.stableSortInPlaceBy` except the comparator is fixed.
-
-## stableSort
-
-```res sig
-let stableSort: array<element> => array<element>
-```
-
-The same as `Belt.SortArray.stableSortBy` except the comparator is fixed.
-
-## binarySearch
-
-```res sig
-let binarySearch: (array<element>, element) => int
-```
-
-If value is not found and value is less than one or more elements in array, the negative number returned is the bitwise complement of the index of the first element that is larger than value.
-
-If value is not found and value is greater than all elements in array, the negative number returned is the bitwise complement of (the index of the last element plus 1)
-
-for example, if `key` is smaller than all elements return `-1` since `lnot(-1) = 0` if `key` is larger than all elements return `- (len + 1)` since `lnot(-(len+1)) = len`.
diff --git a/pages/docs/manual/v10.0.0/api/belt/sort-array-string.mdx b/pages/docs/manual/v10.0.0/api/belt/sort-array-string.mdx
deleted file mode 100644
index 3016c1903..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/sort-array-string.mdx
+++ /dev/null
@@ -1,59 +0,0 @@
-# SortArrayString
-
-<Intro>
-
-This is a specialized module for `Belt.SortArray`, the docs in that module also applies here, except the comparator is fixed and inlined.
-
-</Intro>
-
-## element
-
-```res prelude
-type element = string
-```
-
-## strictlySortedLength
-
-```res sig
-let strictlySortedLength: array<element> => int
-```
-
-The same as `Belt.SortArray.strictlySortedLength` except the comparator is fixed.
-
-Returns `+n` means increasing order `-n` means negative order.
-
-## isSorted
-
-```res sig
-let isSorted: array<element> => bool
-```
-
-`sorted(xs)` return true if `xs` is in non strict increasing order.
-
-## stableSortInPlace
-
-```res sig
-let stableSortInPlace: array<element> => unit
-```
-
-The same as `Belt.SortArray.stableSortInPlaceBy` except the comparator is fixed.
-
-## stableSort
-
-```res sig
-let stableSort: array<element> => array<element>
-```
-
-The same as `Belt.SortArray.stableSortBy` except the comparator is fixed.
-
-## binarySearch
-
-```res sig
-let binarySearch: (array<element>, element) => int
-```
-
-If value is not found and value is less than one or more elements in array, the negative number returned is the bitwise complement of the index of the first element that is larger than value.
-
-If value is not found and value is greater than all elements in array, the negative number returned is the bitwise complement of (the index of the last element plus 1)
-
-for example, if `key` is smaller than all elements return `-1` since `lnot(-1) = 0` if `key` is larger than all elements return `- (len + 1)` since `lnot(-(len+1)) = len`.
diff --git a/pages/docs/manual/v10.0.0/api/belt/sort-array.mdx b/pages/docs/manual/v10.0.0/api/belt/sort-array.mdx
deleted file mode 100644
index 8d6e3d1ee..000000000
--- a/pages/docs/manual/v10.0.0/api/belt/sort-array.mdx
+++ /dev/null
@@ -1,111 +0,0 @@
-# SortArray
-
-## SortArrayInt
-
-```res example
-module Int = Belt.SortArray.Int
-```
-
-Specialized when key type is `int`, more efficient than the generic type
-
-## SortArrayString
-
-```res example
-module String = Belt.SortArray.String
-```
-
-Specialized when key type is `string`, more efficient than the generic type
-
-## strictlySortedLengthU
-
-```res sig
-let strictlySortedLengthU: (array<'a>, (. 'a, 'a) => bool) => int
-```
-
-## strictlySortedLength
-
-```res sig
-let strictlySortedLength: (array<'a>, ('a, 'a) => bool) => int
-```
-
-`strictlySortedLenght(xs, cmp);` return `+n` means increasing order `-n` means negative order
-
-```res example
-Belt.SortArray.strictlySortedLength([1, 2, 3, 4, 3], (x, y) => x < y) == 4
-
-Belt.SortArray.strictlySortedLength([], (x, y) => x < y) == 0
-
-Belt.SortArray.strictlySortedLength([1], (x, y) => x < y) == 1
-
-Belt.SortArray.strictlySortedLength([4, 3, 2, 1], (x, y) => x < y) == -4
-```
-
-## isSortedU
-
-```res sig
-let isSortedU: (array<'a>, (. 'a, 'a) => int) => bool
-```
-
-## isSorted
-
-```res sig
-let isSorted: (array<'a>, ('a, 'a) => int) => bool
-```
-
-`isSorted(arr, cmp)`: Returns true if array is increasingly sorted (equal is okay)
-
-## stableSortInPlaceByU
-
-```res sig
-let stableSortInPlaceByU: (array<'a>, (. 'a, 'a) => int) => unit
-```
-
-## stableSortInPlaceBy
-
-```res sig
-let stableSortInPlaceBy: (array<'a>, ('a, 'a) => int) => unit
-```
-
-## stableSortByU
-
-```res sig
-let stableSortByU: (array<'a>, (. 'a, 'a) => int) => array<'a>
-```
-
-## stableSortBy
-
-```res sig
-let stableSortBy: (array<'a>, ('a, 'a) => int) => array<'a>
-```
-
-`stableSortBy(xs, cmp)`: Returns a fresh array Sort `xs` in place using
-comparator `cmp`, the stable means if the elements are equal, their order will
-be preserved
-
-## binarySearchByU
-
-```res sig
-let binarySearchByU: (array<'a>, 'a, (. 'a, 'a) => int) => int
-```
-
-## binarySearchBy
-
-```res sig
-let binarySearchBy: (array<'a>, 'a, ('a, 'a) => int) => int
-```
-
-If value is not found and value is less than one or more elements in array, the
-negative number returned is the bitwise complement of the index of the first
-element that is larger than value.
-
-If value is not found and value is greater
-than all elements in array, the negative number returned is the bitwise
-complement of (the index of the last element plus 1)for example, if `key` is
-smaller than all elements return `-1` since `lnot(-1) == 0` if `key` is larger
-than all elements return `lnot(-1) == 0` since `lnot(- (len + 1)) == len`
-
-```res example
-Belt.SortArray.binarySearchBy([1, 2, 3, 4, 33, 35, 36], 33, Pervasives.compare) == 4
-
-lnot(Belt.SortArray.binarySearchBy([1, 3, 5, 7], 4, Pervasives.compare)) == 2
-```
diff --git a/pages/docs/manual/v10.0.0/api/dom.mdx b/pages/docs/manual/v10.0.0/api/dom.mdx
deleted file mode 100644
index eee448156..000000000
--- a/pages/docs/manual/v10.0.0/api/dom.mdx
+++ /dev/null
@@ -1,855 +0,0 @@
-# Dom
-
-<Intro>
-
-The Dom module offers a canonical set of dom related types that third party libraries can depend on. It only provides types, no functions to manipulate the values of certain types whatsoever.
-
-</Intro>
-
-## animation
-
-```res sig
-type animation
-```
-
-## cssStyleDeclaration
-
-```res sig
-type cssStyleDeclaration
-```
-
-## cssStyleSheet
-
-```res sig
-type cssStyleSheet
-```
-
-## node
-
-```res sig
-type node
-```
-
-## characterData
-
-```res sig
-type characterData
-```
-
-## cdataSection
-
-```res sig
-type cdataSection
-```
-
-## comment
-
-```res sig
-type comment
-```
-
-## document
-
-```res sig
-type document
-```
-
-## documentType
-
-```res sig
-type documentType
-```
-
-## domImplementation
-
-```res sig
-type domImplementation
-```
-
-## element
-
-```res sig
-type element
-```
-
-## htmlCollection
-
-```res sig
-type htmlCollection
-```
-
-## htmlFormControlsCollection
-
-```res sig
-type htmlFormControlsCollection
-```
-
-## htmlOptionsCollection
-
-```res sig
-type htmlOptionsCollection
-```
-
-## intersectionObserver
-
-```res sig
-type intersectionObserver
-```
-
-## intersectionObserverEntry
-
-```res sig
-type intersectionObserverEntry
-```
-
-## mutationObserver
-
-```res sig
-type mutationObserver
-```
-
-## mutationRecord
-
-```res sig
-type mutationRecord
-```
-
-## performanceObserver
-
-```res sig
-type performanceObserver
-```
-
-## performanceObserverEntryList
-
-```res sig
-type performanceObserverEntryList
-```
-
-## reportingObserver
-
-```res sig
-type reportingObserver
-```
-
-## reportingObserverOptions
-
-```res sig
-type reportingObserverOptions
-```
-
-## resizeObserver
-
-```res sig
-type resizeObserver
-```
-
-## resizeObserverEntry
-
-```res sig
-type resizeObserverEntry
-```
-
-## namedNodeMap
-
-```res sig
-type namedNodeMap
-```
-
-## nodeList
-
-```res sig
-type nodeList
-```
-
-## radioNodeList
-
-```res sig
-type radioNodeList
-```
-
-## processingInstruction
-
-```res sig
-type processingInstruction
-```
-
-## shadowRoot
-
-```res sig
-type shadowRoot
-```
-
-## text
-
-```res sig
-type text
-```
-
-## domRect
-
-```res sig
-type domRect
-```
-
-## dataTransfer
-
-```res sig
-type dataTransfer
-```
-
-## domStringMap
-
-```res sig
-type domStringMap
-```
-
-## history
-
-```res sig
-type history
-```
-
-## htmlDocument
-
-```res sig
-type htmlDocument
-```
-
-## htmlElement
-
-```res sig
-type htmlElement
-```
-
-## htmlAnchorElement
-
-```res sig
-type htmlAnchorElement
-```
-
-## htmlAreaElement
-
-```res sig
-type htmlAreaElement
-```
-
-## htmlAudioElement
-
-```res sig
-type htmlAudioElement
-```
-
-## htmlBaseElement
-
-```res sig
-type htmlBaseElement
-```
-
-## htmlBodyElement
-
-```res sig
-type htmlBodyElement
-```
-
-## htmlBrElement
-
-```res sig
-type htmlBrElement
-```
-
-## htmlButtonElement
-
-```res sig
-type htmlButtonElement
-```
-
-## htmlCanvasElement
-
-```res sig
-type htmlCanvasElement
-```
-
-## htmlDataElement
-
-```res sig
-type htmlDataElement
-```
-
-## htmlDataListElement
-
-```res sig
-type htmlDataListElement
-```
-
-## htmlDialogElement
-
-```res sig
-type htmlDialogElement
-```
-
-## htmlDivElement
-
-```res sig
-type htmlDivElement
-```
-
-## htmlDlistElement
-
-```res sig
-type htmlDlistElement
-```
-
-## htmlEmbedElement
-
-```res sig
-type htmlEmbedElement
-```
-
-## htmlFieldSetElement
-
-```res sig
-type htmlFieldSetElement
-```
-
-## htmlFormElement
-
-```res sig
-type htmlFormElement
-```
-
-## htmlHeadElement
-
-```res sig
-type htmlHeadElement
-```
-
-## htmlHeadingElement
-
-```res sig
-type htmlHeadingElement
-```
-
-## htmlHrElement
-
-```res sig
-type htmlHrElement
-```
-
-## htmlHtmlElement
-
-```res sig
-type htmlHtmElement
-```
-
-## htmlIframeElement
-
-```res sig
-type htmlIframeElement
-```
-
-## htmlImageElement
-
-```res sig
-type htmlImageElement
-```
-
-## htmlInputElement
-
-```res sig
-type htmlInputElement
-```
-
-## htmlLabelElement
-
-```res sig
-type htmlLabelElement
-```
-
-## htmlLegendElement
-
-```res sig
-type htmlLegendElement
-```
-
-## htmlLiElement
-
-```res sig
-type htmlLiElement
-```
-
-## htmlLinkElement
-
-```res sig
-type htmlLinkElement
-```
-
-## htmlMapElement
-
-```res sig
-type htmlMapElement
-```
-
-## htmlMediaElement
-
-```res sig
-type htmlMediaElement
-```
-
-## htmlMenuElement
-
-```res sig
-type htmlMenuElement
-```
-
-## htmlMetaElement
-
-```res sig
-type htmlMetaElement
-```
-
-## htmlMeterElement
-
-```res sig
-type htmlMeterElement
-```
-
-## htmlModElement
-
-```res sig
-type htmlModElement
-```
-
-## htmlOListElement
-
-```res sig
-type htmlOListElement
-```
-
-## htmlObjectElement
-
-```res sig
-type htmlObjectElement
-```
-
-## htmlOptGroupElement
-
-```res sig
-type htmlOptGroupElement
-```
-
-## htmlOptionElement
-
-```res sig
-type htmlOptionElement
-```
-
-## htmlOutputElement
-
-```res sig
-type htmlOutputElement
-```
-
-## htmlParagraphElement
-
-```res sig
-type htmlParagraphElement
-```
-
-## htmlParamElement
-
-```res sig
-type htmlParamElement
-```
-
-## htmlPreElement
-
-```res sig
-type htmlPreElement
-```
-
-## htmlProgressElement
-
-```res sig
-type htmlProgressElement 
-```
-
-## htmlQuoteElement
-
-```res sig
-type  htmlQuoteElement
-```
-
-## htmlScriptElement
-
-```res sig
-type htmlScriptElement
-```
-
-## htmlSelectElement
-
-```res sig
-type htmlSelectElement 
-```
-
-## htmlSlotElement
-
-```res sig
-type htmlSlotElement
-```
-
-## htmlSourceElement
-
-```res sig
-type htmlSourceElement
-```
-
-## htmlSpanElement
-
-```res sig
-type htmlSpanElement
-```
-
-## htmlStyleElement
-
-```res sig
-type htmlStyleElement
-```
-
-## htmlTableCaptionElement
-
-```res sig
-type htmlTableCaptionElement
-```
-
-## htmlTableCellElement
-
-```res sig
-type htmlTableCellElement
-```
-
-## htmlTableColElement
-
-```res sig
-type htmlTableColElement
-```
-
-## htmlTableDataCellElement
-
-```res sig
-type htmlTableDataCellElement
-```
-
-## htmlTableElement
-
-```res sig
-type htmlTableElement
-```
-
-## htmlTableHeaderCellElement
-
-```res sig
-type htmlTableHeaderCellElement
-```
-
-## htmlTableRowElement
-
-```res sig
-type htmlTableRowElement
-```
-
-## htmlTableSectionElement
-
-```res sig
-type htmlTableSectionElement
-```
-
-## htmlTextAreaElement
-
-```res sig
-type htmlTextAreaElement
-```
-
-## htmlTimeElement
-
-```res sig
-type htmlTimeElement
-```
-
-## htmlTitleElement
-
-```res sig
-type htmlTitleElement
-```
-
-## htmlTrackElement
-
-```res sig
-type htmlTrackElement
-```
-
-## htmlUlistElement
-
-```res sig
-type htmlUlistElement
-```
-
-## htmlUnknownElement
-
-```res sig
-type htmlUnknownElement
-```
-
-## htmlVideoElement
-
-```res sig
-type htmlVideoElement
-```
-
-## location
-
-```res sig
-type location
-```
-
-## window
-
-```res sig
-type window
-```
-
-## xmlDocument
-
-```res sig
-type xmlDocument
-```
-
-## event
-
-```res sig
-type event
-```
-
-## uiEvent 
-
-```res sig
-type uiEvent
-```
-
-## animationEvent
-
-```res sig
-type animationEvent
-```
-
-## beforeUnloadEvent
-
-```res sig
-type beforeUnloadEvent
-```
-
-## clipboardEvent
-
-```res sig
-type clipboardEvent
-```
-
-## closeEvent
-
-```res sig
-type closeEvent
-```
-
-## compositionEvent
-
-```res sig
-type compositionEvent
-```
-
-## customEvent
-
-```res sig
-type customEvent
-```
-
-## dragEvent
-
-```res sig
-type dragEvent
-```
-
-## errorEvent
-
-```res sig
-type errorEvent
-```
-
-## focusEvent
-
-```res sig
-type focusEvent
-```
-
-## idbVersionChangeEvent
-
-```res sig
-type idbVersionChangeEvent
-```
-
-## inputEvent
-
-```res sig
-type inputEvent
-```
-
-## keyboardEvent
-
-```res sig
-type keyboardEvent
-```
-
-## mouseEvent
-
-```res sig
-type mouseEvent
-```
-
-## pageTransitionEvent
-
-```res sig
-type pageTransitionEvent
-```
-
-## pointerEvent
-
-```res sig
-type pointerEvent
-```
-
-## popStateEvent
-
-```res sig
-type popStateEvent
-```
-
-## progressEvent
-
-```res sig
-type progressEvent
-```
-
-## relatedEvent
-
-```res sig
-type relatedEvent
-```
-
-## storageEvent
-
-```res sig
-type storageEvent
-```
-
-## svgZoomEvent
-
-```res sig
-type svgZoomEvent
-```
-
-## timeEvent
-
-```res sig
-type timeEvent
-```
-
-## touchEvent
-
-```res sig
-type touchEvent
-```
-
-## trackEvent
-
-```res sig
-type trackEvent
-```
-
-## transitionEvent
-
-```res sig
-type transitionEvent
-```
-
-## webGlContextEvent
-
-```res sig
-type webGlContextEvent
-```
-
-## wheelEvent
-
-```res sig
-type wheelEvent
-```
-
-## range
-
-```res sig
-type range
-```
-
-## selection
-
-```res sig
-type selection
-```
-
-## domTokenList
-
-```res sig
-type domTokenList
-```
-
-## domSettableTokenList
-
-```res sig
-type domSettableTokenList
-```
-
-## nodeFilter
-
-```res sig
-type nodeFilter = {
-  acceptNode: (Dom.element) => int
-}
-```
-
-## nodeIterator
-
-```res sig
-type nodeIterator
-```
-
-## treeWalker
-
-```res sig
-type treeWalker
-```
-
-## svgRect
-
-```res sig
-type svgRect
-```
-
-## svgPoint
-
-```res sig
-type svgPoint
-```
-
-## eventPointerId
-
-```res sig
-type eventPointerId
-```
diff --git a/pages/docs/manual/v10.0.0/api/dom/storage.mdx b/pages/docs/manual/v10.0.0/api/dom/storage.mdx
deleted file mode 100644
index 281240683..000000000
--- a/pages/docs/manual/v10.0.0/api/dom/storage.mdx
+++ /dev/null
@@ -1,55 +0,0 @@
-# Storage
-
-## t
-
-```res prelude sig
-type t
-```
-
-## getItem
-
-```res sig
-external getItem: (string, t) => option<string> = "getItem"
-```
-
-## setItem
-
-```res sig
-external setItem: (string, string, t) => unit = "setItem"
-```
-
-## removeItem
-
-```res sig
-external removeItem: (string, t) => unit = "removeItem"
-```
-
-## clear
-
-```res sig
-external clear: t => unit = "clear"
-```
-
-## key
-
-```res sig
-external key: (int, t) => option<string> = "key"
-```
-
-## length
-
-```res sig
-external length: t => int = "length"
-```
-
-## localStorage
-
-```res sig
-@val external localStorage: t = "localStorage"
-```
-
-## sessionStorage
-
-```res sig
-@val external sessionStorage: t = "sessionStorage"
-```
diff --git a/pages/docs/manual/v10.0.0/api/dom/storage2.mdx b/pages/docs/manual/v10.0.0/api/dom/storage2.mdx
deleted file mode 100644
index 5292b85a3..000000000
--- a/pages/docs/manual/v10.0.0/api/dom/storage2.mdx
+++ /dev/null
@@ -1,61 +0,0 @@
-# Storage2
-
-<Intro>
-
-The same as [Dom.Storage](./storage2), but with `t` on first argument position for proper `->` usage.
-
-</Intro>
-
-## t
-
-```res prelude sig
-type t
-```
-
-## getItem
-
-```res sig
-external getItem: (t, string) => option<string> = "getItem"
-```
-
-## setItem
-
-```res sig
-external setItem: (t, string, string) => unit = "setItem"
-```
-
-## removeItem
-
-```res sig
-external removeItem: (t, string) => unit = "removeItem"
-```
-
-## clear
-
-```res sig
-external clear: t => unit = "clear"
-```
-
-## key
-
-```res sig
-external key: (t, int) => option<string> = "key"
-```
-
-## length
-
-```res sig
-external length: t => int = "length"
-```
-
-## localStorage
-
-```res sig
-@val external localStorage: t = "localStorage"
-```
-
-## sessionStorage
-
-```res sig
-@val external sessionStorage: t = "sessionStorage"
-```
diff --git a/pages/docs/manual/v10.0.0/api/js.mdx b/pages/docs/manual/v10.0.0/api/js.mdx
deleted file mode 100644
index d3aea4c57..000000000
--- a/pages/docs/manual/v10.0.0/api/js.mdx
+++ /dev/null
@@ -1,178 +0,0 @@
-# Js
-
-The Js module mostly contains ReScript bindings to _standard JavaScript APIs_
-like [console.log](https://developer.mozilla.org/en-US/docs/Web/API/Console/log),
-or the JavaScript
-[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String),
-[Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date), and
-[Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
-classes.
-
-It is meant as a zero-abstraction interop layer and directly exposes JavaScript functions as they are. If you can find your API in this module, prefer this over an equivalent Belt helper. For example, prefer [Js.Array2](js/array-2) over [Belt.Array](belt/array)
-
-## Argument Order
-
-For historical reasons, some APIs in the Js namespace (e.g. [Js.String](js/string)) are
-using the data-last argument order whereas others (e.g. [Js.Date](js/date)) are using data-first.
-
-For more information about these argument orders and the trade-offs between them, see
-[this blog post](https://www.javierchavarri.com/data-first-and-data-last-a-comparison/).
-
-_Eventually, all modules in the Js namespace are going to be migrated to data-first though._
-
-In the meantime, there are several options for dealing with the data-last APIs:
-
-```res example
-/* Js.String (data-last API used with pipe last operator) */
-Js.log("2019-11-10" |> Js.String.split("-"))
-Js.log("ReScript" |> Js.String.startsWith("Re"))
-
-/* Js.String (data-last API used with pipe first operator) */
-Js.log("2019-11-10"->Js.String.split("-", _))
-Js.log("ReScript"->Js.String.startsWith("Re", _))
-
-/* Js.String (data-last API used without any piping) */
-Js.log(Js.String.split("-", "2019-11-10"))
-Js.log(Js.String.startsWith("Re", "ReScript"))
-```
-## Js.Xxx2 Modules
-
-Prefer `Js.Array2` over `Js.Array`, `Js.String2` over `Js.String`, etc. The latters are old modules.
-
-## Object
-
-```res sig
-type t<+'a>
-```
-
-Js object type.
-
-```res example
-let x: {"x": int, "y": int} = {"x": 1, "y": 2}
-```
-
-## Nullable and Undefined
-
-```res prelude
-type null<+'a>
-```
-
-nullable, value of this type can be either null or 'a this type is the same as type t in Js.Null
-
-```res prelude
-type undefined<+'a>
-```
-
-value of this type can be either undefined or 'a this type is the same as type t in Js.Undefined
-
-```res prelude
-type nullable<+'a>
-```
-
-value of this type can be undefined, null or 'a this type is the same as type t n Js.Null_undefined
-
-```res prelude
-type null_undefined<'a> = Js.nullable<'a>
-```
-
-```res sig
-let toOption: Js.nullable<'a> => option<'a>
-```
-
-```res sig
-let undefinedToOption: Js.undefined<'a> => option<'a>
-```
-
-```res sig
-let nullToOption: Js.null<'a> => option<'a>
-```
-
-```res sig
-let test: Js.nullable<'a> => bool
-```
-
-```res sig
-let isNullable: Js.nullable<'a> => bool
-```
-
-```res sig
-let testAny: 'a => bool
-```
-
-The same as `Js.test` except that it is more permissive on the types of input.
-
-```res sig
-type promise<+'a, +'e>
-```
-
-Deprecated. please use `Js.Promise`.
-The promise type, defined here for interoperation across packages.
-
-```res sig
-let null: Js.null<'a>
-```
-
-The same as empty in `Js.Null`. Will be compiled as `null`.
-
-```res sig
-let undefined: Js.undefined<'a>
-```
-
-The same as empty `Js.Undefined`. Will be compiled as `undefined`.
-
-## TypeOf
-
-```res sig
-let typeof: 'a => string
-```
-
-`typeof x` will be compiled as `typeof x` in JS. Please consider functions in `Js.Types` for a type safe way of reflection.
-
-## Logging
-
-```res sig
-let log: 'a => unit
-let log2: ('a, 'b) => unit
-let log3: ('a, 'b, 'c) => unit
-let log4: ('a, 'b, 'c, 'd) => unit
-```
-
-A convenience function to log everything.
-
-```res sig
-let logMany: array<'a> => unit
-```
-
-A convenience function to log more than 4 arguments
-
-## Comparison
-
-```res sig
-let eqNull: ('a, null<'a>) => bool
-let eqUndefined: ('a, undefined<'a>) => bool
-let eqNullable: ('a, nullable<'a>) => bool
-```
-
-```res sig
-let unsafe_lt: ('a, 'a) => bool
-```
-
-`unsafe_lt a b` will be compiled as `a < b`. It is marked as unsafe, since it is impossible to give a proper semantics for comparision which applies to any type.
-
-```res sig
-let unsafe_le: ('a, 'a) => bool
-```
-
-`unsafe_le a b` will be compiled as `a <= b`. See also `Js.unsafe_lt`.
-
-```res sig
-let unsafe_gt: ('a, 'a) => bool
-```
-
-`unsafe_gt a b` will be compiled as `a > b`. See also `Js.unsafe_lt`.
-
-```res sig
-let unsafe_ge: ('a, 'a) => bool
-```
-
-`unsafe_ge a b` will be compiled as `a >= b`. See also `Js.unsafe_lt`.
diff --git a/pages/docs/manual/v10.0.0/api/js/array-2.mdx b/pages/docs/manual/v10.0.0/api/js/array-2.mdx
deleted file mode 100644
index 393134ce6..000000000
--- a/pages/docs/manual/v10.0.0/api/js/array-2.mdx
+++ /dev/null
@@ -1,850 +0,0 @@
-# Array2
-
-<Intro>
-
-Provides bindings to JavaScript’s `Array` functions. These bindings are optimized for pipe-first (`->`), where the array to be processed is the first parameter in the function.
-
-Here is an example to find the sum of squares of all even numbers in an array.
-Without pipe first, we must call the functions in reverse order:
-
-```res example
-let isEven = x => mod(x, 2) == 0
-let square = x => x * x
-let result = {
-  open Js.Array2
-  reduce(map(filter([5, 2, 3, 4, 1], isEven), square), \"+", 0)
-}
-```
-
-With pipe first, we call the functions in the “natural” order:
-
-```res example
-let isEven = x => mod(x, 2) == 0
-let square = x => x * x
-let result = {
-  open Js.Array2
-  [5, 2, 3, 4, 1]->filter(isEven)->map(square)->reduce(\"+", 0)
-}
-```
-</Intro>
-
-## t
-
-```res prelude
-type t<'a> = array<'a>
-```
-
-The type used to describe a JavaScript array.
-
-## array_like
-
-```res prelude
-type array_like<'a>
-```
-
-A type used to describe JavaScript objects that are like an array or are iterable.
-
-## from
-
-```res sig
-let from: array_like<'a> => array<'a>
-```
-
-Creates a shallow copy of an array from an array-like object. See [`Array.from`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from) on MDN.
-
-```res example
-let strArr = Js.String.castToArrayLike("abcd")
-Js.Array2.from(strArr) == ["a", "b", "c", "d"]
-```
-
-## fromMap
-
-```res sig
-let fromMap: (array_like<'a>, 'a => 'b) => array<'b>
-```
-
-Creates a new array by applying a function (the second argument) to each item in the `array_like` first argument.  See [`Array.from`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from) on MDN.
-
-```res example
-let strArr = Js.String.castToArrayLike("abcd")
-let code = s => Js.String.charCodeAt(0, s)
-Js.Array2.fromMap(strArr, code) == [97.0, 98.0, 99.0, 100.0]
-```
-
-## isArray
-
-```res sig
-let isArray: 'a => bool
-```
-
-Returns `true` if its argument is an array; `false` otherwise. This is a runtime check, which is why the second example returns `true`---a list is internally represented as a nested JavaScript array.
-
-```res example
-Js.Array2.isArray([5, 2, 3, 1, 4]) == true
-Js.Array2.isArray(list{5, 2, 3, 1, 4}) == true
-Js.Array2.isArray("abcd") == false
-```
-
-## length
-
-```res sig
-let length: array<'a> => int
-```
-
-Returns the number of elements in the array. See [`Array.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length) on MDN.
-
-## copyWithin
-
-```res sig
-let copyWithin: (t<'a>, ~to_: int) => t<'a>
-```
-
-Copies from the first element in the given array to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array2.copyWithin(arr, ~to_=2) == [100, 101, 100, 101, 102]
-arr == [100, 101, 100, 101, 102]
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (t<'a>, ~to_: int, ~from: int) => t<'a>
-```
-
-Copies starting at element `~from` in the given array to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array2.copyWithinFrom(arr, ~from=2, ~to_=0) == [102, 103, 104, 103, 104]
-arr == [102, 103, 104, 103, 104]
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (t<'a>, ~to_: int, ~start: int, ~end_: int) => t<'a>
-```
-
-Copies starting at element `~start` in the given array up to but not including `~end_` to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104, 105]
-Js.Array2.copyWithinFromRange(arr, ~start=2, ~end_=5, ~to_=1) == [100, 102, 103, 104, 104, 105]
-arr == [100, 102, 103, 104, 104, 105]
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (t<'a>, 'a) => t<'a>
-```
-Sets all elements of the given array (the first arumgent) to the designated value (the secon argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array2.fillInPlace(arr, 99) == [99, 99, 99, 99, 99]
-arr == [99, 99, 99, 99, 99]
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (t<'a>, 'a, ~from: int) => t<'a>
-```
-Sets all elements of the given array (the first arumgent) from position `~from` to the end to the designated value (the second argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array2.fillFromInPlace(arr, 99, ~from=2) == [100, 101, 99, 99, 99]
-arr == [100, 101, 99, 99, 99]
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (t<'a>, 'a, ~start: int, ~end_: int) => t<'a>
-```
-Sets the elements of the given array (the first arumgent) from position `~start` up to but not including position `~end_` to the designated value (the second argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array2.fillRangeInPlace(arr, 99, ~start=1, ~end_=4) == [100, 99, 99, 99, 104]
-arr == [100, 99, 99, 99, 104]
-```
-
-## pop
-
-```res sig
-let pop: t<'a> => option<'a>
-```
-If the array is not empty, removes the last element and returns it as `Some(value)`; returns `None` if the array is empty. *This function modifies the original array.* See [`Array.pop`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array2.pop(arr) == Some(104)
-arr == [100, 101, 102, 103]
-
-let empty: array<int> = []
-Js.Array2.pop(empty) == None
-```
-
-## push
-
-```res sig
-let push: (t<'a>, 'a) => int
-```
-Appends the given value to the array, returning the number of elements in the updated array. *This function modifies the original array.* See [`Array.push`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) on MDN.
-
-```res example
-let arr = ["ant", "bee", "cat"]
-Js.Array2.push(arr, "dog") == 4
-arr == ["ant", "bee", "cat", "dog"]
-```
-
-## pushMany
-
-```res sig
-let pushMany: (t<'a>, array<'a>) => int
-```
-Appends the values from one array (the second argument) to another (the first argument), returning the number of elements in the updated array. *This function modifies the original array.* See [`Array.push`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) on MDN.
-
-```res example
-let arr = ["ant", "bee", "cat"]
-Js.Array2.pushMany(arr, ["dog", "elk"]) == 5
-arr == ["ant", "bee", "cat", "dog", "elk"]
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t<'a> => t<'a>
-```
-Returns an array with the elements of the input array in reverse order. *This function modifies the original array.* See [`Array.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse) on MDN.
-
-```res example
-let arr = ["ant", "bee", "cat"]
-Js.Array2.reverseInPlace(arr) == ["cat", "bee", "ant"]
-arr == ["cat", "bee", "ant"]
-```
-
-## shift
-
-```res sig
-let shift: t<'a> => option<'a>
-```
-If the array is not empty, removes the first element and returns it as `Some(value)`; returns `None` if the array is empty. *This function modifies the original array.* See [`Array.shift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array2.shift(arr) == Some(100)
-arr == [101, 102, 103, 104]
-
-let empty: array<int> = []
-Js.Array2.shift(empty) == None
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t<'a> => t<'a>
-```
-Sorts the given array in place and returns the sorted array. JavaScript sorts the array by converting the arguments to UTF-16 strings and sorting them. See the second example with sorting numbers, which does not do a numeric sort. *This function modifies the original array.* See [`Array.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) on MDN.
-
-```res example
-let words = ["bee", "dog", "ant", "cat"]
-Js.Array2.sortInPlace(words) == ["ant", "bee", "cat", "dog"]
-words == ["ant", "bee", "cat", "dog"]
-
-let numbers = [3, 30, 10, 1, 20, 2]
-Js.Array2.sortInPlace(numbers) == [1, 10, 2, 20, 3, 30]
-numbers == [1, 10, 2, 20, 3, 30]
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: (t<'a>, ('a, 'a) => int) => t<'a>
-```
-Sorts the given array in place and returns the sorted array. *This function modifies the original array.*
-
-The first argument to `sortInPlaceWith()` is a function that compares two items from the array and returns:
-
-* an integer less than zero if the first item is less than the second item
-* zero if the items are equal
-* an integer greater than zero if the first item is greater than the second item
-
-See [`Array.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) on MDN.
-
-```res example
-// sort by word length
-let words = ["horse", "aardvark", "dog", "camel"]
-let byLength = (s1, s2) => Js.String.length(s1) - Js.String.length(s2)
-
-Js.Array2.sortInPlaceWith(words, byLength) == ["dog", "horse", "camel", "aardvark"]
-
-// sort in reverse numeric order
-let numbers = [3, 30, 10, 1, 20, 2]
-let reverseNumeric = (n1, n2) => n2 - n1
-Js.Array2.sortInPlaceWith(numbers, reverseNumeric) == [30, 20, 10, 3, 2, 1]
-```
-
-## spliceInPlace
-
-```res sig
-let spliceInPlace: (t<'a>, ~pos: int, ~remove: int, ~add: array<'a>) => t<'a>
-```
-Starting at position `~pos`, remove `~remove` elements and then add the elements from the `~add` array. Returns an array consisting of the removed items. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```res example
-let arr = ["a", "b", "c", "d", "e", "f"]
-Js.Array2.spliceInPlace(arr, ~pos=2, ~remove=2, ~add=["x", "y", "z"]) == ["c", "d"]
-arr == ["a", "b", "x", "y", "z", "e", "f"]
-
-let arr2 = ["a", "b", "c", "d"]
-Js.Array2.spliceInPlace(arr2, ~pos=3, ~remove=0, ~add=["x", "y"]) == []
-arr2 == ["a", "b", "c", "x", "y", "d"]
-
-let arr3 = ["a", "b", "c", "d", "e", "f"]
-Js.Array2.spliceInPlace(arr3, ~pos=9, ~remove=2, ~add=["x", "y", "z"]) == []
-arr3 == ["a", "b", "c", "d", "e", "f", "x", "y", "z"]
-```
-
-## removeFromInPlace
-
-```res sig
-let removeFromInPlace: (t<'a>, ~pos: int) => t<'a>
-```
-Removes elements from the given array starting at position `~pos` to the end of the array, returning the removed elements. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```res example
-let arr = ["a", "b", "c", "d", "e", "f"]
-Js.Array2.removeFromInPlace(arr, ~pos=4) == ["e", "f"]
-arr == ["a", "b", "c", "d"]
-```
-
-## removeCountInPlace
-
-```res sig
-let removeCountInPlace: (t<'a>, ~pos: int, ~count: int) => t<'a>
-```
-Removes `~count` elements from the given array starting at position `~pos`, returning the removed elements. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```res example
-let arr = ["a", "b", "c", "d", "e", "f"]
-Js.Array2.removeCountInPlace(arr, ~pos=2, ~count=3) == ["c", "d", "e"]
-arr == ["a", "b", "f"]
-```
-
-## unshift
-
-```res sig
-let unshift: (t<'a>, 'a) => int
-```
-Adds the given element to the array, returning the new number of elements in the array. *This function modifies the original array.* See [`Array.unshift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) on MDN.
-
-```res example
-let arr = ["b", "c", "d"]
-Js.Array2.unshift(arr, "a") == 4
-arr == ["a", "b", "c", "d"]
-```
-
-## unshiftMany
-
-```res sig
-let unshiftMany: (t<'a>, array<'a>) => int
-```
-Adds the elements in the second array argument at the beginning of the first array argument, returning the new number of elements in the array. *This function modifies the original array.* See [`Array.unshift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) on MDN.
-
-```res example
-let arr = ["d", "e"]
-Js.Array2.unshiftMany(arr, ["a", "b", "c"]) == 5
-arr == ["a", "b", "c", "d", "e"]
-```
-
-## append
-
-```res sig
-let append: (t<'a>, 'a) => t<'a>
-```
-Deprecated. `append()` is not type-safe. Use `concat()` instead.
-
-## concat
-
-```res sig
-let concat: (t<'a>, t<'a>) => t<'a>
-```
-Concatenates the second array argument to the first array argument, returning a new array. The original arrays are not modified. See [`Array.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat) on MDN.
-
-```res example
-Js.Array2.concat(["a", "b"], ["c", "d", "e"]) == ["a", "b", "c", "d", "e"]
-```
-
-## concatMany
-
-```res sig
-let concatMany: (t<'a>, array<t<'a>>) => t<'a>
-```
-The second argument to `concatMany()` is an array of arrays; these are added at the end of the first argument, returning a new array. See [`Array.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat) on MDN.
-
-```res example
-Js.Array2.concatMany(["a", "b", "c"], [["d", "e"], ["f", "g", "h"]]) == [
-    "a",
-    "b",
-    "c",
-    "d",
-    "e",
-    "f",
-    "g",
-    "h",
-  ]
-```
-
-## includes
-
-```res sig
-let includes: (t<'a>, 'a) => bool
-```
-Returns true if the given value is in the array, `false` otherwise. See [`Array.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes) on MDN.
-
-```res example
-Js.Array2.includes(["a", "b", "c"], "b") == true
-Js.Array2.includes(["a", "b", "c"], "x") == false
-```
-
-## indexOf
-
-```res sig
-let indexOf: (t<'a>, 'a) => int
-```
-Returns the index of the first element in the array that has the given value. If the value is not in the array, returns -1. See [`Array.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf) on MDN.
-
-```res example
-Js.Array2.indexOf([100, 101, 102, 103], 102) == 2
-Js.Array2.indexOf([100, 101, 102, 103], 999) == -1
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (t<'a>, 'a, ~from: int) => int
-```
-Returns the index of the first element in the array with the given value. The search starts at position `~from`. See [`Array.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf) on MDN.
-
-```res example
-Js.Array2.indexOfFrom(["a", "b", "a", "c", "a"], "a", ~from=2) == 2
-Js.Array2.indexOfFrom(["a", "b", "a", "c", "a"], "a", ~from=3) == 4
-Js.Array2.indexOfFrom(["a", "b", "a", "c", "a"], "b", ~from=2) == -1
-```
-
-## joinWith
-
-```res sig
-let joinWith: (t<'a>, string) => string
-```
-This function converts each element of the array to a string (via JavaScript) and concatenates them, separated by the string given in the first argument, into a single string. See [`Array.join`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join) on MDN.
-
-```res example
-Js.Array2.joinWith(["ant", "bee", "cat"], "--") == "ant--bee--cat"
-Js.Array2.joinWith(["door", "bell"], "") == "doorbell"
-Js.Array2.joinWith([2020, 9, 4], "/") == "2020/9/4"
-Js.Array2.joinWith([2.5, 3.6, 3e-2], ";") == "2.5;3.6;0.03"
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (t<'a>, 'a) => int
-```
-Returns the index of the last element in the array that has the given value. If the value is not in the array, returns -1. See [`Array.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) on MDN.
-
-```res example
-Js.Array2.lastIndexOf(["a", "b", "a", "c"], "a") == 2
-Js.Array2.lastIndexOf(["a", "b", "a", "c"], "x") == -1
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (t<'a>, 'a, ~from: int) => int
-```
-Returns the index of the last element in the array that has the given value, searching from position `~from` down to the start of the array. If the value is not in the array, returns -1. See [`Array.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) on MDN.
-
-```res example
-Js.Array2.lastIndexOfFrom(["a", "b", "a", "c", "a", "d"], "a", ~from=3) == 2
-Js.Array2.lastIndexOfFrom(["a", "b", "a", "c", "a", "d"], "c", ~from=2) == -1
-```
-
-## slice
-
-```res sig
-let slice: (t<'a>, ~start: int, ~end_: int) => t<'a>
-```
-Returns a shallow copy of the given array from the `~start` index up to but not including the `~end_` position. Negative numbers indicate an offset from the end of the array. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104, 105, 106]
-Js.Array2.slice(arr, ~start=2, ~end_=5) == [102, 103, 104]
-Js.Array2.slice(arr, ~start=-3, ~end_=-1) == [104, 105]
-Js.Array2.slice(arr, ~start=9, ~end_=10) == []
-```
-
-## copy
-
-```res sig
-let copy: t<'a> => t<'a>
-```
-Returns a copy of the entire array. Same as `Js.Array2.Slice(arr, ~start=0, ~end_=Js.Array2.length(arr))`. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-## sliceFrom
-
-```res sig
-let sliceFrom: (t<'a>, int) => t<'a>
-```
-Returns a shallow copy of the given array from the given index to the end. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-
-```res example
-Js.Array2.sliceFrom([100, 101, 102, 103, 104], 2) == [102, 103, 104]
-```
-
-## toString
-
-```res sig
-let toString: t<'a> => string
-```
-Converts the array to a string. Each element is converted to a string using JavaScript. Unlike the JavaScript `Array.toString()`, all elements in a ReasonML array must have the same type. See [`Array.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString) on MDN.
-
-```res example
-Js.Array2.toString([3.5, 4.6, 7.8]) == "3.5,4.6,7.8"
-Js.Array2.toString(["a", "b", "c"]) == "a,b,c"
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t<'a> => string
-```
-Converts the array to a string using the conventions of the current locale. Each element is converted to a string using JavaScript. Unlike the JavaScript `Array.toLocaleString()`, all elements in a ReasonML array must have the same type. See [`Array.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toLocaleString) on MDN.
-
-```res example
-Js.Array2.toLocaleString([Js.Date.make()])
-// returns "3/19/2020, 10:52:11 AM" for locale en_US.utf8
-// returns "2020-3-19 10:52:11" for locale de_DE.utf8
-```
-
-## every
-
-```res sig
-let every: (t<'a>, 'a => bool) => bool
-```
-The first argument to `every()` is an array. The second argument is a predicate function that returns a boolean. The `every()` function returns `true` if the predicate function is true for all items in the given array. If given an empty array, returns `true`. See [`Array.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) on MDN.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-Js.Array2.every([6, 22, 8, 4], isEven) == true
-Js.Array2.every([6, 22, 7, 4], isEven) == false
-```
-
-## everyi
-
-```res sig
-let everyi: (t<'a>, ('a, int) => bool) => bool
-```
-
-The first argument to `everyi()` is an array. The second argument is a predicate function with two arguments: an array element and that element’s index; it returns a boolean. The `everyi()` function returns `true` if the predicate function is true for all items in the given array. If given an empty array, returns `true`. See [`Array.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) on MDN.
-
-```res example
-// determine if all even-index items are positive
-let evenIndexPositive = (item, index) => mod(index, 2) == 0 ? item > 0 : true
-
-Js.Array2.everyi([6, -3, 5, 8], evenIndexPositive) == true
-Js.Array2.everyi([6, 3, -5, 8], evenIndexPositive) == false
-```
-
-## filter
-
-```res sig
-let filter: (t<'a>, 'a => bool) => t<'a>
-```
-Applies the given predicate function (the second argument) to each element in the array; the result is an array of those elements for which the predicate function returned `true`. See [`Array.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) on MDN.
-
-```res example
-let nonEmpty = s => s != ""
-Js.Array2.filter(["abc", "", "", "def", "ghi"], nonEmpty) == ["abc", "def", "ghi"]
-```
-
-## filteri
-
-```res sig
-let filteri: (t<'a>, ('a, int) => bool) => t<'a>
-```
-Each element of the given array are passed to the predicate function. The return value is an array of all those elements for which the predicate function returned `true`.  See [`Array.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) on MDN.
-
-```res example
-// keep only positive elements at odd indices
-let positiveOddElement = (item, index) => mod(index, 2) == 1 && item > 0
-
-Js.Array2.filteri([6, 3, 5, 8, 7, -4, 1], positiveOddElement) == [3, 8]
-```
-
-## find
-
-```res sig
-let find: (t<'a>, 'a => bool) => option<'a>
-```
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```res example
-// find first negative element
-Js.Array2.find([33, 22, -55, 77, -44], x => x < 0) == Some(-55)
-Js.Array2.find([33, 22, 55, 77, 44], x => x < 0) == None
-```
-
-## findi
-
-```res sig
-let findi: (t<'a>, ('a, int) => bool) => option<'a>
-```
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. The predicate function takes an array element and an index as its parameters. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```res example
-// find first positive item at an odd index
-let positiveOddElement = (item, index) => mod(index, 2) == 1 && item > 0
-
-Js.Array2.findi([66, -33, 55, 88, 22], positiveOddElement) == Some(88)
-Js.Array2.findi([66, -33, 55, -88, 22], positiveOddElement) == None
-```
-
-## findIndex
-
-```res sig
-let findIndex: (t<'a>, 'a => bool) => int
-```
-Returns the index of the first element in the array that satisifies the given predicate function, or -1 if no element satisifies the predicate. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```res example
-Js.Array2.findIndex([33, 22, -55, 77, -44], x => x < 0) == 2
-Js.Array2.findIndex([33, 22, 55, 77, 44], x => x < 0) == -1
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: (t<'a>, ('a, int) => bool) => int
-```
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. The predicate function takes an array element and an index as its parameters. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```res example
-// find index of first positive item at an odd index
-let positiveOddElement = (item, index) => mod(index, 2) == 1 && item > 0
-
-Js.Array2.findIndexi([66, -33, 55, 88, 22], positiveOddElement) == 3
-Js.Array2.findIndexi([66, -33, 55, -88, 22], positiveOddElement) == -1
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'a>, 'a => unit) => unit
-```
-The `forEach()` function applies the function given as the second argument to each element in the array. The function you provide returns `unit`, and the `forEach()` function also returns `unit`. You use `forEach()` when you need to process each element in the array but not return any new array or value; for example, to print the items in an array. See [`Array.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) on MDN.
-
-```res example
-// display all elements in an array
-Js.Array2.forEach(["a", "b", "c"], x => Js.log(x)) == ()
-```
-
-## forEachi
-
-```res sig
-let forEachi: (t<'a>, ('a, int) => unit) => unit
-```
-The `forEachi()` function applies the function given as the second argument to each element in the array. The function you provide takes an item in the array and its index number, and returns `unit`. The `forEachi()` function also returns `unit`. You use `forEachi()` when you need to process each element in the array but not return any new array or value; for example, to print the items in an array. See [`Array.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) on MDN.
-
-```res example
-// display all elements in an array as a numbered list
-Js.Array2.forEachi(["a", "b", "c"], (item, index) => Js.log2(index + 1, item)) == ()
-```
-
-## map
-
-```res sig
-let map: (t<'a>, 'a => 'b) => t<'b>
-```
-Applies the function (the second argument) to each item in the array, returning a new array. The result array does not have to have elements of the same type as the input array. See [`Array.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) on MDN.
-
-```res example
-Js.Array2.map([12, 4, 8], x => x * x) == [144, 16, 64]
-Js.Array2.map(["animal", "vegetable", "mineral"], Js.String.length) == [6, 9, 7]
-```
-
-## mapi
-
-```res sig
-let mapi: (t<'a>, ('a, int) => 'b) => t<'b>
-```
-Applies the function (the second argument) to each item in the array, returning a new array. The function acceps two arguments: an item from the array and its index number. The result array does not have to have elements of the same type as the input array. See [`Array.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) on MDN.
-
-```res example
-// multiply each item in array by its position
-let product = (item, index) => item * index
-Js.Array2.mapi([10, 11, 12], product) == [0, 11, 24]
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'a>, ('b, 'a) => 'b, 'b) => 'b
-```
-The `reduce()` function takes three parameters: an array, a *reducer function*,  and a beginning accumulator value. The reducer function has two parameters: an accumulated value and an element of the array.
-
-`reduce()` first calls the reducer function with the beginning value and the first element in the array. The result becomes the new accumulator value, which is passed in to the reducer function along with the second element in the array. `reduce()` proceeds through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduce()`. See [`Array.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) on MDN.
-
-```res example
-let sumOfSquares = (accumulator, item) => accumulator + item * item
-
-Js.Array2.reduce([10, 2, 4], sumOfSquares, 0) == 120
-Js.Array2.reduce([10, 2, 4], \"*", 1) == 80
-Js.Array2.reduce(
-  ["animal", "vegetable", "mineral"],
-  (acc, item) => acc + Js.String.length(item),
-  0,
-) == 22 // 6 + 9 + 7
-Js.Array2.reduce([2.0, 4.0], (acc, item) => item /. acc, 1.0) == 2.0 // 4.0 / (2.0 / 1.0)
-```
-
-## reducei
-
-```res sig
-let reducei: (t<'a>, ('b, 'a, int) => 'b, 'b) => 'b
-```
-The `reducei()` function takes three parameters: an array, a *reducer function*, and a beginning accumulator value. The reducer function has three parameters: an accumulated value, an element of the array, and the index of that element.
-
-`reducei()` first calls the reducer function with the beginning value, the first element in the array, and zero (its index). The result becomes the new accumulator value, which is passed to the reducer function along with the second element in the array and one (its index). `reducei()` proceeds from left to right through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reducei()`. See [`Array.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) on MDN.
-
-```res example
-// find sum of even-index elements in array
-let sumOfEvens = (accumulator, item, index) =>
-  if mod(index, 2) == 0 {
-    accumulator + item
-  } else {
-    accumulator
-  }
-
-Js.Array2.reducei([2, 5, 1, 4, 3], sumOfEvens, 0) == 6
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: (t<'a>, ('b, 'a) => 'b, 'b) => 'b
-```
-The `reduceRight()` function takes three parameters: an array, a *reducer function*, and a beginning accumulator value. The reducer function has two parameters: an accumulated value and an element of the array.
-
-`reduceRight()` first calls the reducer function with the beginning value and the last element in the array. The result becomes the new accumulator value, which is passed in to the reducer function along with the next-to-last element in the array. `reduceRight()` proceeds from right to left through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduceRight()`.  See [`Array.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight) on MDN.
-
-**NOTE:** In many cases, `reduce()` and `reduceRight()` give the same result. However, see the last example here and compare it to the example from `reduce()`, where order makes a difference.
-
-```res example
-let sumOfSquares = (accumulator, item) => accumulator + item * item
-
-Js.Array2.reduceRight([10, 2, 4], sumOfSquares, 0) == 120
-Js.Array2.reduceRight([2.0, 4.0], (acc, item) => item /. acc, 1.0) == 0.5 // 2.0 / (4.0 / 1.0)
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: (t<'a>, ('b, 'a, int) => 'b, 'b) => 'b
-```
-The `reduceRighti()` function takes three parameters: an array, a *reducer function*, and a beginning accumulator value. The reducer function has three parameters: an accumulated value, an element of the array, and the index of that element. `reduceRighti()` first calls the reducer function with the beginning value, the last element in the array, and its index (length of array minus one). The result becomes the new accumulator value, which is passed in to the reducer function along with the second element in the array and one (its index). `reduceRighti()` proceeds from right to left through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduceRighti()`. See [`Array.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight) on MDN.
-
-**NOTE:** In many cases, `reducei()` and `reduceRighti()` give the same result. However, there are cases where the order in which items are processed makes a difference.
-
-```res example
-// find sum of even-index elements in array
-let sumOfEvens = (accumulator, item, index) =>
-  if mod(index, 2) == 0 {
-    accumulator + item
-  } else {
-    accumulator
-  }
-
-Js.Array2.reduceRighti([2, 5, 1, 4, 3], sumOfEvens, 0) == 6
-```
-
-## some
-
-```res sig
-let some: (t<'a>, 'a => bool) => bool
-```
-Returns `true` if the predicate function given as the second argument to `some()` returns `true` for any element in the array; `false` otherwise.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-Js.Array2.some([3, 7, 5, 2, 9], isEven) == true
-Js.Array2.some([3, 7, 5, 1, 9], isEven) == false
-```
-
-## somei
-
-```res sig
-let somei: (t<'a>, ('a, int) => bool) => bool
-```
-Returns `true` if the predicate function given as the second argument to `somei()` returns `true` for any element in the array; `false` otherwise. The predicate function has two arguments: an item from the array and the index value
-
-```res example
-// Does any string in the array
-// have the same length as its index?
-
-let sameLength = (str, index) => Js.String.length(str) == index
-
-// "ef" has length 2 and is it at index 2
-Js.Array2.somei(["ab", "cd", "ef", "gh"], sameLength) == true
-// no item has the same length as its index
-Js.Array2.somei(["a", "bc", "def", "gh"], sameLength) == false
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (array<'a>, int) => 'a
-```
-Returns the value at the given position in the array if the position is in bounds; returns the JavaScript value `undefined` otherwise.
-
-```res example
-let arr = [100, 101, 102, 103]
-Js.Array2.unsafe_get(arr, 3) == 103
-Js.Array2.unsafe_get(arr, 4) // returns undefined
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (array<'a>, int, 'a) => unit
-```
-Sets the value at the given position in the array if the position is in bounds. If the index is out of bounds, well, “here there be dragons.“ *This function modifies the original array.*
-
-```res example
-let arr = [100, 101, 102, 103]
-Js.Array2.unsafe_set(arr, 3, 99)
-// result is [100, 101, 102, 99];
-
-Js.Array2.unsafe_set(arr, 4, 88)
-// result is [100, 101, 102, 99, 88]
-
-Js.Array2.unsafe_set(arr, 6, 77)
-// result is [100, 101, 102, 99, 88, <1 empty item>, 77]
-
-Js.Array2.unsafe_set(arr, -1, 66)
-// you don't want to know.
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/array.mdx b/pages/docs/manual/v10.0.0/api/js/array.mdx
deleted file mode 100644
index 1ed2abb75..000000000
--- a/pages/docs/manual/v10.0.0/api/js/array.mdx
+++ /dev/null
@@ -1,926 +0,0 @@
-# Array
-
-<Intro>
-
-Provides bindings to JavaScript’s `Array` functions. These bindings are optimized for pipe-last (`|>`), where the array to be processed is the last parameter in the function.
-
-Here is an example to find the sum of squares of all even numbers in an array.
-Without pipe last, we must call the functions in reverse order:
-
-```res example
-let isEven = x => mod(x, 2) == 0
-let square = x => x * x
-let result = {
-  open Js.Array
-  reduce(\"+", 0, map(square, filter(isEven, [5, 2, 3, 4, 1])))
-}
-```
-
-With pipe last, we call the functions in the “natural” order:
-
-```res example
-let isEven = x => mod(x, 2) == 0
-let square = x => x * x
-let result = {
-  open Js.Array
-  [5, 2, 3, 4, 1] |> filter(isEven) |> map(square) |> reduce(\"+", 0)
-}
-```
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a> = array<'a>
-```
-
-The type used to describe a JavaScript array.
-
-## array_like
-
-```res prelude
-type array_like<'a> = Js_array2.array_like<'a>
-```
-
-A type used to describe JavaScript objects that are like an array or are iterable.
-
-## from
-
-```res sig
-let from: array_like<'a> => array<'a>
-```
-
-Creates a shallow copy of an array from an array-like object. See [`Array.from`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from) on MDN.
-
-```res example
-let strArr = Js.String.castToArrayLike("abcd")
-Js.Array.from(strArr) == ["a", "b", "c", "d"]
-```
-
-## fromMap
-
-```res sig
-let fromMap: (array_like<'a>, 'a => 'b) => array<'b>
-```
-
-Creates a new array by applying a function (the second argument) to each item in the `array_like` first argument.  See [`Array.from`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from) on MDN.
-
-```res example
-let strArr = Js.String.castToArrayLike("abcd")
-let code = s => Js.String.charCodeAt(0, s)
-Js.Array.fromMap(strArr, code) == [97.0, 98.0, 99.0, 100.0]
-```
-
-## isArray
-
-```res sig
-let isArray: 'a => bool
-```
-
-Returns `true` if its argument is an array; `false` otherwise. This is a runtime check, which is why the second example returns `true`---a list is internally represented as a nested JavaScript array.
-
-```res example
-Js.Array.isArray([5, 2, 3, 1, 4]) == true
-Js.Array.isArray(list{5, 2, 3, 1, 4}) == true
-Js.Array.isArray("abcd") == false
-```
-
-## length
-
-```res sig
-let length: array<'a> => int
-```
-
-Returns the number of elements in the array. See [`Array.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length) on MDN.
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t<'a>) => t<'a>
-```
-
-Copies from the first element in the given array to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array.copyWithin(~to_=2, arr) == [100, 101, 100, 101, 102]
-arr == [100, 101, 100, 101, 102]
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t<'a>) => t<'a>
-```
-
-Copies starting at element `~from` in the given array to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array.copyWithinFrom(~from=2, ~to_=0, arr) == [102, 103, 104, 103, 104]
-arr == [102, 103, 104, 103, 104]
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t<'a>) => t<'a>
-```
-
-Copies starting at element `~start` in the given array up to but not including `~end_` to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104, 105]
-Js.Array.copyWithinFromRange(~start=2, ~end_=5, ~to_=1, arr) == [100, 102, 103, 104, 104, 105]
-arr == [100, 102, 103, 104, 104, 105]
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: ('a, t<'a>) => t<'a>
-```
-Sets all elements of the given array (the second arumgent) to the designated value (the first argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array.fillInPlace(99, arr) == [99, 99, 99, 99, 99]
-arr == [99, 99, 99, 99, 99]
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: ('a, ~from: int, t<'a>) => t<'a>
-```
-Sets all elements of the given array (the last arumgent) from position `~from` to the end to the designated value (the first argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array.fillFromInPlace(99, ~from=2, arr) == [100, 101, 99, 99, 99]
-arr == [100, 101, 99, 99, 99]
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: ('a, ~start: int, ~end_: int, t<'a>) => t<'a>
-```
-
-Sets the elements of the given array (the last arumgent) from position `~start` up to but not including position `~end_` to the designated value (the first argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array.fillRangeInPlace(99, ~start=1, ~end_=4, arr) == [100, 99, 99, 99, 104]
-arr == [100, 99, 99, 99, 104]
-```
-
-## pop
-
-```res sig
-let pop: t<'a> => option<'a>
-```
-
-If the array is not empty, removes the last element and returns it as `Some(value)`; returns `None` if the array is empty. *This function modifies the original array.* See [`Array.pop`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array.pop(arr) == Some(104)
-arr == [100, 101, 102, 103]
-
-let empty: array<int> = []
-Js.Array.pop(empty) == None
-```
-
-## push
-
-```res sig
-let push: ('a, t<'a>) => int
-```
-
-Appends the given value to the array, returning the number of elements in the updated array. *This function modifies the original array.* See [`Array.push`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) on MDN.
-
-```res example
-let arr = ["ant", "bee", "cat"]
-Js.Array.push("dog", arr) == 4
-arr == ["ant", "bee", "cat", "dog"]
-```
-
-## pushMany
-
-```res sig
-let pushMany: (array<'a>, t<'a>) => int
-```
-
-Appends the values from one array (the first argument) to another (the second argument), returning the number of elements in the updated array. *This function modifies the original array.* See [`Array.push`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) on MDN.
-
-```res example
-let arr = ["ant", "bee", "cat"]
-Js.Array.pushMany(["dog", "elk"], arr) == 5
-arr == ["ant", "bee", "cat", "dog", "elk"]
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t<'a> => t<'a>
-```
-
-Returns an array with the elements of the input array in reverse order. *This function modifies the original array.* See [`Array.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse) on MDN.
-
-```res example
-let arr = ["ant", "bee", "cat"]
-Js.Array.reverseInPlace(arr) == ["cat", "bee", "ant"]
-arr == ["cat", "bee", "ant"]
-```
-
-## shift
-
-```res sig
-let shift: t<'a> => option<'a>
-```
-If the array is not empty, removes the first element and returns it as `Some(value)`; returns `None` if the array is empty. *This function modifies the original array.* See [`Array.shift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array.shift(arr) == Some(100)
-arr == [101, 102, 103, 104]
-
-let empty: array<int> = []
-Js.Array.shift(empty) == None
-```
-## sortInPlace
-
-```res sig
-let sortInPlace: t<'a> => t<'a>
-```
-
-Sorts the given array in place and returns the sorted array. JavaScript sorts the array by converting the arguments to UTF-16 strings and sorting them. See the second example with sorting numbers, which does not do a numeric sort. *This function modifies the original array.* See [`Array.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) on MDN.
-
-```res example
-let words = ["bee", "dog", "ant", "cat"]
-Js.Array.sortInPlace(words) == ["ant", "bee", "cat", "dog"]
-words == ["ant", "bee", "cat", "dog"]
-
-let numbers = [3, 30, 10, 1, 20, 2]
-Js.Array.sortInPlace(numbers) == [1, 10, 2, 20, 3, 30]
-numbers == [1, 10, 2, 20, 3, 30]
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: (('a, 'a) => int, t<'a>) => t<'a>
-```
-
-Sorts the given array in place and returns the sorted array. *This function modifies the original array.*
-
-The first argument to `sortInPlaceWith()` is a function that compares two items from the array and returns:
-
-* an integer less than zero if the first item is less than the second item
-* zero if the items are equal
-* an integer greater than zero if the first item is greater than the second item
-
-See [`Array.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) on MDN.
-
-```res example
-// sort by word length
-let words = ["horse", "aardvark", "dog", "camel"]
-let byLength = (s1, s2) => Js.String.length(s1) - Js.String.length(s2)
-
-Js.Array.sortInPlaceWith(byLength, words) == ["dog", "horse", "camel", "aardvark"]
-
-// sort in reverse numeric order
-let numbers = [3, 30, 10, 1, 20, 2]
-let reverseNumeric = (n1, n2) => n2 - n1
-Js.Array.sortInPlaceWith(reverseNumeric, numbers) == [30, 20, 10, 3, 2, 1]
-```
-
-## spliceInPlace
-
-```res sig
-let spliceInPlace: (~pos: int, ~remove: int, ~add: array<'a>, t<'a>) => t<'a>
-```
-
-Starting at position `~pos`, remove `~remove` elements and then add the elements from the `~add` array. Returns an array consisting of the removed items. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```res example
-let arr = ["a", "b", "c", "d", "e", "f"]
-Js.Array.spliceInPlace(~pos=2, ~remove=2, ~add=["x", "y", "z"], arr) == ["c", "d"]
-arr == ["a", "b", "x", "y", "z", "e", "f"]
-
-let arr2 = ["a", "b", "c", "d"]
-Js.Array.spliceInPlace(~pos=3, ~remove=0, ~add=["x", "y"], arr2) == []
-arr2 == ["a", "b", "c", "x", "y", "d"]
-
-let arr3 = ["a", "b", "c", "d", "e", "f"]
-Js.Array.spliceInPlace(~pos=9, ~remove=2, ~add=["x", "y", "z"], arr3) == []
-arr3 == ["a", "b", "c", "d", "e", "f", "x", "y", "z"]
-```
-
-## removeFromInPlace
-
-```res sig
-let removeFromInPlace: (~pos: int, t<'a>) => t<'a>
-```
-
-Removes elements from the given array starting at position `~pos` to the end of the array, returning the removed elements. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```res example
-let arr = ["a", "b", "c", "d", "e", "f"]
-Js.Array.removeFromInPlace(~pos=4, arr) == ["e", "f"]
-arr == ["a", "b", "c", "d"]
-```
-
-## removeCountInPlace
-
-```res sig
-let removeCountInPlace: (~pos: int, ~count: int, t<'a>) => t<'a>
-```
-
-Removes `~count` elements from the given array starting at position `~pos`, returning the removed elements. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```res example
-let arr = ["a", "b", "c", "d", "e", "f"]
-Js.Array.removeCountInPlace(~pos=2, ~count=3, arr) == ["c", "d", "e"]
-arr == ["a", "b", "f"]
-```
-
-## unshift
-
-```res sig
-let unshift: ('a, t<'a>) => int
-```
-
-Adds the given element to the array, returning the new number of elements in the array. *This function modifies the original array.* See [`Array.unshift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) on MDN.
-
-```res example
-let arr = ["b", "c", "d"]
-Js.Array.unshift("a", arr) == 4
-arr == ["a", "b", "c", "d"]
-```
-
-## unshiftMany
-
-```res sig
-let unshiftMany: (array<'a>, t<'a>) => int
-```
-
-Adds the elements in the first array argument at the beginning of the second array argument, returning the new number of elements in the array. *This function modifies the original array.* See [`Array.unshift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) on MDN.
-
-```res example
-let arr = ["d", "e"]
-Js.Array.unshiftMany(["a", "b", "c"], arr) == 5
-arr == ["a", "b", "c", "d", "e"]
-```
-
-## append
-
-```res sig
-let append: ('a, t<'a>) => t<'a>
-```
-
-Deprecated. `append()` is not type-safe. Use `concat()` instead.
-
-## concat
-
-```res sig
-let concat: (t<'a>, t<'a>) => t<'a>
-```
-
-Concatenates the first array argument to the second array argument, returning a new array. The original arrays are not modified. See [`Array.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat) on MDN.
-
-```res example
-Js.Array.concat(["c", "d", "e"], ["a", "b"]) == ["a", "b", "c", "d", "e"]
-```
-
-## concatMany
-
-```res sig
-let concatMany: (array<t<'a>>, t<'a>) => t<'a>
-```
-
-The first argument to `concatMany()` is an array of arrays; these are added at the end of the second argument, returning a new array. See [`Array.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat) on MDN.
-
-```res example
-Js.Array.concatMany([["d", "e"], ["f", "g", "h"]], ["a", "b", "c"]) == [
-    "a",
-    "b",
-    "c",
-    "d",
-    "e",
-    "f",
-    "g",
-    "h",
-  ]
-```
-
-## includes
-
-```res sig
-let includes: ('a, t<'a>) => bool
-```
-
-Returns true if the given value is in the array, `false` otherwise. See [`Array.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes) on MDN.
-
-```res example
-Js.Array.includes("b", ["a", "b", "c"]) == true
-Js.Array.includes("x", ["a", "b", "c"]) == false
-```
-
-## indexOf
-
-```res sig
-let indexOf: ('a, t<'a>) => int
-```
-Returns the index of the first element in the array that has the given value. If the value is not in the array, returns -1. See [`Array.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf) on MDN.
-
-```res example
-Js.Array.indexOf(102, [100, 101, 102, 103]) == 2
-Js.Array.indexOf(999, [100, 101, 102, 103]) == -1
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: ('a, ~from: int, t<'a>) => int
-```
-
-Returns the index of the first element in the array with the given value. The search starts
-at position `~from`. See [`Array.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf) on MDN.
-
-```res example
-Js.Array.indexOfFrom("a", ~from=2, ["a", "b", "a", "c", "a"]) == 2
-Js.Array.indexOfFrom("a", ~from=3, ["a", "b", "a", "c", "a"]) == 4
-Js.Array.indexOfFrom("b", ~from=2, ["a", "b", "a", "c", "a"]) == -1
-```
-
-## join
-
-```res sig
-let join: t<'a> => string
-```
-Deprecated. Use `joinWith` instead.
-
-## joinWith
-
-```res sig
-let joinWith: (string, t<'a>) => string
-```
-This function converts each element of the array to a string (via JavaScript) and concatenates them, separated by the string given in the first argument, into a single string. See [`Array.join`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join) on MDN.
-
-```res example
-Js.Array.joinWith("--", ["ant", "bee", "cat"]) == "ant--bee--cat"
-Js.Array.joinWith("", ["door", "bell"]) == "doorbell"
-Js.Array.joinWith("/", [2020, 9, 4]) == "2020/9/4"
-Js.Array.joinWith(";", [2.5, 3.6, 3e-2]) == "2.5;3.6;0.03"
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: ('a, t<'a>) => int
-```
-
-Returns the index of the last element in the array that has the given value. If the value is not in the array, returns -1. See [`Array.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) on MDN.
-
-```res example
-Js.Array.lastIndexOf("a", ["a", "b", "a", "c"]) == 2
-Js.Array.lastIndexOf("x", ["a", "b", "a", "c"]) == -1
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: ('a, ~from: int, t<'a>) => int
-```
-
-Returns the index of the last element in the array that has the given value, searching from position `~from` down to the start of the array. If the value is not in the array, returns -1. See [`Array.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) on MDN.
-
-```res example
-Js.Array.lastIndexOfFrom("a", ~from=3, ["a", "b", "a", "c", "a", "d"]) == 2
-Js.Array.lastIndexOfFrom("c", ~from=2, ["a", "b", "a", "c", "a", "d"]) == -1
-```
-
-## lastIndexOf_start
-
-```res sig
-let lastIndexOf_start: ('a, t<'a>) => int
-```
-
-Deprecated. Please use `lastIndexOf`.
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t<'a>) => t<'a>
-```
-
-Returns a shallow copy of the given array from the `~start` index up to but not including the `~end_` position. Negative numbers indicate an offset from the end of the array. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104, 105, 106]
-Js.Array.slice(~start=2, ~end_=5, arr) == [102, 103, 104]
-Js.Array.slice(~start=-3, ~end_=-1, arr) == [104, 105]
-Js.Array.slice(~start=9, ~end_=10, arr) == []
-```
-
-## copy
-
-```res sig
-let copy: t<'a> => t<'a>
-```
-
-Returns a copy of the entire array. Same as `Js.Array.Slice(~start=0, ~end_=Js.Array.length(arr), arr)`. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-
-## slice_copy
-
-```res sig
-let slice_copy: (unit, t<'a>) => t<'a>
-```
-
-Deprecated. Please use `copy`.
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t<'a>) => t<'a>
-```
-
-Returns a shallow copy of the given array from the given index to the end. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-
-```res example
-Js.Array.sliceFrom(2, [100, 101, 102, 103, 104]) == [102, 103, 104]
-```
-
-## slice_start
-
-```res sig
-let slice_start: (int, t<'a>) => t<'a>
-```
-
-Deprecated. Please `sliceFrom`.
-
-## toString
-
-```res sig
-let toString: t<'a> => string
-```
-
-Converts the array to a string. Each element is converted to a string using JavaScript. Unlike the JavaScript `Array.toString()`, all elements in a ReasonML array must have the same type. See [`Array.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString) on MDN.
-
-```res example
-Js.Array.toString([3.5, 4.6, 7.8]) == "3.5,4.6,7.8"
-Js.Array.toString(["a", "b", "c"]) == "a,b,c"
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t<'a> => string
-```
-
-Converts the array to a string using the conventions of the current locale. Each element is converted to a string using JavaScript. Unlike the JavaScript `Array.toLocaleString()`, all elements in a ReasonML array must have the same type. See [`Array.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toLocaleString) on MDN.
-
-```res example
-Js.Array.toLocaleString([Js.Date.make()])
-// returns "3/19/2020, 10:52:11 AM" for locale en_US.utf8
-// returns "2020-3-19 10:52:11" for locale de_DE.utf8
-```
-
-## every
-
-```res sig
-let every: ('a => bool, t<'a>) => bool
-```
-
-The first argument to `every()` is a predicate function that returns a boolean. The `every()` function returns `true` if the predicate function is true for all items in the given array. If given an empty array, returns `true`. See [`Array.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) on MDN.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-Js.Array.every(isEven, [6, 22, 8, 4]) == true
-Js.Array.every(isEven, [6, 22, 7, 4]) == false
-```
-
-## everyi
-
-```res sig
-let everyi: (('a, int) => bool, t<'a>) => bool
-```
-
-The first argument to `everyi()` is a predicate function with two arguments: an array element and that element’s index; it returns a boolean. The `everyi()` function returns `true` if the predicate function is true for all items in the given array. If given an empty array, returns `true`. See [`Array.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) on MDN.
-
-```res example
-// determine if all even-index items are positive
-let evenIndexPositive = (item, index) => mod(index, 2) == 0 ? item > 0 : true
-
-Js.Array.everyi(evenIndexPositive, [6, -3, 5, 8]) == true
-Js.Array.everyi(evenIndexPositive, [6, 3, -5, 8]) == false
-```
-
-## filter
-
-```res sig
-let filter: ('a => bool, t<'a>) => t<'a>
-```
-
-Applies the given predicate function to each element in the array; the result is an array of those elements for which the predicate function returned `true`. See [`Array.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) on MDN.
-
-```res example
-let nonEmpty = s => s != ""
-Js.Array.filter(nonEmpty, ["abc", "", "", "def", "ghi"]) == ["abc", "def", "ghi"]
-```
-
-
-## filteri
-
-```res sig
-let filteri: (('a, int) => bool, t<'a>) => t<'a>
-```
-
-Each element of the given array are passed to the predicate function. The return value is an array of all those elements for which the predicate function returned `true`.  See [`Array.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) on MDN.
-
-```res example
-// keep only positive elements at odd indices
-let positiveOddElement = (item, index) => mod(index, 2) == 1 && item > 0
-
-Js.Array.filteri(positiveOddElement, [6, 3, 5, 8, 7, -4, 1]) == [3, 8]
-```
-
-## find
-
-```res sig
-let find: ('a => bool, t<'a>) => option<'a>
-```
-
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```res example
-// find first negative element
-Js.Array.find(x => x < 0, [33, 22, -55, 77, -44]) == Some(-55)
-Js.Array.find(x => x < 0, [33, 22, 55, 77, 44]) == None
-```
-
-## findi
-
-```res sig
-let findi: (('a, int) => bool, t<'a>) => option<'a>
-```
-
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. The predicate function takes an array element and an index as its parameters. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```res example
-// find first positive item at an odd index
-let positiveOddElement = (item, index) => mod(index, 2) == 1 && item > 0
-
-Js.Array.findi(positiveOddElement, [66, -33, 55, 88, 22]) == Some(88)
-Js.Array.findi(positiveOddElement, [66, -33, 55, -88, 22]) == None
-```
-
-## findIndex
-
-```res sig
-let findIndex: ('a => bool, t<'a>) => int
-```
-
-Returns the index of the first element in the array that satisifies the given predicate function, or -1 if no element satisifies the predicate. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```res example
-Js.Array.findIndex(x => x < 0, [33, 22, -55, 77, -44]) == 2
-Js.Array.findIndex(x => x < 0, [33, 22, 55, 77, 44]) == -1
-```
-## findIndexi
-
-```res sig
-let findIndexi: (('a, int) => bool, t<'a>) => int
-```
-
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. The predicate function takes an array element and an index as its parameters. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```res example
-// find index of first positive item at an odd index
-let positiveOddElement = (item, index) => mod(index, 2) == 1 && item > 0
-
-Js.Array.findIndexi(positiveOddElement, [66, -33, 55, 88, 22]) == 3
-Js.Array.findIndexi(positiveOddElement, [66, -33, 55, -88, 22]) == -1
-```
-
-## forEach
-
-```res sig
-let forEach: ('a => unit, t<'a>) => unit
-```
-
-The `forEach()` function applies the function given as the first argument to each element in the array. The function you provide returns `unit`, and the `forEach()` function also returns `unit`. You use `forEach()` when you need to process each element in the array but not return any new array or value; for example, to print the items in an array. See [`Array.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) on MDN.
-
-```res example
-// display all elements in an array
-Js.Array.forEach(x => Js.log(x), ["a", "b", "c"]) == ()
-```
-
-## forEachi
-
-```res sig
-let forEachi: (('a, int) => unit, t<'a>) => unit
-```
-
-The `forEachi()` function applies the function given as the first argument to each element in the array. The function you provide takes an item in the array and its index number, and returns `unit`. The `forEachi()` function also returns `unit`. You use `forEachi()` when you need to process each element in the array but not return any new array or value; for example, to print the items in an array. See [`Array.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) on MDN.
-
-```res example
-// display all elements in an array as a numbered list
-Js.Array.forEachi((item, index) => Js.log2(index + 1, item), ["a", "b", "c"]) == ()
-```
-
-## map
-
-```res sig
-let map: ('a => 'b, t<'a>) => t<'b>
-```
-
-Applies the function (given as the first argument) to each item in the array, returning a new array. The result array does not have to have elements of the same type as the input array. See [`Array.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) on MDN.
-
-```res example
-Js.Array.map(x => x * x, [12, 4, 8]) == [144, 16, 64]
-Js.Array.map(Js.String.length, ["animal", "vegetable", "mineral"]) == [6, 9, 7]
-```
-
-## mapi
-
-```res sig
-let mapi: (('a, int) => 'b, t<'a>) => t<'b>
-```
-
-Applies the function (given as the first argument) to each item in the array, returning a new array. The function acceps two arguments: an item from the array and its index number. The result array does not have to have elements of the same type as the input array. See [`Array.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) on MDN.
-
-```res example
-// multiply each item in array by its position
-let product = (item, index) => item * index
-Js.Array.mapi(product, [10, 11, 12]) == [0, 11, 24]
-```
-
-## reduce
-
-```res sig
-let reduce: (('b, 'a) => 'b, 'b, t<'a>) => 'b
-```
-
-The `reduce()` function takes three parameters: a *reducer function*, a beginning accumulator value, and an array. The reducer function has two parameters: an accumulated value and an element of the array.
-
-`reduce()` first calls the reducer function with the beginning value and the first element in the array. The result becomes the new accumulator value, which is passed in to the reducer function along with the second element in the array. `reduce()` proceeds through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduce()`. See [`Array.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) on MDN.
-
-```res example
-let sumOfSquares = (accumulator, item) => accumulator + item * item
-
-Js.Array.reduce(sumOfSquares, 0, [10, 2, 4]) == 120
-Js.Array.reduce(\"*", 1, [10, 2, 4]) == 80
-Js.Array.reduce(
-  (acc, item) => acc + Js.String.length(item),
-  0,
-  ["animal", "vegetable", "mineral"],
-) == 22 // 6 + 9 + 7
-Js.Array.reduce((acc, item) => item /. acc, 1.0, [2.0, 4.0]) == 2.0 // 4.0 / (2.0 / 1.0)
-```
-
-## reducei
-
-```res sig
-let reducei: (('b, 'a, int) => 'b, 'b, t<'a>) => 'b
-```
-
-The `reducei()` function takes three parameters: a *reducer function*, a beginning accumulator value, and an array. The reducer function has three parameters: an accumulated value, an element of the array, and the index of that element.
-
-`reducei()` first calls the reducer function with the beginning value, the first element in the array, and zero (its index). The result becomes the new accumulator value, which is passed to the reducer function along with the second element in the array and one (its index). `reducei()` proceeds from left to right through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reducei()`. See [`Array.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) on MDN.
-
-```res example
-// find sum of even-index elements in array
-let sumOfEvens = (accumulator, item, index) =>
-  if mod(index, 2) == 0 {
-    accumulator + item
-  } else {
-    accumulator
-  }
-
-Js.Array.reducei(sumOfEvens, 0, [2, 5, 1, 4, 3]) == 6
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: (('b, 'a) => 'b, 'b, t<'a>) => 'b
-```
-
-The `reduceRight()` function takes three parameters: a *reducer function*, a beginning accumulator value, and an array. The reducer function has two parameters: an accumulated value and an element of the array.
-
-`reduceRight()` first calls the reducer function with the beginning value and the last element in the array. The result becomes the new accumulator value, which is passed in to the reducer function along with the next-to-last element in the array. `reduceRight()` proceeds from right to left through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduceRight()`.  See [`Array.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight) on MDN.
-
-**NOTE:** In many cases, `reduce()` and `reduceRight()` give the same result. However, see the last example here and compare it to the example from `reduce()`, where order makes a difference.
-
-```res example
-let sumOfSquares = (accumulator, item) => accumulator + item * item
-
-Js.Array.reduceRight(sumOfSquares, 0, [10, 2, 4]) == 120
-Js.Array.reduceRight((acc, item) => item /. acc, 1.0, [2.0, 4.0]) == 0.5 // 2.0 / (4.0 / 1.0)
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: (('b, 'a, int) => 'b, 'b, t<'a>) => 'b
-```
-
-The `reduceRighti()` function takes three parameters: a *reducer function*, a beginning accumulator value, and an array. The reducer function has three parameters: an accumulated value, an element of the array, and the index of that element. `reduceRighti()` first calls the reducer function with the beginning value, the last element in the array, and its index (length of array minus one). The result becomes the new accumulator value, which is passed in to the reducer function along with the second element in the array and one (its index). `reduceRighti()` proceeds from right to left through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduceRighti()`. See [`Array.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight) on MDN.
-
-**NOTE:** In many cases, `reducei()` and `reduceRighti()` give the same result. However, there are cases where the order in which items are processed makes a difference.
-
-```res example
-// find sum of even-index elements in array
-let sumOfEvens = (accumulator, item, index) =>
-  if mod(index, 2) == 0 {
-    accumulator + item
-  } else {
-    accumulator
-  }
-
-Js.Array.reduceRighti(sumOfEvens, 0, [2, 5, 1, 4, 3]) == 6
-```
-
-## some
-
-```res sig
-let some: ('a => bool, t<'a>) => bool
-```
-
-Returns `true` if the predicate function given as the first argument to `some()` returns `true` for any element in the array; `false` otherwise.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-Js.Array.some(isEven, [3, 7, 5, 2, 9]) == true
-Js.Array.some(isEven, [3, 7, 5, 1, 9]) == false
-```
-
-## somei
-
-```res sig
-let somei: (('a, int) => bool, t<'a>) => bool
-```
-
-Returns `true` if the predicate function given as the first argument to `somei()` returns `true` for any element in the array; `false` otherwise. The predicate function has two arguments: an item from the array and the index value
-
-```res example
-// Does any string in the array
-// have the same length as its index?
-
-let sameLength = (str, index) => Js.String.length(str) == index
-
-// "ef" has length 2 and is it at index 2
-Js.Array.somei(sameLength, ["ab", "cd", "ef", "gh"]) == true
-// no item has the same length as its index
-Js.Array.somei(sameLength, ["a", "bc", "def", "gh"]) == false
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (array<'a>, int) => 'a
-```
-Returns the value at the given position in the array if the position is in bounds; returns
-the JavaScript value `undefined` otherwise.
-
-```res example
-let arr = [100, 101, 102, 103]
-Js.Array.unsafe_get(arr, 3) == 103
-Js.Array.unsafe_get(arr, 4) // returns undefined
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (array<'a>, int, 'a) => unit
-```
-
-Sets the value at the given position in the array if the position is in bounds. If the index is out of bounds, well, “here there be dragons.“ *This function modifies the original array.*
-
-```res example
-let arr = [100, 101, 102, 103]
-Js.Array.unsafe_set(arr, 3, 99)
-// result is [100, 101, 102, 99]
-
-Js.Array.unsafe_set(arr, 4, 88)
-// result is [100, 101, 102, 99, 88]
-
-Js.Array.unsafe_set(arr, 6, 77)
-// result is [100, 101, 102, 99, 88, <1 empty item>, 77]
-
-Js.Array.unsafe_set(arr, -1, 66)
-// you don't want to know.
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/console.mdx b/pages/docs/manual/v10.0.0/api/js/console.mdx
deleted file mode 100644
index f02bd576b..000000000
--- a/pages/docs/manual/v10.0.0/api/js/console.mdx
+++ /dev/null
@@ -1,114 +0,0 @@
-# Console
-
-<Intro>
-
-Provide console (logging) utilities.
-
-</Intro>
-
-
-## log
-
-```res sig
-let log: 'a => unit
-```
-
-```res sig
-let log2: ('a, 'b) => unit
-```
-
-```res sig
-let log3: ('a, 'b, 'c) => unit
-```
-
-```res sig
-let log4: ('a, 'b, 'c, 'd) => unit
-```
-
-```res sig
-let logMany: array<'a> => unit
-```
-
-## info
-
-```res sig
-let info: 'a => unit
-```
-
-```res sig
-let info2: ('a, 'b) => unit
-```
-
-```res sig
-let info3: ('a, 'b, 'c) => unit
-```
-
-```res sig
-let info4: ('a, 'b, 'c, 'd) => unit
-```
-
-```res sig
-let infoMany: array<'a> => unit
-```
-
-## warn
-
-```res sig
-let warn: 'a => unit
-```
-
-```res sig
-let warn2: ('a, 'b) => unit
-```
-
-```res sig
-let warn3: ('a, 'b, 'c) => unit
-```
-
-```res sig
-let warn4: ('a, 'b, 'c, 'd) => unit
-```
-
-```res sig
-let warnMany: array<'a> => unit
-```
-
-## error
-
-```res sig
-let error: 'a => unit
-```
-
-```res sig
-let error2: ('a, 'b) => unit
-```
-
-```res sig
-let error3: ('a, 'b, 'c) => unit
-```
-
-```res sig
-let error4: ('a, 'b, 'c, 'd) => unit
-```
-
-```res sig
-let errorMany: array<'a> => unit
-```
-
-## trace
-
-```res sig
-let trace: unit => unit
-```
-
-## timeStart
-
-```res sig
-let timeStart: string => unit
-```
-
-## timeEnd
-
-```res sig
-let timeEnd: string => unit
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/date.mdx b/pages/docs/manual/v10.0.0/api/js/date.mdx
deleted file mode 100644
index 9212782d7..000000000
--- a/pages/docs/manual/v10.0.0/api/js/date.mdx
+++ /dev/null
@@ -1,1060 +0,0 @@
-# Date
-
-<Intro>
-
-Provide bindings to JS date. (See [`Date`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date) on MDN.) JavaScript stores dates as the number of milliseconds since
-the UNIX *epoch*, midnight 1 January 1970, UTC.
-</Intro>
-
-In these examples, we will be using this date:
-
-```res prelude
-let exampleDate = Js.Date.fromFloat(123456654321.0)
-```
-
-which is Thu, 29 Nov 1973 21:30:54 GMT. There is no particular significance to this date.
-The code used to access this date is running in the Europe/Austria time zone with the `en_US.utf8` locale.
-
-In all of these functions, month values are in the range 0-11, where January is month zero.
-
-
-## t
-
-```res prelude
-type t
-```
-
-## valueOf
-
-```res sig
-let valueOf: t => float
-```
-Returns the primitive value of this date, equivalent to `getTime()`. (See [`Date.valueOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/valueOf) on MDN.)
-
-```res example
-Js.Date.valueOf(exampleDate) == 123456654321.0
-```
-
-## make
-
-```res sig
-let make: unit => t
-```
-Returns a date representing the current time. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-```res example
-let now = Js.Date.make()
-```
-
-## fromFloat
-
-```res sig
-let fromFloat: float => t
-```
-
-Returns a date representing the given argument, which is a number of milliseconds since the epoch. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-```res example
-Js.Date.fromFloat(123456654321.0) == exampleDate
-```
-
-## fromString
-
-```res sig
-let fromString: string => t
-```
-
-Returns a `Js.Date.t` represented by the given string. The string can be in “IETF-compliant RFC 2822 timestamps, and also strings in a version of ISO8601.” Returns `NaN` if given an invalid date string. According to the [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) documentation on MDN, its use is discouraged.
-
-```res example
-Js.Date.fromString("Thu, 29 Nov 1973 21:30:54.321 GMT") == exampleDate
-Js.Date.fromString("1973-11-29T21:30:54.321Z00:00") == exampleDate
-Js.Date.fromString("Thor, 32 Lok -19 60:70:80 XYZ") // returns NaN
-```
-
-## makeWithYM
-
-```res sig
-let makeWithYM: (~year: float, ~month: float, unit) => t
-```
-Returns a date representing midnight of the first day of the given month and year in the current time zone. Fractional parts of arguments are ignored. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-```res example
-let november1 = Js.Date.makeWithYM(~year=2020.0, ~month=10.0, ())
-```
-
-## makeWithYMD
-
-```res sig
-let makeWithYMD: (~year: float, ~month: float, ~date: float, unit) => t
-```
-Returns a date representing midnight of the given date of the given month and year in the current time zone. Fractional parts of arguments are ignored. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-## makeWithYMDH
-
-```res sig
-let makeWithYMDH: (~year: float, ~month: float, ~date: float, ~hours: float, unit) => t
-```
-Returns a date representing the given date of the given month and year, at zero minutes and zero seconds past the given `hours`, in the current time zone. Fractional parts of arguments are ignored. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN. Fractional parts of the arguments are ignored.
-
-## makeWithYMDHM
-
-```res sig
-let makeWithYMDHM: (
-  ~year: float,
-  ~month: float,
-  ~date: float,
-  ~hours: float,
-  ~minutes: float,
-  unit,
-) => t
-```
-Returns a date representing the given date of the given month and year, at zero seconds past the given time in hours and minutes in the current time zone.  Fractional parts of arguments are ignored. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-## makeWithYMDHMS
-
-```res sig
-let makeWithYMDHMS: (
-  ~year: float,
-  ~month: float,
-  ~date: float,
-  ~hours: float,
-  ~minutes: float,
-  ~seconds: float,
-  unit,
-) => t
-```
-Returns a date representing the given date of the given month and year, at the given time in hours, minutes, and seconds in the current time zone. Fractional parts of arguments are ignored. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-```res example
-Js.Date.makeWithYMDHMS(
-  ~year=1973.0,
-  ~month=11.0,
-  ~date=29.0,
-  ~hours=21.0,
-  ~minutes=30.0,
-  ~seconds=54.321,
-  (),
-) == exampleDate
-```
-
-## utcWithYM
-
-```res sig
-let utcWithYM: (~year: float, ~month: float, unit) => float
-```
-Returns a float representing the number of milliseconds past the epoch for midnight of the first day of the given month and year in UTC. Fractional parts of arguments are ignored. See [`Date.UTC`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC) on MDN.
-
-```res example
-let november1 = Js.Date.utcWithYM(~year=2020.0, ~month=10.0, ())
-```
-
-## utcWithYMD
-
-```res sig
-let utcWithYMD: (~year: float, ~month: float, ~date: float, unit) => float
-```
-Returns a float representing the number of milliseconds past the epoch for midnight of the given date of the given month and year in UTC. Fractional parts of arguments are ignored. See [`Date.UTC`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC) on MDN.
-
-## utcWithYMDH
-
-```res sig
-let utcWithYMDH: (~year: float, ~month: float, ~date: float, ~hours: float, unit) => float
-```
-Returns a float representing the number of milliseconds past the epoch for midnight of the given date of the given month and year, at zero minutes and seconds past the given hours in UTC. Fractional parts of arguments are ignored. See [`Date.UTC`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC) on MDN.
-
-## utcWithYMDHM
-
-```res sig
-let utcWithYMDHM: (
-  ~year: float,
-  ~month: float,
-  ~date: float,
-  ~hours: float,
-  ~minutes: float,
-  unit,
-) => float
-```
-Returns a float representing the number of milliseconds past the epoch for midnight of the given date of the given month and year, at zero seconds past the given number of minutes past the given hours in UTC. Fractional parts of arguments are ignored. See [`Date.UTC`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC) on MDN.
-
-## utcWithYMDHMS
-
-```res sig
-let utcWithYMDHMS: (
-  ~year: float,
-  ~month: float,
-  ~date: float,
-  ~hours: float,
-  ~minutes: float,
-  ~seconds: float,
-  unit,
-) => float
-```
-Returns a float representing the number of milliseconds past the epoch for midnight of the given date of the given month and year, at the given time in hours, minutes and seconds in UTC. Fractional parts of arguments are ignored. See [`Date.UTC`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC) on MDN.
-
-## now
-
-```res sig
-let now: unit => float
-```
-Returns the current time as number of milliseconds since Unix epoch.
-
-## parse
-
-```res sig
-let parse: string => t
-```
-Deprecated. Use [`fromString()`](#fromstring).
-
-## parseAsFloat
-
-```res sig
-let parseAsFloat: string => float
-```
-Returns a float with the number of milliseconds past the epoch represented by the given string. The string can be in “IETF-compliant RFC 2822 timestamps, and also strings in a version of ISO8601.” Returns `NaN` if given an invalid date string. According to the [`Date.parse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/parse) documentation on MDN, its use is discouraged. Returns `NaN` if passed invalid date string.
-
-## getDate
-
-```res sig
-let getDate: t => float
-```
-Returns the day of the month for its argument. The argument is evaluated in the current time zone. See [`Date.getDate`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getDate) on MDN.
-
-```res example
-Js.Date.getDate(exampleDate) == 29.0
-```
-
-## getDay
-
-```res sig
-let getDay: t => float
-```
-Returns the day of the week (0.0-6.0) for its argument, where 0.0 represents Sunday. The argument is evaluated in the current time zone.  See [`Date.getDay`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getDay) on MDN.
-
-```res example
-Js.Date.getDay(exampleDate) == 4.0
-```
-
-## getFullYear
-
-```res sig
-let getFullYear: t => float
-```
-Returns the full year (as opposed to the range 0-99) for its argument. The argument is evaluated in the current time zone. See [`Date.getFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getFullYear) on MDN.
-
-```res example
-Js.Date.getFullYear(exampleDate) == 1973.0
-```
-
-## getHours
-
-```res sig
-let getHours: t => float
-```
-Returns the hours for its argument, evaluated in the current time zone. See [`Date.getHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getHours) on MDN.
-
-```res example
-Js.Date.getHours(exampleDate) == 22.0 // Vienna is in GMT+01:00
-```
-
-## getMilliseconds
-
-```res sig
-let getMilliseconds: t => float
-```
-Returns the number of milliseconds for its argument, evaluated in the current time zone. See [`Date.getMilliseconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds) on MDN.
-
-```res example
-Js.Date.getMilliseconds(exampleDate) == 321.0
-```
-
-## getMinutes
-
-```res sig
-let getMinutes: t => float
-```
-Returns the number of minutes for its argument, evaluated in the current time zone. See [`Date.getMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMinutes) on MDN.
-
-```res example
-Js.Date.getMinutes(exampleDate) == 30.0
-```
-
-## getMonth
-
-```res sig
-let getMonth: t => float
-```
-Returns the month (0.0-11.0) for its argument, evaluated in the current time zone. January is month zero.  See [`Date.getMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMonth) on MDN.
-
-```res example
-Js.Date.getMonth(exampleDate) == 10.0
-```
-
-## getSeconds
-
-```res sig
-let getSeconds: t => float
-```
-Returns the seconds for its argument, evaluated in the current time zone. See [`Date.getSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getSeconds) on MDN.
-
-```res example
-Js.Date.getSeconds(exampleDate) == 54.0
-```
-
-## getTime
-
-```res sig
-let getTime: t => float
-```
-Returns the number of milliseconds since Unix epoch, evaluated in UTC.  See [`Date.getTime`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTime) on MDN.
-
-```res example
-Js.Date.getTime(exampleDate) == 123456654321.0
-```
-
-## getTimezoneOffset
-
-```res sig
-let getTimezoneOffset: t => float
-```
-
-Returns the time zone offset in minutes from the current time zone to UTC. See [`Date.getTimezoneOffset`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset) on MDN.
-
-```res example
-Js.Date.getTimezoneOffset(exampleDate) == -60.0
-```
-
-## getUTCDate
-
-```res sig
-let getUTCDate: t => float
-```
-Returns the day of the month of the argument, evaluated in UTC. See [`Date.getUTCDate`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCDate) on MDN.
-
-```res example
-Js.Date.getUTCDate(exampleDate) == 29.0
-```
-
-## getUTCDay
-
-```res sig
-let getUTCDay: t => float
-```
-Returns the day of the week of the argument, evaluated in UTC. The range of the return value is 0.0-6.0, where Sunday is zero. See [`Date.getUTCDay`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCDay) on MDN.
-
-```res example
-Js.Date.getUTCDay(exampleDate) == 4.0
-```
-
-## getUTCFullYear
-
-```res sig
-let getUTCFullYear: t => float
-```
-Returns the full year (as opposed to the range 0-99) for its argument. The argument is evaluated in UTC.  See [`Date.getUTCFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear) on MDN.
-
-```res example
-Js.Date.getUTCFullYear(exampleDate) == 1973.0
-```
-
-## getUTCHours
-
-```res sig
-let getUTCHours: t => float
-```
-Returns the hours for its argument, evaluated in the current time zone. See [`Date.getUTCHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCHours) on MDN.
-
-```res example
-Js.Date.getUTCHours(exampleDate) == 21.0
-```
-
-## getUTCMilliseconds
-
-```res sig
-let getUTCMilliseconds: t => float
-```
-Returns the number of milliseconds for its argument, evaluated in UTC. See [`Date.getUTCMilliseconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds) on MDN.
-
-```res example
-Js.Date.getUTCMilliseconds(exampleDate) == 321.0
-```
-
-## getUTCMinutes
-
-```res sig
-let getUTCMinutes: t => float
-```
-Returns the number of minutes for its argument, evaluated in UTC. See [`Date.getUTCMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes) on MDN.
-
-```res example
-Js.Date.getUTCMinutes(exampleDate) == 30.0
-```
-
-## getUTCMonth
-
-```res sig
-let getUTCMonth: t => float
-```
-Returns the month (0.0-11.0) for its argument, evaluated in UTC. January is month zero. See [`Date.getUTCMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth) on MDN.
-
-```res example
-Js.Date.getUTCMonth(exampleDate) == 10.0
-```
-
-## getUTCSeconds
-
-```res sig
-let getUTCSeconds: t => float
-```
-Returns the seconds for its argument, evaluated in UTC. See [`Date.getUTCSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds) on MDN.
-
-```res example
-Js.Date.getUTCSeconds(exampleDate) == 54.0
-```
-
-## getYear
-
-```res sig
-let getYear: t => float
-```
-Deprecated. Use `getFullYear()` instead.
-
-## setDate
-
-```res sig
-let setDate: (t, float) => float
-```
-Sets the given `Date`’s day of month to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setDate`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setDate) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let twoWeeksBefore = Js.Date.setDate(date1, 15.0)
-date1 == Js.Date.fromString("1973-11-15T21:30:54.321Z00:00")
-twoWeeksBefore == Js.Date.getTime(date1)
-```
-
-## setFullYear
-
-```res sig
-let setFullYear: (t, float) => float
-```
-Sets the given `Date`’s year to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setFullYear) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let nextYear = Js.Date.setFullYear(date1, 1974.0)
-date1 == Js.Date.fromString("1974-11-15T21:30:54.321Z00:00")
-nextYear == Js.Date.getTime(date1)
-```
-
-## setFullYearM
-
-```res sig
-let setFullYearM: (t, ~year: float, ~month: float, unit) => float
-```
-
-Sets the given `Date`’s year and month to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setFullYear) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let future = Js.Date.setFullYearM(date1, ~year=1974.0, ~month=0.0, ())
-date1 == Js.Date.fromString("1974-01-22T21:30:54.321Z00:00")
-future == Js.Date.getTime(date1)
-```
-
-## setFullYearMD
-
-```res sig
-let setFullYearMD: (t, ~year: float, ~month: float, ~date: float, unit) => float
-```
-Sets the given `Date`’s year, month, and day of month to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setFullYear) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let future = Js.Date.setFullYearMD(date1, ~year=1974.0, ~month=0.0, ~date=7.0, ())
-date1 == Js.Date.fromString("1974-01-07T21:30:54.321Z00:00")
-future == Js.Date.getTime(date1)
-```
-
-## setHours
-
-```res sig
-let setHours: (t, float) => float
-```
-Sets the given `Date`’s hours to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setHours) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let nextHour = Js.Date.setHours(date1, 22.0)
-date1 == Js.Date.fromString("1973-11-29T22:30:54.321Z00:00")
-nextHour == Js.Date.getTime(date1)
-```
-
-## setHoursM
-
-```res sig
-let setHoursM: (t, ~hours: float, ~minutes: float, unit) => float
-```
-Sets the given `Date`’s hours and minutes to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setHours) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setHoursM(date1, ~hours=22.0, ~minutes=46.0, ())
-date1 == Js.Date.fromString("1973-11-29T22:46:54.321Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setHoursMS
-
-```res sig
-let setHoursMS: (t, ~hours: float, ~minutes: float, ~seconds: float, unit) => float
-```
-Sets the given `Date`’s hours, minutes, and seconds to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setHours) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setHoursMS(date1, ~hours=22.0, ~minutes=46.0, ~seconds=37.0, ())
-date1 == Js.Date.fromString("1973-11-29T22:46:37.321Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setHoursMSMs
-
-```res sig
-let setHoursMSMs: (
-  t,
-  ~hours: float,
-  ~minutes: float,
-  ~seconds: float,
-  ~milliseconds: float,
-  unit,
-) => float
-```
-Sets the given `Date`’s hours, minutes, seconds, and milliseconds to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setHours) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setHoursMSMs(
-  date1,
-  ~hours=22.0,
-  ~minutes=46.0,
-  ~seconds=37.0,
-  ~milliseconds=494.0,
-  (),
-)
-date1 == Js.Date.fromString("1973-11-29T22:46:37.494Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setMilliseconds
-
-```res sig
-let setMilliseconds: (t, float) => float
-```
-Sets the given `Date`’s milliseconds to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMilliseconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMilliseconds(date1, 494.0)
-date1 == Js.Date.fromString("1973-11-29T21:30:54.494Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setMinutes
-
-```res sig
-let setMinutes: (t, float) => float
-```
-Sets the given `Date`’s minutes to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMinutes) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMinutes(date1, 34.0)
-date1 == Js.Date.fromString("1973-11-29T21:34:54.494Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setMinutesS
-
-```res sig
-let setMinutesS: (t, ~minutes: float, ~seconds: float, unit) => float
-```
-Sets the given `Date`’s minutes and seconds to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMinutes) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMinutesS(date1, ~minutes=34.0, ~seconds=56.0, ())
-date1 == Js.Date.fromString("1973-11-29T21:34:56.494Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setMinutesSMs
-
-```res sig
-let setMinutesSMs: (t, ~minutes: float, ~seconds: float, ~milliseconds: float, unit) => float
-```
-Sets the given `Date`’s minutes, seconds, and milliseconds to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMinutes) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMinutesSMs(
-  date1,
-  ~minutes=34.0,
-  ~seconds=56.0,
-  ~milliseconds=789.0,
-  (),
-)
-date1 == Js.Date.fromString("1973-11-29T21:34:56.789Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setMonth
-
-```res sig
-let setMonth: (t, float) => float
-```
-Sets the given `Date`’s month to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMonth) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMonth(date1, 11.0)
-date1 == Js.Date.fromString("1973-12-29T21:34:56.789Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setMonthD
-
-```res sig
-let setMonthD: (t, ~month: float, ~date: float, unit) => float
-```
-Sets the given `Date`’s month and day of month to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMonth) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMonthD(date1, ~month=11.0, ~date=8.0, ())
-date1 == Js.Date.fromString("1973-12-08T21:34:56.789Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setSeconds
-
-```res sig
-let setSeconds: (t, float) => float
-```
-Sets the given `Date`’s seconds to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setSeconds) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setSeconds(date1, 56.0)
-date1 == Js.Date.fromString("1973-12-29T21:30:56.321Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setSecondsMs
-
-```res sig
-let setSecondsMs: (t, ~seconds: float, ~milliseconds: float, unit) => float
-```
-Sets the given `Date`’s seconds and milliseconds to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setSeconds) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setSecondsMs(date1, ~seconds=56.0, ~milliseconds=789.0, ())
-date1 == Js.Date.fromString("1973-12-29T21:30:56.789Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setTime
-
-```res sig
-let setTime: (t, float) => float
-```
-Sets the given `Date`’s value in terms of milliseconds since the epoch. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setTime`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setTime) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setTime(date1, 198765432101.0)
-
-date1 == Js.Date.fromString("1976-04-19T12:37:12.101Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCDate
-
-```res sig
-let setUTCDate: (t, float) => float
-```
-Sets the given `Date`’s day of month to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCDate`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCDate) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let twoWeeksBefore = Js.Date.setUTCDate(date1, 15.0)
-date1 == Js.Date.fromString("1973-11-15T21:30:54.321Z00:00")
-twoWeeksBefore == Js.Date.getTime(date1)
-```
-
-## setUTCFullYear
-
-```res sig
-let setUTCFullYear: (t, float) => float
-```
-Sets the given `Date`’s year to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let nextYear = Js.Date.setUTCFullYear(date1, 1974.0)
-date1 == Js.Date.fromString("1974-11-15T21:30:54.321Z00:00")
-nextYear == Js.Date.getTime(date1)
-```
-
-## setUTCFullYearM
-
-```res sig
-let setUTCFullYearM: (t, ~year: float, ~month: float, unit) => float
-```
-Sets the given `Date`’s year and month to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let future = Js.Date.setUTCFullYearM(date1, ~year=1974.0, ~month=0.0, ())
-date1 == Js.Date.fromString("1974-01-22T21:30:54.321Z00:00")
-future == Js.Date.getTime(date1)
-```
-
-## setUTCFullYearMD
-
-```res sig
-let setUTCFullYearMD: (t, ~year: float, ~month: float, ~date: float, unit) => float
-```
-Sets the given `Date`’s year, month, and day of month to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let future = Js.Date.setUTCFullYearMD(date1, ~year=1974.0, ~month=0.0, ~date=7.0, ())
-date1 == Js.Date.fromString("1974-01-07T21:30:54.321Z00:00")
-future == Js.Date.getTime(date1)
-```
-
-## setUTCHours
-
-```res sig
-let setUTCHours: (t, float) => float
-```
-Sets the given `Date`’s hours to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCHours) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let nextHour = Js.Date.setUTCHours(date1, 22.0)
-date1 == Js.Date.fromString("1973-11-29T22:30:54.321Z00:00")
-nextHour == Js.Date.getTime(date1)
-```
-
-## setUTCHoursM
-
-```res sig
-let setUTCHoursM: (t, ~hours: float, ~minutes: float, unit) => float
-```
-Sets the given `Date`’s hours and minutes to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCHours) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCHoursM(date1, ~hours=22.0, ~minutes=46.0, ())
-date1 == Js.Date.fromString("1973-11-29T22:46:54.321Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCHoursMS
-
-```res sig
-let setUTCHoursMS: (t, ~hours: float, ~minutes: float, ~seconds: float, unit) => float
-```
-Sets the given `Date`’s hours, minutes, and seconds to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCHours) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCHoursMS(date1, ~hours=22.0, ~minutes=46.0, ~seconds=37.0, ())
-date1 == Js.Date.fromString("1973-11-29T22:46:37.321Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCHoursMSMs
-
-```res sig
-let setUTCHoursMSMs: (
-  t,
-  ~hours: float,
-  ~minutes: float,
-  ~seconds: float,
-  ~milliseconds: float,
-  unit,
-) => float
-```
-Sets the given `Date`’s hours, minutes, seconds, and milliseconds to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCHours) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCHoursMSMs(
-  date1,
-  ~hours=22.0,
-  ~minutes=46.0,
-  ~seconds=37.0,
-  ~milliseconds=494.0,
-  (),
-)
-date1 == Js.Date.fromString("1973-11-29T22:46:37.494Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCMilliseconds
-
-```res sig
-let setUTCMilliseconds: (t, float) => float
-```
-Sets the given `Date`’s milliseconds to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMilliseconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMilliseconds(date1, 494.0)
-date1 == Js.Date.fromString("1973-11-29T21:30:54.494Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCMinutes
-
-```res sig
-let setUTCMinutes: (t, float) => float
-```
-Sets the given `Date`’s minutes to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMinutes(date1, 34.0)
-date1 == Js.Date.fromString("1973-11-29T21:34:54.494Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCMinutesS
-
-```res sig
-let setUTCMinutesS: (t, ~minutes: float, ~seconds: float, unit) => float
-```
-Sets the given `Date`’s minutes and seconds to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMinutesS(date1, ~minutes=34.0, ~seconds=56.0, ())
-date1 == Js.Date.fromString("1973-11-29T21:34:56.494Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCMinutesSMs
-
-```res sig
-let setUTCMinutesSMs: (t, ~minutes: float, ~seconds: float, ~milliseconds: float, unit) => float
-```
-Sets the given `Date`’s minutes, seconds, and milliseconds to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMinutesSMs(
-  date1,
-  ~minutes=34.0,
-  ~seconds=56.0,
-  ~milliseconds=789.0,
-  (),
-)
-date1 == Js.Date.fromString("1973-11-29T21:34:56.789Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCMonth
-
-```res sig
-let setUTCMonth: (t, float) => float
-```
-Sets the given `Date`’s month to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMonth(date1, 11.0)
-date1 == Js.Date.fromString("1973-12-29T21:34:56.789Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCMonthD
-
-```res sig
-let setUTCMonthD: (t, ~month: float, ~date: float, unit) => float
-```
-Sets the given `Date`’s month and day of month to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMonthD(date1, ~month=11.0, ~date=8.0, ())
-date1 == Js.Date.fromString("1973-12-08T21:34:56.789Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCSeconds
-
-```res sig
-let setUTCSeconds: (t, float) => float
-```
-Sets the given `Date`’s seconds to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCSeconds(date1, 56.0)
-date1 == Js.Date.fromString("1973-12-29T21:30:56.321Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCSecondsMs
-
-```res sig
-let setUTCSecondsMs: (t, ~seconds: float, ~milliseconds: float, unit) => float
-```
-Sets the given `Date`’s seconds and milliseconds to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCSecondsMs(date1, ~seconds=56.0, ~milliseconds=789.0, ())
-date1 == Js.Date.fromString("1973-12-29T21:30:56.789Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCTime
-
-```res sig
-let setUTCTime: (t, float) => float
-```
-Same as [`setTime()`](#settime).
-
-## setYear
-
-```res sig
-let setYear: (t, float) => float
-```
-Deprecated. Use [`setFullYear()`](#setfullyear) instead.
-
-## toDateString
-
-```res sig
-let toDateString: t => string
-```
-Returns the date (day of week, year, month, and day of month) portion of a `Date` in English. See [`Date.toDateString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toDateString) on MDN.
-
-```res example
-Js.Date.toDateString(exampleDate) == "Thu Nov 29 1973"
-```
-
-## toGMTString
-
-```res sig
-let toGMTString: t => string
-```
-Deprecated. Use [`toUTCString()`](#toutcstring) instead.
-
-## toISOString
-
-```res sig
-let toISOString: t => string
-```
-Returns a simplified version of the ISO 8601 format for the date. See [`Date.toISOString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) on MDN.
-
-```res example
-Js.Date.toISOString(exampleDate) == "1973-11-29T21:30:54.321Z"
-```
-
-## toJSON
-
-```res sig
-let toJSON: t => string
-```
-Deprecated. This method is unsafe. It will be changed to return `option` in a future release. Please use `toJSONUnsafe()` instead.
-
-## toJSONUnsafe
-
-```res sig
-let toJSONUnsafe: t => string
-```
-Returns a string representation of the given date. See [`Date.toJSON`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toJSON) on MDN.
-
-```res example
-Js.Date.toJSONUnsafe(exampleDate) == "1973-11-29T21:30:54.321Z"
-```
-
-## toLocaleDateString
-
-```res sig
-let toLocaleDateString: t => string
-```
-
-Returns the year, month, and day for the given `Date` in the current locale format. See [`Date.toLocaleDateString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString) on MDN.
-
-```res example
-Js.Date.toLocaleDateString(exampleDate) == "11/29/1973" // for en_US.utf8
-Js.Date.toLocaleDateString(exampleDate) == "29.11.73" // for de_DE.utf8
-```
-
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-Returns the time and date for the given `Date` in the current locale format. See [`Date.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString) on MDN.
-
-```res example
-Js.Date.toLocaleString(exampleDate) == "11/29/1973, 10:30:54 PM" // for en_US.utf8
-Js.Date.toLocaleString(exampleDate) == "29.11.1973, 22:30:54" // for de_DE.utf8
-```
-
-## toLocaleTimeString
-
-```res sig
-let toLocaleTimeString: t => string
-```
-Returns the time of day for the given `Date` in the current locale format. See [`Date.toLocaleTimeString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString) on MDN.
-
-```res example
-Js.Date.toLocaleString(exampleDate) == "10:30:54 PM" // for en_US.utf8
-Js.Date.toLocaleString(exampleDate) == "22:30:54" // for de_DE.utf8
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-Returns a string representing the date and time of day for the given `Date` in the current locale and time zone. See [`Date.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toString) on MDN.
-
-```res example
-Js.Date.toString(
-  exampleDate,
-) == "Thu Nov 29 1973 22:30:54 GMT+0100 (Central European Standard Time)"
-```
-
-## toTimeString
-
-```res sig
-let toTimeString: t => string
-```
-
-Returns a string representing the time of day for the given `Date` in the current locale and time zone.  See [`Date.toTimeString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toTimeString) on MDN.
-
-```res example
-Js.Date.toTimeString(exampleDate) == "22:30:54 GMT+0100 (Central European Standard Time)"
-```
-
-## toUTCString
-
-```res sig
-let toUTCString: t => string
-```
-
-Returns a string representing the date and time of day for the given `Date` in the current locale and UTC (GMT time zone). See [`Date.toUTCString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toUTCString) on MDN.
-
-```res example
-Js.Date.toUTCString(exampleDate) == "Thu, 29 Nov 1973 21:30:54 GMT"
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/dict.mdx b/pages/docs/manual/v10.0.0/api/js/dict.mdx
deleted file mode 100644
index 881527a9e..000000000
--- a/pages/docs/manual/v10.0.0/api/js/dict.mdx
+++ /dev/null
@@ -1,164 +0,0 @@
-# Dict
-
-<Intro>
-
-Provide utilities for JS dictionary object.
-
-**Note:** This module's examples will assume this predeclared dictionary:
-
-```res prelude
-let ages = Js.Dict.fromList(list{("Maria", 30), ("Vinh", 22), ("Fred", 49)})
-```
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a>
-```
-
-Dictionary type (ie an '{ }' JS object). However it is restricted to hold a single type; therefore values must have the same type.
-This Dictionary type is mostly used with the Js_json.t type.
-
-## key
-
-```res prelude
-type key = string
-```
-
-The type for dictionary keys. This means that dictionaries *must* use `string`s as their keys.
-
-## get
-
-```res sig
-let get: (t<'a>, key) => option<'a>
-```
-
-`Js.Dict.get(key)` returns `None` if the key is not found in the dictionary, `Some(value)` otherwise.
-
-```res example
-Js.Dict.get(ages, "Vinh") == Some(22)
-Js.Dict.get(ages, "Paul") == None
-```
-
-## unsafeGet
-
-```res sig
-let unsafeGet: (t<'a>, key) => 'a
-```
-`Js.Dict.unsafeGet(key)` returns the value if the key exists, otherwise an `undefined` value is returned. Use this only when you are sure the key exists (i.e. when having used the `keys()` function to check that the key is valid).
-
-```res example
-Js.Dict.unsafeGet(ages, "Fred") == 49
-Js.Dict.unsafeGet(ages, "Paul") // returns undefined
-```
-
-## set
-
-```res sig
-let set: (t<'a>, key, 'a) => unit
-```
-
-`Js.Dict.set(dict, key, value)` sets the key/value in the dictionary `dict`. If the key does not exist, and entry will be created for it. *This function modifies the original dictionary.*
-
-```res example
-Js.Dict.set(ages, "Maria", 31)
-Js.log(ages == Js.Dict.fromList(list{("Maria", 31), ("Vinh", 22), ("Fred", 49)}))
-
-Js.Dict.set(ages, "David", 66)
-Js.log(ages == Js.Dict.fromList(list{("Maria", 31), ("Vinh", 22), ("Fred", 49), ("David", 66)}))
-```
-
-## keys
-
-```res sig
-let keys: t<'a> => array<string>
-```
-
-Returns all the keys in the dictionary `dict`.
-
-```res example
-Js.Dict.keys(ages) == ["Maria", "Vinh", "Fred"]
-```
-
-## empty
-
-```res sig
-let empty: unit => t<'a>
-```
-
-Returns an empty dictionary.
-
-## unsafeDeleteKey
-
-```res sig
-let unsafeDeleteKey: (. t<string>, string) => unit
-```
-
-Experimental internal function
-
-## entries
-
-```res sig
-let entries: t<'a> => array<(key, 'a)>
-```
-
-Returns an array of key/value pairs in the given dictionary (ES2017).
-
-```res example
-Js.Dict.entries(ages) == [("Maria", 30), ("Vinh", 22), ("Fred", 49)]
-```
-
-## values
-
-```res sig
-let values: t<'a> => array<'a>
-```
-
-Returns the values in the given dictionary (ES2017).
-
-```res example
-Js.Dict.values(ages) == [30, 22, 49]
-```
-
-## fromList
-
-```res sig
-let fromList: list<(key, 'a)> => t<'a>
-```
-
-Creates a new dictionary containing each (key, value) pair in its list argument.
-
-```res example
-let capitals = Js.Dict.fromList(list{("Japan", "Tokyo"), ("France", "Paris"), ("Egypt", "Cairo")})
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<(key, 'a)> => t<'a>
-```
-
-Creates a new dictionary containing each (key, value) pair in its array argument.
-
-```res example
-let capitals2 = Js.Dict.fromArray([("Germany", "Berlin"), ("Burkina Faso", "Ouagadougou")])
-```
-
-## map
-
-```res sig
-let map: ((. 'a) => 'b, t<'a>) => t<'b>
-```
-
-`map(f, dict)` maps `dict` to a new dictionary with the same keys, using the function `f` to map each value.
-
-```res example
-let prices = Js.Dict.fromList(list{("pen", 1.00), ("book", 5.00), ("stapler", 7.00)})
-
-let discount = (. price) => price *. 0.90
-let salePrices = Js.Dict.map(discount, prices)
-
-salePrices == Js.Dict.fromList(list{("pen", 0.90), ("book", 4.50), ("stapler", 6.30)})
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/exn.mdx b/pages/docs/manual/v10.0.0/api/js/exn.mdx
deleted file mode 100644
index 730a4b2ed..000000000
--- a/pages/docs/manual/v10.0.0/api/js/exn.mdx
+++ /dev/null
@@ -1,103 +0,0 @@
-# Exn
-
-<Intro>
-
-Provide utilities for dealing with JS exceptions.
-
-</Intro>
-
-## t
-
-```res prelude
-type t
-```
-
-## exn
-
-```res sig
-type exn +=
-  private
-  | Error(t)
-```
-
-## asJsExn
-
-```res sig
-let asJsExn: exn => option<t>
-```
-
-## stack
-
-```res sig
-let stack: t => option<string>
-```
-
-## message
-
-```res sig
-let message: t => option<string>
-```
-
-## name
-
-```res sig
-let name: t => option<string>
-```
-
-## fileName
-
-```res sig
-let fileName: t => option<string>
-```
-
-## isCamlExceptionOrOpenVariant
-
-```res sig
-let isCamlExceptionOrOpenVariant: 'a => bool
-```
-
-Internal use only.
-
-## raiseError
-
-```res sig
-let raiseError: string => 'a
-```
-
-Raise Js exception Error object with stacktrace.
-
-## raiseEvalError
-
-```res sig
-let raiseEvalError: string => 'a
-```
-
-## raiseRangeError
-
-```res sig
-let raiseRangeError: string => 'a
-```
-
-## raiseReferenceError
-
-```res sig
-let raiseReferenceError: string => 'a
-```
-
-## raiseSyntaxError
-
-```res sig
-let raiseSyntaxError: string => 'a
-```
-
-## raiseTypeError
-
-```res sig
-let raiseTypeError: string => 'a
-```
-
-## raiseUriError
-
-```res sig
-let raiseUriError: string => 'a
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/float.mdx b/pages/docs/manual/v10.0.0/api/js/float.mdx
deleted file mode 100644
index 1da019985..000000000
--- a/pages/docs/manual/v10.0.0/api/js/float.mdx
+++ /dev/null
@@ -1,282 +0,0 @@
-# Float
-
-<Intro>
-
-Provide utilities for JS float.
-
-</Intro>
-
-## _NaN
-
-```res sig
-let _NaN: float
-```
-The special value "Not a Number".
-
-## isNaN
-
-```res sig
-let isNaN: float => bool
-```
-
-Tests if the given value is _NaN.
-Note that both `_NaN == _NaN` and `_NaN === _NaN` will return false. `isNaN` is therefore necessary to test for `_NaN`.
-
-Returns true if the given value is `_NaN`, false otherwise.
-
-## isFinite
-
-```res sig
-let isFinite: float => bool
-```
-
-Tests if the given value is finite.
-Returns true if the given value is a finite number, false otherwise.
-
-```res example
-/* returns [false] */
-Js.Float.isFinite(infinity)
-```
-
-```res example
-/* returns [false] */
-Js.Float.isFinite(neg_infinity)
-```
-
-```res example
-/* returns [false] */
-Js.Float.isFinite(Js.Float._NaN)
-```
-
-```res example
-/* returns [true] */
-Js.Float.isFinite(1234.)
-```
-
-## toExponential
-
-```res sig
-let toExponential: float => string
-```
-
-Formats a float using exponential (scientific) notation.
-Returns a string representing the given value in exponential notation.
-Raises `RangeError` if `digits` is not in the range \[0, 20\] (inclusive).
-
-```res example
-/* prints "7.71234e+1" */
-Js.Float.toExponential(77.1234)->Js.log
-```
-
-```res example
-/* prints "7.7e+1" */
-Js.Float.toExponential(77.)->Js.log
-```
-
-## toExponentialWithPrecision
-
-```res sig
-let toExponentialWithPrecision: (float, ~digits: int) => string
-```
-
-Formats a `float` using exponential (scientific) notation.
-`digits` specifies how many digits should appear after the decimal point. The value must be in the range \[0, 20\] (inclusive).
-
-Returns a `string` representing the given value in exponential notation.
-
-The output will be rounded or padded with zeroes if necessary.
-Raises `RangeError` if `digits` is not in the range \[0, 20\] (inclusive).
-
-```res example
-/* prints "7.71e+1" */
-Js.Float.toExponentialWithPrecision(77.1234, ~digits=2)->Js.log
-```
-
-## toFixed
-
-```res sig
-let toFixed: float => string
-```
-
-Formats a `float` using fixed point notation.
-Returns a `string` representing the given value in fixed-point notation (usually).
-Raises `RangeError` if `digits` is not in the range \[0, 20\] (inclusive).
-
-```res example
-/* prints "12346" (note the rounding) */
-Js.Float.toFixed(12345.6789)->Js.log
-```
-
-```res example
-/* print "1.2e+21" */
-Js.Float.toFixed(1.2e21)->Js.log
-```
-
-## toFixedWithPrecision
-
-```res sig
-let toFixedWithPrecision: (float, ~digits: int) => string
-```
-
-Formats a `float` using fixed point notation.
-`digits` specifies how many digits should appear after the decimal point. The value must be in the range \[0, 20\] (inclusive). Defaults to 0.
-
-Returns a `string` representing the given value in fixed-point notation (usually).
-
-The output will be rounded or padded with zeroes if necessary.
-Raises `RangeError` if `digits` is not in the range \[0, 20\] (inclusive).
-
-```res example
-/* prints "12345.7" (note the rounding) */
-Js.Float.toFixedWithPrecision(12345.6789, ~digits=1)->Js.log
-```
-
-```res example
-/* prints "0.00" (note the added zeroes) */
-Js.Float.toFixedWithPrecision(0., ~digits=2)->Js.log
-```
-
-## toPrecision
-
-```res sig
-let toPrecision: float => string
-```
-
-Formats a `float` using some fairly arbitrary rules.
-Returns a `string` representing the given value in fixed-point (usually).
-
-`toPrecision` differs from `toFixed` in that the former will format the number with full precision, while the latter will not output any digits after the decimal point.
-Raises `RangeError` if `digits` is not in the range accepted by this function.
-
-```res example
-/* prints "12345.6789" */
-Js.Float.toPrecision(12345.6789)->Js.log
-```
-
-```res example
-/* print "1.2e+21" */
-Js.Float.toPrecision(1.2e21)->Js.log
-```
-
-## toPrecisionWithPrecision
-
-```res sig
-let toPrecisionWithPrecision: (float, ~digits: int) => string
-```
-
-Formats a `float` using some fairly arbitrary rules.
-`digits` specifies how many digits should appear in total. The value must be between 0 and some arbitrary number that's hopefully at least larger than 20 (for Node it's 21. Why? Who knows).
-
-Returns a `string` representing the given value in fixed-point or scientific notation.
-
-The output will be rounded or padded with zeroes if necessary.
-
-`toPrecisionWithPrecision` differs from `toFixedWithPrecision` in that the former will count all digits against the precision, while the latter will count only the digits after the decimal point.
-`toPrecisionWithPrecision` will also use scientific notation if the specified precision is less than the number for digits before the decimal point.
-Raises `RangeError` if `digits` is not in the range accepted by this function.
-
-```res example
-/* prints "1e+4" */
-Js.Float.toPrecisionWithPrecision(12345.6789, ~digits=1)->Js.log
-```
-
-```res example
-/* prints "0.0" */
-Js.Float.toPrecisionWithPrecision(0., ~digits=2)->Js.log
-```
-
-## toString
-
-```res sig
-let toString: float => string
-```
-
-Formats a `float` as a `string`.
-Returns a `string` representing the given value in fixed-point (usually).
-
-```res example
-/* prints "12345.6789" */
-Js.Float.toString(12345.6789)->Js.log
-```
-
-## toStringWithRadix
-
-```res sig
-let toStringWithRadix: (float, ~radix: int) => string
-```
-
-Formats a `float` as a `string`.
-`radix` specifies the radix base to use for the formatted number. The value must be in the range \[2, 36\] (inclusive).
-
-Returns a `string` representing the given value in fixed-point (usually).
-Raises `RangeError` if `radix` is not in the range \[2, 36\] (inclusive).
-
-```res example
-/* prints "110" */
-Js.Float.toStringWithRadix(6., ~radix=2)->Js.log
-```
-
-```res example
-/* prints "11.001000111101011100001010001111010111000010100011111" */
-Js.Float.toStringWithRadix(3.14, ~radix=2)->Js.log
-```
-
-```res example
-/* prints "deadbeef" */
-Js.Float.toStringWithRadix(3735928559., ~radix=16)->Js.log
-
-```
-
-```res example
-/* prints "3f.gez4w97ry0a18ymf6qadcxr" */
-Js.Float.toStringWithRadix(123.456, ~radix=36)->Js.log
-```
-
-## fromString
-
-```res sig
-let fromString: string => float
-```
-
-Parses the given `string` into a `float` using JavaScript semantics.
-Returns the number as a `float` if successfully parsed, `_NaN` otherwise.
-
-```res example
-/* returns 123 */
-Js.Float.fromString("123")
-```
-
-```res example
-/* returns 12.3 */
-Js.Float.fromString("12.3")
-```
-
-```res example
-/* returns 0 */
-Js.Float.fromString("")
-```
-
-```res example
-/* returns 17 */
-Js.Float.fromString("0x11")
-```
-
-```res example
-/* returns 3 */
-Js.Float.fromString("0b11")
-```
-
-```res example
-/* returns 9 */
-Js.Float.fromString("0o11")
-```
-
-```res example
-/* returns [_NaN] */
-Js.Float.fromString("hello")
-```
-
-```res example
-/* returns [_NaN] */
-Js.Float.fromString("100a")
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/global.mdx b/pages/docs/manual/v10.0.0/api/js/global.mdx
deleted file mode 100644
index 7bba67610..000000000
--- a/pages/docs/manual/v10.0.0/api/js/global.mdx
+++ /dev/null
@@ -1,179 +0,0 @@
-# Global
-
-<Intro>
-
-Provide bindings to JS global functions in global namespace.
-
-</Intro>
-
-```res prelude
-type intervalId
-```
-
-Identify an interval started by `Js.Global.setInterval`.
-
-```res prelude
-type timeoutId
-```
-
-Identify timeout started by `Js.Global.setTimeout`.
-
-## clearInterval
-
-```res sig
-let clearInterval: intervalId => unit
-```
-
-Clear an interval started by `Js.Global.setInterval`
-
-```res example
-/* API for a somewhat aggressive snoozing alarm clock */
-
-let punchSleepyGuy = () => Js.log("Punch")
-
-let interval = ref(Js.Nullable.null)
-
-let remind = () => {
-  Js.log("Wake Up!")
-  punchSleepyGuy()
-}
-
-let snooze = mins =>
-  interval := Js.Nullable.return(Js.Global.setInterval(remind, mins * 60 * 1000))
-
-let cancel = () =>
-  Js.Nullable.iter(interval.contents, (. intervalId) => Js.Global.clearInterval(intervalId))
-```
-
-## clearTimeout
-
-```res sig
-let clearTimeout: timeoutId => unit
-```
-
-Clear a timeout started by `Js.Global.setTimeout`.
-
-```res example
-/* A simple model of a code monkey's brain */
-
-let closeHackerNewsTab = () => Js.log("close")
-
-let timer = ref(Js.Nullable.null)
-
-let work = () => closeHackerNewsTab()
-
-let procrastinate = mins => {
-  Js.Nullable.iter(timer.contents, (. timer) => Js.Global.clearTimeout(timer))
-  timer := Js.Nullable.return(Js.Global.setTimeout(work, mins * 60 * 1000))
-}
-```
-
-## setInterval
-
-```res sig
-let setInterval: (unit => unit, int) => intervalId
-```
-
-Repeatedly executes a callback with a specified interval (in milliseconds) between calls.
-Returns a `Js.Global.intervalId` that can be passed to `Js.Global.clearInterval` to cancel the timeout.
-
-```res example
-/* Will count up and print the count to the console every second */
-
-let count = ref(0)
-
-let tick = () => {
-  count := count.contents + 1
-  Js.log(Belt.Int.toString(count.contents))
-}
-
-Js.Global.setInterval(tick, 1000)
-```
-
-## setIntervalFloat
-
-```res sig
-let setIntervalFloat: (unit => unit, float) => intervalId
-```
-
-Repeatedly executes a callback with a specified interval (in milliseconds) between calls.
-Returns a `Js.Global.intervalId` that can be passed to `Js.Global.clearInterval` to cancel the timeout.
-
-```res example
-/* Will count up and print the count to the console every second */
-
-let count = ref(0)
-
-let tick = () => {
-  count := count.contents + 1
-  Js.log(Belt.Int.toString(count.contents))
-}
-
-Js.Global.setIntervalFloat(tick, 1000.0)
-```
-
-## setTimeout
-
-```res sig
-let setTimeout: (unit => unit, int) => timeoutId
-```
-
-Execute a callback after a specified delay (in milliseconds).
-Returns a `Js.Global.timeoutId` that can be passed to `Js.Global.clearTimeout` to cancel the timeout.
-
-```res example
-/* Prints "Timed out!" in the console after one second */
-
-let message = "Timed out!"
-
-Js.Global.setTimeout(() => Js.log(message), 1000)
-```
-
-## setTimeoutFloat
-
-```res sig
-let setTimeoutFloat: (unit => unit, float) => timeoutId
-```
-
-Execute a callback after a specified delay (in milliseconds).
-Returns a `Js.Global.timeoutId` that can be passed to `Js.Global.clearTimeout` to cancel the timeout.
-
-```res example
-/* Prints "Timed out!" in the console after one second */
-
-let message = "Timed out!"
-
-Js.Global.setTimeoutFloat(() => Js.log(message), 1000.0)
-```
-
-## encodeURI
-
-```res sig
-let encodeURI: string => string
-```
-
-URL-encodes a string.
-
-## decodeURI
-
-```res sig
-let decodeURI: string => string
-```
-
-Decodes a URL-enmcoded string produced by encodeURI.
-
-## encodeURIComponent
-
-```res sig
-let encodeURIComponent: string => string
-```
-
-URL-encodes a string, including characters with special meaning in a URI.
-
-## decodeURIComponent
-
-```res sig
-let decodeURIComponent: string => string
-```
-
-Decodes a URL-enmcoded string produced by encodeURIComponent
diff --git a/pages/docs/manual/v10.0.0/api/js/int.mdx b/pages/docs/manual/v10.0.0/api/js/int.mdx
deleted file mode 100644
index 1fc48b47a..000000000
--- a/pages/docs/manual/v10.0.0/api/js/int.mdx
+++ /dev/null
@@ -1,146 +0,0 @@
-# Int
-
-<Intro>
-
-Provide utilities for handling `int`.
-
-</Intro>
-
-## toExponential
-
-```res sig
-let toExponential: int => string
-```
-
-Formats an `int` using exponential (scientific) notation.
-Returns a `string` representing the given value in exponential notation.
-Raises `RangeError` if digits is not in the range \[0, 20\] (inclusive).
-
-```res example
-/* prints "7.7e+1" */
-Js.log(Js.Int.toExponential(77))
-```
-
-## toExponentialWithPrecision
-
-```res sig
-let toExponentialWithPrecision: (int, ~digits: int) => string
-```
-
-Formats an `int` using exponential (scientific) notation.
-`digits` specifies how many digits should appear after the decimal point. The value must be in the range \[0, 20\] (inclusive).
-
-Returns a `string` representing the given value in exponential notation.
-
-The output will be rounded or padded with zeroes if necessary.
-Raises `RangeError` if `digits` is not in the range \[0, 20\] (inclusive).
-
-```res example
-/* prints "7.70e+1" */
-Js.log(Js.Int.toExponentialWithPrecision(77, ~digits=2))
-
-/* prints "5.68e+3" */
-Js.log(Js.Int.toExponentialWithPrecision(5678, ~digits=2))
-```
-
-## toPrecision
-
-```res sig
-let toPrecision: int => string
-```
-
-Formats an `int` using some fairly arbitrary rules.
-Returns a `string` representing the given value in fixed-point (usually).
-
-`toPrecision` differs from `toFixed` in that the former will format the number with full precision, while the latter will not output any digits after the decimal point.
-Raises `RangeError` if `digits` is not in the range accepted by this function.
-
-```res example
-/* prints "123456789" */
-Js.log(Js.Int.toPrecision(123456789))
-```
-
-## toPrecisionWithPrecision
-
-```res sig
-let toPrecisionWithPrecision: (int, ~digits: int) => string
-```
-
-Formats an `int` using some fairly arbitrary rules.
-`digits` specifies how many digits should appear in total. The value must between 0 and some arbitrary number that's hopefully at least larger than 20 (for Node it's 21. Why? Who knows).
-
-Returns a `string` representing the given value in fixed-point or scientific notation.
-
-The output will be rounded or padded with zeroes if necessary.
-
-`toPrecisionWithPrecision` differs from `toFixedWithPrecision` in that the former will count all digits against the precision, while the latter will count only the digits after the decimal point.
-`toPrecisionWithPrecision` will also use scientific notation if the specified precision is less than the number of digits before the decimal point.
-Raises `RangeError` if `digits` is not in the range accepted by this function.
-
-```res example
-/* prints "1.2e+8" */
-Js.log(Js.Int.toPrecisionWithPrecision(123456789, ~digits=2))
-
-/* prints "0.0" */
-Js.log(Js.Int.toPrecisionWithPrecision(0, ~digits=2))
-```
-
-## toString
-
-```res sig
-let toString: int => string
-```
-
-Formats an `int` as a `string`.
-Returns a `string` representing the given value in fixed-point (usually).
-
-```res example
-/* prints "123456789" */
-Js.log(Js.Int.toString(123456789))
-```
-
-## toStringWithRadix
-
-```res sig
-let toStringWithRadix: (int, ~radix: int) => string
-```
-
-Formats an `int` as a `string`.
-`radix` specifies the radix base to use for the formatted number. The value must be in the range \[2, 36\] (inclusive).
-Returns a `string` representing the given value in fixed-point (usually).
-Raises `RangeError` if `radix` is not in the range \[2, 36\] (inclusive).
-
-```res example
-/* prints "110" */
-Js.log(Js.Int.toStringWithRadix(6, ~radix=2))
-
-/* prints "deadbeef" */
-Js.log(Js.Int.toStringWithRadix(3735928559, ~radix=16))
-
-/* prints "2n9c" */
-Js.log(Js.Int.toStringWithRadix(123456, ~radix=36))
-```
-
-## toFloat
-
-```res sig
-let toFloat: int => float
-```
-
-## equal
-
-```res sig
-let equal: (int, int) => bool
-```
-
-## max
-
-```res sig
-let max: int
-```
-
-## min
-
-```res sig
-let min: int
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/json.mdx b/pages/docs/manual/v10.0.0/api/js/json.mdx
deleted file mode 100644
index ca48da776..000000000
--- a/pages/docs/manual/v10.0.0/api/js/json.mdx
+++ /dev/null
@@ -1,293 +0,0 @@
-# Json
-
-<Intro>
-
-Provide utilities for JSON.
-
-</Intro>
-
-## t
-
-```res prelude
-type t
-```
-
-The JSON data structure.
-
-## kind
-
-```res prelude
-type rec kind<'a> =
-  | String: kind<Js_string.t>
-  | Number: kind<float>
-  | Object: kind<Js_dict.t<t>>
-  | Array: kind<array<t>>
-  | Boolean: kind<bool>
-  | Null: kind<Js_types.null_val>
-```
-
-Underlying type of a JSON value.
-
-## tagged_t
-
-```res prelude
-type tagged_t =
-  | JSONFalse
-  | JSONTrue
-  | JSONNull
-  | JSONString(string)
-  | JSONNumber(float)
-  | JSONObject(Js_dict.t<t>)
-  | JSONArray(array<t>)
-```
-
-
-## classify
-
-```res sig
-let classify: t => tagged_t
-```
-
-## test
-
-```res sig
-let test: ('a, kind<'b>) => bool
-```
-
-`test(v, kind)` returns `true` if `v` is of `kind`.
-
-## decodeString
-
-```res sig
-let decodeString: t => option<Js_string.t>
-```
-
-`decodeString(json)` returns `Some(s)` if `json` is a `string`, `None` otherwise.
-
-## decodeNumber
-
-```res sig
-let decodeNumber: t => option<float>
-```
-
-`decodeNumber(json)` returns `Some(n)` if `json` is a `number`, `None` otherwise.
-
-## decodeObject
-
-```res sig
-let decodeObject: t => option<Js_dict.t<t>>
-```
-
-`decodeObject(json)` returns `Some(o)` if `json` is an `object`, `None` otherwise.
-
-## decodeArray
-
-```res sig
-let decodeArray: t => option<array<t>>
-```
-
-`decodeArray(json)` returns `Some(a)` if `json` is an `array`, `None` otherwise.
-
-## decodeBoolean
-
-```res sig
-let decodeBoolean: t => option<bool>
-```
-
-`decodeBoolean(json)` returns `Some(b)` if `json` is a `boolean`, `None` otherwise.
-
-## decodeNull
-
-```res sig
-let decodeNull: t => option<Js_null.t<'a>>
-```
-
-`decodeNull(json)` returns `Some(null)` if `json` is a `null`, `None` otherwise.
-
-## null
-
-```res sig
-let null: t
-```
-
-`null` is the singleton null JSON value.
-
-## string
-
-```res sig
-let string: string => t
-```
-
-`string(s)` makes a JSON string of the `string` `s`.
-
-## number
-
-```res sig
-let number: float => t
-```
-
-`number(n)` makes a JSON number of the `float` `n`.
-
-## boolean
-
-```res sig
-let boolean: bool => t
-```
-
-`boolean(b)` makes a JSON boolean of the `bool` `b`.
-
-## object_
-
-```res sig
-let object_: Js_dict.t<t> => t
-```
-
-`object_(dict)` makes a JSON object of the `Js.Dict.t` `dict`.
-
-## array
-
-```res sig
-let array: array<t> => t
-```
-
-`array_(a)` makes a JSON array of the `Js.Json.t` array `a`.
-
-## stringArray
-
-```res sig
-let stringArray: array<string> => t
-```
-
-`stringArray(a)` makes a JSON array of the `string` array `a`.
-
-## numberArray
-
-```res sig
-let numberArray: array<float> => t
-```
-
-`numberArray(a)` makes a JSON array of the `float` array `a`.
-
-## booleanArray
-
-```res sig
-let booleanArray: array<bool> => t
-```
-
-`booleanArray(a)` makes a JSON array of the `bool` array `a`.
-
-## objectArray
-
-```res sig
-let objectArray: array<Js_dict.t<t>> => t
-```
-
-`objectArray(a) makes a JSON array of the `JsDict.t` array `a`.
-
-## parseExn
-
-```res sig
-let parseExn: string => t
-```
-
-`parseExn(s)` parses the `string` `s` into a JSON data structure.
-Returns a JSON data structure.
-Raises `SyntaxError` if the given string is not a valid JSON. Note: `SyntaxError` is a JavaScript exception.
-
-```res example
-/* parse a simple JSON string */
-
-let json = try Js.Json.parseExn(` "hello" `) catch {
-| _ => failwith("Error parsing JSON string")
-}
-
-switch Js.Json.classify(json) {
-| Js.Json.JSONString(value) => Js.log(value)
-| _ => failwith("Expected a string")
-}
-```
-
-```res example
-/* parse a complex JSON string */
-
-let getIds = s => {
-  let json = try Js.Json.parseExn(s) catch {
-  | _ => failwith("Error parsing JSON string")
-  }
-
-  switch Js.Json.classify(json) {
-  | Js.Json.JSONObject(value) =>
-    /* In this branch, compiler infer value : Js.Json.t Js.Dict.t */
-    switch Js.Dict.get(value, "ids") {
-    | Some(ids) =>
-      switch Js.Json.classify(ids) {
-      | Js.Json.JSONArray(ids) => /* In this branch compiler infer ids : Js.Json.t array */
-        ids
-      | _ => failwith("Expected an array")
-      }
-    | None => failwith("Expected an `ids` property")
-    }
-  | _ => failwith("Expected an object")
-  }
-}
-
-/* prints `1, 2, 3` */
-Js.log(getIds(` { "ids" : [1, 2, 3 ] } `))
-```
-
-## stringify
-
-```res sig
-let stringify: t => string
-```
-
-`stringify(json)` formats the JSON data structure as a `string`.
-Returns the string representation of a given JSON data structure.
-
-```res example
-/* Creates and stringifies a simple JS object */
-
-{
-  let dict = Js.Dict.empty()
-  Js.Dict.set(dict, "name", Js.Json.string("John Doe"))
-  Js.Dict.set(dict, "age", Js.Json.number(30.0))
-  Js.Dict.set(dict, "likes", Js.Json.stringArray(["bucklescript", "ocaml", "js"]))
-
-  Js.log(Js.Json.stringify(Js.Json.object_(dict)))
-}
-```
-
-## stringifyWithSpace
-
-```res sig
-let stringifyWithSpace: (t, int) => string
-```
-
-`stringify(json)` formats the JSON data structure as a `string`.
-Returns the string representation of a given JSON data structure with spacing.
-
-```res example
-/* Creates and stringifies a simple JS object with spacing */
-
-{
-  let dict = Js.Dict.empty()
-  Js.Dict.set(dict, "name", Js.Json.string("John Doe"))
-  Js.Dict.set(dict, "age", Js.Json.number(30.0))
-  Js.Dict.set(dict, "likes", Js.Json.stringArray(["bucklescript", "ocaml", "js"]))
-
-  Js.log(Js.Json.stringifyWithSpace(Js.Json.object_(dict), 2))
-}
-```
-
-## stringifyAny
-
-```res sig
-let stringifyAny: 'a => option<string>
-```
-
-`stringifyAny(value)` formats any value into a JSON string.
-
-```res example
-/* prints `["hello", "world"]` */
-Js.log(Js.Json.stringifyAny(["hello", "world"]))
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/list.mdx b/pages/docs/manual/v10.0.0/api/js/list.mdx
deleted file mode 100644
index 72b908489..000000000
--- a/pages/docs/manual/v10.0.0/api/js/list.mdx
+++ /dev/null
@@ -1,143 +0,0 @@
-# List
-
-<Intro>
-
-Provide utilities for list.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a> = list<'a>
-```
-
-## length
-
-```res sig
-let length: t<'a> => int
-```
-
-## cons
-
-```res sig
-let cons: ('a, t<'a>) => t<'a>
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a> => bool
-```
-
-## hd
-
-```res sig
-let hd: t<'a> => option<'a>
-```
-
-## tl
-
-```res sig
-let tl: t<'a> => option<t<'a>>
-```
-
-## nth
-
-```res sig
-let nth: (t<'a>, int) => option<'a>
-```
-
-## revAppend
-
-```res sig
-let revAppend: (t<'a>, t<'a>) => t<'a>
-```
-
-## rev
-
-```res sig
-let rev: t<'a> => t<'a>
-```
-
-## mapRev
-
-```res sig
-let mapRev: ((. 'a) => 'b, t<'a>) => t<'b>
-```
-
-## map
-
-```res sig
-let map: ((. 'a) => 'b, t<'a>) => t<'b>
-```
-
-## iter
-
-```res sig
-let iter: ((. 'a) => unit, t<'a>) => unit
-```
-
-## iteri
-
-```res sig
-let iteri: ((. int, 'a) => unit, t<'a>) => unit
-```
-
-## foldLeft
-
-```res sig
-let foldLeft: ((. 'a, 'b) => 'a, 'a, list<'b>) => 'a
-```
-
-Application order is left to right, tail-recurisve.
-
-## foldRight
-
-```res sig
-let foldRight: ((. 'a, 'b) => 'b, list<'a>, 'b) => 'b
-```
-
-Application order is right to left, tail-recursive.
-
-## flatten
-
-```res sig
-let flatten: t<t<'a>> => t<'a>
-```
-
-## filter
-
-```res sig
-let filter: ((. 'a) => bool, t<'a>) => t<'a>
-```
-
-## filterMap
-
-```res sig
-let filterMap: ((. 'a) => option<'b>, t<'a>) => t<'b>
-```
-
-## countBy
-
-```res sig
-let countBy: ((. 'a) => bool, list<'a>) => int
-```
-
-## init
-
-```res sig
-let init: (int, (. int) => 'a) => t<'a>
-```
-
-## toVector
-
-```res sig
-let toVector: t<'a> => Js_vector.t<'a>
-```
-
-## equal
-
-```res sig
-let equal: ((. 'a, 'a) => bool, list<'a>, list<'a>) => bool
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/math.mdx b/pages/docs/manual/v10.0.0/api/js/math.mdx
deleted file mode 100644
index 90592d361..000000000
--- a/pages/docs/manual/v10.0.0/api/js/math.mdx
+++ /dev/null
@@ -1,628 +0,0 @@
-# Math
-
-<Intro>
-
-Provide utilities for JS Math. Note: The constants `_E`, `_LN10`, `_LN2`, `_LOG10E`, `_LOG2E`, `_PI`, `_SQRT1_2`, and `_SQRT2` begin with an underscore because ReasonML variable names cannot begin with a capital letter. (Module names begin with upper case.)
-
-</Intro>
-
-## _E
-
-```res sig
-let _E: float
-```
-
-Euler's number; ≈ 2.718281828459045. See [`Math.E`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/E) on MDN.
-
-## _LN2
-
-```res sig
-let _LN2: float
-```
-
-Natural logarithm of 2; ≈ 0.6931471805599453. See [`Math.LN2`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/LN2) on MDN.
-
-## _LN10
-
-```res sig
-let _LN10: float
-```
-
-Natural logarithm of 10; ≈ 2.302585092994046. See [`Math.LN10`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/LN10) on MDN.
-
-## _LOG2E
-
-```res sig
-let _LOG2E: float
-```
-
-Base 2 logarithm of E; ≈ 1.4426950408889634. See [`Math.LOG2E`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/LOG2E) on MDN.
-
-## _LOG10E
-
-```res sig
-let _LOG10E: float
-```
-
-Base 10 logarithm of E; ≈ 0.4342944819032518. See [`Math.LOG10E`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/LOG10E) on MDN.
-
-## _PI
-
-```res sig
-let _PI: float
-```
-
-Pi - ratio of the circumference to the diameter of a circle; ≈ 3.141592653589793. See [`Math.PI`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/PI) on MDN.
-
-## _SQRT1_2
-
-```res sig
-let _SQRT1_2: float
-```
-
-Square root of 1/2; ≈ 0.7071067811865476. See [`Math.SQRT1_2`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2) on MDN.
-
-## _SQRT2
-
-```res sig
-let _SQRT2: float
-```
-
-Square root of 2; ≈ 1.4142135623730951. See [`Math.SQRT2`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/SQRT2) on MDN.
-
-## abs_int
-
-```res sig
-let abs_int: int => int
-```
-
-Absolute value for integer argument. See [`Math.abs`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/abs) on MDN.
-
-## abs_float
-
-```res sig
-let abs_float: float => float
-```
-
-Absolute value for float argument. See [`Math.abs`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/abs) on MDN.
-
-## acos
-
-```res sig
-let acos: float => float
-```
-
-Arccosine (in radians) of argument; returns `NaN` if the argument is outside the range [-1.0, 1.0]. See [`Math.acos`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acos) on MDN.
-
-## acosh
-
-```res sig
-let acosh: float => float
-```
-
-Hyperbolic arccosine (in radians) of argument; returns `NaN` if the argument is less than 1.0. See [`Math.acosh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acosh) on MDN.
-
-## asin
-
-```res sig
-let asin: float => float
-```
-
-Arcsine (in radians) of argument; returns `NaN` if the argument is outside the range [-1.0, 1.0]. See [`Math.asin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asin) on MDN.
-
-## asinh
-
-```res sig
-let asinh: float => float
-```
-
-Hyperbolic arcsine (in radians) of argument. See [`Math.asinh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asinh) on MDN.
-
-## atan
-
-```res sig
-let atan: float => float
-```
-
-Arctangent (in radians) of argument. See [`Math.atan`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan) on MDN.
-
-## atanh
-
-```res sig
-let atanh: float => float
-```
-
-Hyperbolic arctangent (in radians) of argument; returns `NaN` if the argument is is outside the range [-1.0, 1.0]. Returns `-Infinity` and `Infinity` for arguments -1.0 and 1.0. See [`Math.atanh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atanh) on MDN.
-
-## atan2
-
-```res sig
-let atan2: (~y: float, ~x: float, unit) => float
-```
-
-Returns the angle (in radians) of the quotient `y /. x`. It is also the angle between the *x*-axis and point (*x*, *y*). See [`Math.atan2`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2) on MDN.
-
-```res example
-Js.Math.atan2(~y=0.0, ~x=10.0, ()) == 0.0
-Js.Math.atan2(~x=5.0, ~y=5.0, ()) == Js.Math._PI /. 4.0
-Js.Math.atan2(~x=-5.0, ~y=5.0, ())
-Js.Math.atan2(~x=-5.0, ~y=5.0, ()) == 3.0 *. Js.Math._PI /. 4.0
-Js.Math.atan2(~x=-0.0, ~y=-5.0, ()) == -.Js.Math._PI /. 2.0
-```
-
-## cbrt
-
-```res sig
-let cbrt: float => float
-```
-
-Cube root. See [`Math.cbrt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cbrt) on MDN
-
-## unsafe_ceil_int
-
-```res sig
-let unsafe_ceil_int: float => int
-```
-
-Returns the smallest integer greater than or equal to the argument. This function may return values not representable by `int`, whose range is -2147483648 to 2147483647. This is because, in JavaScript, there are only 64-bit floating point numbers, which can represent integers in the range ±(2<sup>53</sup>-1) exactly. See [`Math.ceil`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil) on MDN.
-
-```res example
-Js.Math.unsafe_ceil_int(3.1) == 4
-Js.Math.unsafe_ceil_int(3.0) == 3
-Js.Math.unsafe_ceil_int(-3.1) == -3
-Js.Math.unsafe_ceil_int(1.0e15) // result is outside range of int datatype
-```
-
-## unsafe_ceil
-
-```res sig
-let unsafe_ceil: float => int
-```
-Deprecated; please use [`unsafe_ceil_int`](#unsafe_ceil_int) instead.
-
-## ceil_int
-
-```res sig
-let ceil_int: float => int
-```
-
-Returns the smallest `int` greater than or equal to the argument; the result is pinned to the range of the `int` data type: -2147483648 to 2147483647. See [`Math.ceil`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil) on MDN.
-
-```res example
-Js.Math.ceil_int(3.1) == 4
-Js.Math.ceil_int(3.0) == 3
-Js.Math.ceil_int(-3.1) == -3
-Js.Math.ceil_int(-1.0e15) == -2147483648
-Js.Math.ceil_int(1.0e15) == 2147483647
-```
-
-## ceil
-
-```res sig
-let ceil: float => int
-```
-
-Deprecated; please use [`ceil_int`](#ceil_int) instead.
-
-## ceil_float
-
-```res sig
-let ceil_float: float => float
-```
-
-Returns the smallest integral value greater than or equal to the argument. The result is a `float` and is not restricted to the `int` data type range. See [`Math.ceil`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil) on MDN.
-
-```res example
-Js.Math.ceil_float(3.1) == 4.0
-Js.Math.ceil_float(3.0) == 3.0
-Js.Math.ceil_float(-3.1) == -3.0
-Js.Math.ceil_float(2_150_000_000.3) == 2_150_000_001.0
-```
-
-## clz32
-
-```res sig
-let clz32: int => int
-```
-
-Number of leading zero bits of the argument's 32 bit int representation. See [`Math.clz32`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32) on MDN.
-
-```res example
-Js.Math.clz32(0) == 32
-Js.Math.clz32(-1) == 0
-Js.Math.clz32(255) == 24
-```
-
-## cos
-
-```res sig
-let cos: float => float
-```
-
-Cosine of argument, which must be specified in radians. See [`Math.cos`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cos) on MDN.
-
-## cosh
-
-```res sig
-let cosh: float => float
-```
-
-Hyperbolic cosine of argument, which must be specified in radians. See [`Math.cosh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cosh) on MDN.
-
-## exp
-
-```res sig
-let exp: float => float
-```
-
-Natural exponentional; returns *e* (the base of natural logarithms) to the power of the given argument. See [`Math.exp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/exp) on MDN.
-
-## expm1
-
-```res sig
-let expm1: float => float
-```
-
-Returns *e* (the base of natural logarithms) to the power of the given argument minus 1. See [`Math.expm1`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/expm1) on MDN.
-
-## unsafe_floor_int
-
-```res sig
-let unsafe_floor_int: float => int
-```
-
-Returns the largest integer less than or equal to the argument. This function may return values not representable by `int`, whose range is -2147483648 to 2147483647. This is because, in JavaScript, there are only 64-bit floating point numbers, which can represent integers in the range ±(2<sup>53</sup>-1) exactly. See [`Math.floor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor) on MDN.
-
-```res example
-Js.Math.unsafe_floor_int(3.7) == 3
-Js.Math.unsafe_floor_int(3.0) == 3
-Js.Math.unsafe_floor_int(-3.7) == -4
-Js.Math.unsafe_floor_int(1.0e15) // result is outside range of int datatype
-```
-
-## unsafe_floor
-
-```res sig
-let unsafe_floor: float => int
-```
-
-Deprecated; please use [`unsafe_floor_int`](#unsafe_floor_int) instead.
-
-## floor_int
-
-```res sig
-let floor_int: float => int
-```
-
-Returns the largest `int` less than or equal to the argument; the result is pinned to the range of the `int` data type: -2147483648 to 2147483647. See [`Math.floor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor) on MDN.
-
-```res example
-Js.Math.floor_int(3.7) == 3
-Js.Math.floor_int(3.0) == 3
-Js.Math.floor_int(-3.1) == -4
-Js.Math.floor_int(-1.0e15) == -2147483648
-Js.Math.floor_int(1.0e15) == 2147483647
-```
-
-## floor
-
-```res sig
-let floor: float => int
-```
-
-Deprecated; please use [`floor_int`](#floor_int) instead.
-
-## floor_float
-
-```res sig
-let floor_float: float => float
-```
-
-Returns the largest integral value less than or equal to the argument. The result is a `float` and is not restricted to the `int` data type range. See [`Math.floor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor) on MDN.
-
-```res example
-Js.Math.floor_float(3.7) == 3.0
-Js.Math.floor_float(3.0) == 3.0
-Js.Math.floor_float(-3.1) == -4.0
-Js.Math.floor_float(2_150_000_000.3) == 2_150_000_000.0
-```
-## fround
-
-```res sig
-let fround: float => float
-```
-
-Round to nearest single precision float. See [`Math.fround`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround) on MDN.
-
-```res example
-Js.Math.fround(5.5) == 5.5
-Js.Math.fround(5.05) == 5.050000190734863
-```
-
-## hypot
-
-```res sig
-let hypot: (float, float) => float
-```
-
-Returns the square root of the sum of squares of its two arguments (the Pythagorean formula). See [`Math.hypot`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/hypot) on MDN.
-
-## hypotMany
-
-```res sig
-let hypotMany: array<float> => float
-```
-
-Returns the square root of the sum of squares of the numbers in the array argument (generalized Pythagorean equation). Using an array allows you to have more than two items. See [`Math.hypot`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/hypot) on MDN.
-
-```res example
-Js.Math.hypotMany([3.0, 4.0, 12.0]) == 13.0
-```
-
-## imul
-
-```res sig
-let imul: (int, int) => int
-```
-
-32-bit integer multiplication. Use this only when you need to optimize performance of multiplication of numbers stored as 32-bit integers. See [`Math.imul`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul) on MDN.
-
-## log
-
-```res sig
-let log: float => float
-```
-
-Returns the natural logarithm of its argument; this is the number *x* such that *e*<sup>*x*</sup> equals the argument. Returns `NaN` for negative arguments. See [`Math.log`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log) on MDN.
-
-```res example
-Js.Math.log(Js.Math._E) == 1.0
-Js.Math.log(100.0) == 4.605170185988092
-```
-
-## log1p
-
-```res sig
-let log1p: float => float
-```
-
-Returns the natural logarithm of one plus the argument. Returns `NaN` for arguments less than -1. See [`Math.log1p`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log1p) on MDN.
-
-```res example
-Js.Math.log1p(Js.Math._E -. 1.0) == 1.0
-Js.Math.log1p(99.0) == 4.605170185988092
-```
-
-## log10
-
-```res sig
-let log10: float => float
-```
-
-Returns the base 10 logarithm of its argument. Returns `NaN` for negative arguments. See [`Math.log10`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log10) on MDN.
-
-```res example
-Js.Math.log10(1000.0) == 3.0
-Js.Math.log10(0.01) == -2.0
-Js.Math.log10(Js.Math.sqrt(10.0)) == 0.5
-```
-
-## log2
-
-```res sig
-let log2: float => float
-```
-
-Returns the base 2 logarithm of its argument. Returns `NaN` for negative arguments. See [`Math.log2`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log2) on MDN.
-
-```res example
-Js.Math.log2(512.0) == 9.0
-Js.Math.log2(0.125) == -3.0
-Js.Math.log2(Js.Math._SQRT2) == 0.5000000000000001 // due to precision
-```
-
-
-## max_int
-
-```res sig
-let max_int: (int, int) => int
-```
-
-Returns the maximum of its two integer arguments.  See [`Math.max`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max) on MDN.
-
-## maxMany_int
-
-```res sig
-let maxMany_int: array<int> => int
-```
-
-Returns the maximum of the integers in the given array.  See [`Math.max`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max) on MDN.
-
-## max_float
-
-```res sig
-let max_float: (float, float) => float
-```
-
-Returns the maximum of its two floating point arguments. See [`Math.max`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max) on MDN.
-
-## maxMany_float
-
-```res sig
-let maxMany_float: array<float> => float
-```
-
-Returns the maximum of the floating point values in the given array. See [`Math.max`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max) on MDN.
-
-## min_int
-
-```res sig
-let min_int: (int, int) => int
-```
-
-Returns the minimum of its two integer arguments. See [`Math.min`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min) on MDN.
-
-
-## minMany_int
-
-```res sig
-let minMany_int: array<int> => int
-```
-
-Returns the minimum of the integers in the given array. See [`Math.min`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min) on MDN.
-
-## min_float
-
-```res sig
-let min_float: (float, float) => float
-```
-
-Returns the minimum of its two floating point arguments. See [`Math.min`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min) on MDN.
-
-## minMany_float
-
-```res sig
-let minMany_float: array<float> => float
-```
-
-Returns the minimum of the floating point values in the given array. See [`Math.min`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min) on MDN.
-
-
-## pow_int
-
-```res sig
-let pow_int: (~base: int, ~exp: int) => int
-```
-
-Raises the given base to the given exponent. (Arguments and result are integers.) See [`Math.pow`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/pow) on MDN.
-
-```res example
-Js.Math.pow_int(~base=3, ~exp=4) == 81
-```
-
-
-## pow_float
-
-```res sig
-let pow_float: (~base: float, ~exp: float) => float
-```
-
-Raises the given base to the given exponent. (Arguments and result are floats.) Returns `NaN` if the result would be imaginary. See [`Math.pow`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/pow) on MDN.
-
-```res example
-Js.Math.pow_float(~base=3.0, ~exp=4.0) == 81.0
-Js.Math.pow_float(~base=4.0, ~exp=-2.0) == 0.0625
-Js.Math.pow_float(~base=625.0, ~exp=0.5) == 25.0
-Js.Math.pow_float(~base=625.0, ~exp=-0.5) == 0.04
-Js.Float.isNaN(Js.Math.pow_float(~base=-2.0, ~exp=0.5)) == true
-```
-
-## random
-
-```res sig
-let random: unit => float
-```
-
-Returns a random number in the half-closed interval [0,1). See [`Math.random`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random) on MDN.
-
-## random_int
-
-```res sig
-let random_int: (int, int) => int
-```
-
-A call to `random_int(minVal, maxVal)` returns a random number in the half-closed interval [minVal, maxVal). See [`Math.random`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random) on MDN.
-
-## unsafe_round
-
-```res sig
-let unsafe_round: float => int
-```
-
-Rounds its argument to nearest integer. For numbers with a fractional portion of exactly 0.5, the argument is rounded to the next integer in the direction of positive infinity.  This function may return values not representable by `int`, whose range is -2147483648 to 2147483647. This is because, in JavaScript, there are only 64-bit floating point numbers, which can represent integers in the range ±(2<sup>53</sup>-1) exactly. See [`Math.round`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round) on MDN.
-
-```res example
-Js.Math.unsafe_round(3.7) == 4
-Js.Math.unsafe_round(-3.5) == -3
-Js.Math.unsafe_round(2_150_000_000_000.3) // out of range for int
-```
-
-## round
-
-```res sig
-let round: float => float
-```
-
-Rounds to nearest integral value (expressed as a float). See [`Math.round`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round) on MDN.
-
-
-## sign_int
-
-```res sig
-let sign_int: int => int
-```
-
-Returns the sign of its integer argument: -1 if negative, 0 if zero, 1 if positive. See [`Math.sign`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign) on MDN.
-
-## sign_float
-
-```res sig
-let sign_float: float => float
-```
-Returns the sign of its float argument: -1.0 if negative, 0.0 if zero, 1.0 if positive. See [`Math.sign`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign) on MDN.
-
-## sin
-
-```res sig
-let sin: float => float
-```
-
-Sine of argument, which must be specified in radians. See [`Math.sin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sin) on MDN.
-
-## sinh
-
-```res sig
-let sinh: float => float
-```
-
-Hyperbolic sine of argument, which must be specified in radians. See [`Math.sinh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sinh) on MDN.
-
-## sqrt
-
-```res sig
-let sqrt: float => float
-```
-
-Square root. If the argument is negative, this function returns `NaN`. See [`Math.sqrt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sqrt) on MDN.
-
-## tan
-
-```res sig
-let tan: float => float
-```
-
-Tangent of argument, which must be specified in radians. Returns `NaN` if the argument is positive infinity or negative infinity. See [`Math.cos`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cos) on MDN.
-
-## tanh
-
-```res sig
-let tanh: float => float
-```
-
-Hyperbolic tangent of argument, which must be specified in radians. See [`Math.tanh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/tanh) on MDN.
-
-## unsafe_trunc
-
-```res sig
-let unsafe_trunc: float => int
-```
-
-Truncates its argument; i.e., removes fractional digits. This function may return values not representable by `int`, whose range is -2147483648 to 2147483647. This is because, in JavaScript, there are only 64-bit floating point numbers, which can represent integers in the range ±(2<sup>53</sup>-1) exactly. See [`Math.trunc`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc) on MDN.
-
-## trunc
-
-```res sig
-let trunc: float => float
-```
-
-Truncates its argument; i.e., removes fractional digits. See [`Math.trunc`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc) on MDN.
diff --git a/pages/docs/manual/v10.0.0/api/js/null-undefined.mdx b/pages/docs/manual/v10.0.0/api/js/null-undefined.mdx
deleted file mode 100644
index 754524e19..000000000
--- a/pages/docs/manual/v10.0.0/api/js/null-undefined.mdx
+++ /dev/null
@@ -1,114 +0,0 @@
-# Null_undefined
-
-<Intro>
-
-Provide utilities around `Js.null_undefined`.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a> = Js.null_undefined<'a>
-```
-
-Local alias for `Js.null_undefined<'a>`.
-
-## return
-
-```res sig
-let return: 'a => t<'a>
-```
-
-Constructs a value of `Js.null_undefined<'a>` containing a value of `'a`.
-
-## test
-
-```res sig
-let test: t<'a> => bool
-```
-
-## isNullable
-
-```res sig
-let isNullable: t<'a> => bool
-```
-
-Returns `true` if the given value is null or undefined, `false` otherwise.
-
-## null
-
-```res sig
-let null: t<'a>
-```
-
-The null value of type `Js.null_undefined<'a>`.
-
-## undefined
-
-```res sig
-let undefined: t<'a>
-```
-
-The undefined value of type `Js.null_undefined<'a>`.
-
-## bind
-
-```res sig
-let bind: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-Maps the contained value using the given function.
-If `Js.null_undefined<'a>` contains a value, that value is unwrapped, mapped to a `'b` using the given function `a' => 'b`, then wrapped back up and returned as `Js.null_undefined<'b>`.
-
-```res example
-let maybeGreetWorld = (maybeGreeting: Js.null_undefined<string>) =>
-  Js.Null_undefined.bind(maybeGreeting, (. greeting) => greeting ++ " world!")
-```
-
-## iter
-
-```res sig
-let iter: (t<'a>, (. 'a) => unit) => unit
-```
-
-Iterates over the contained value with the given function.
-If `Js.null_undefined<'a>` contains a value, that value is unwrapped and applied to the given function.
-
-```res example
-let maybeSay = (maybeMessage: Js.null_undefined<string>) =>
-  Js.Null_undefined.iter(maybeMessage, (. message) => Js.log(message))
-```
-
-## fromOption
-
-```res sig
-let fromOption: option<'a> => t<'a>
-```
-
-Maps `option<'a>` to `Js.null_undefined<'a>`.
-`Some(a)` => `a`
-`None` => `undefined`
-
-## from_opt
-
-```res sig
-let from_opt: option<'a> => t<'a>
-```
-
-## toOption
-
-```res sig
-let toOption: t<'a> => option<'a>
-```
-
-Maps `Js.null_undefined<'a>` to `option<'a>`.
-`a` => `Some(a)`
-`undefined` => `None`
-`null` => `None`
-
-## to_opt
-
-```res sig
-let to_opt: t<'a> => option<'a>
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/null.mdx b/pages/docs/manual/v10.0.0/api/js/null.mdx
deleted file mode 100644
index 2ef17290c..000000000
--- a/pages/docs/manual/v10.0.0/api/js/null.mdx
+++ /dev/null
@@ -1,107 +0,0 @@
-# Null
-
-<Intro>
-
-Provide utilities around `null<'a>`.
-
-</Intro>
-
-```res prelude
-type t<'a> = Js.null<'a>
-```
-
-Local alias for `Js.null<'a>`.
-
-```res sig
-let return: 'a => t<'a>
-```
-
-Constructs a value of `Js.null<'a>` containing a value of `'a`.
-
-## test
-
-```res sig
-let test: t<'a> => bool
-```
-
-Returns `true` if the given value is empty (`null`), `false` otherwise.
-
-## empty
-
-```res sig
-let empty: t<'a>
-```
-
-The empty value, `null`.
-
-## getUnsafe
-
-```res sig
-let getUnsafe: t<'a> => 'a
-```
-
-## getExn
-
-```res sig
-let getExn: t<'a> => 'a
-```
-
-## bind
-
-```res sig
-let bind: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-Maps the contained value using the given function.
-If `Js.null<'a>` contains a value, that value is unwrapped, mapped to a `'b` using the given function `'a => 'b`, then wrapped back up and returned as `Js.null<'b>`.
-
-```res example
-let maybeGreetWorld = (maybeGreeting: Js.null<string>) =>
-  Js.Null.bind(maybeGreeting, (. greeting) => greeting ++ " world!")
-```
-
-## iter
-
-```res sig
-let iter: (t<'a>, (. 'a) => unit) => unit
-```
-
-Iterates over the contained value with the given function.
-If `Js.null<'a>` contains a value, that value is unwrapped and applied to the given function.
-
-```res example
-let maybeSay = (maybeMessage: Js.null<string>) =>
-  Js.Null.iter(maybeMessage, (. message) => Js.log(message))
-```
-
-## fromOption
-
-```res sig
-let fromOption: option<'a> => t<'a>
-```
-
-Maps `option<'a>` to `Js.null<'a>`.
-`Some(a)` => `a`
-`None` => `empty`
-
-## from_opt
-
-```res sig
-let from_opt: option<'a> => t<'a>
-```
-
-## toOption
-
-```res sig
-let toOption: t<'a> => option<'a>
-```
-
-Maps `Js.null<'a>` to `option<'a>`.
-`a` => `Some(a)`
-`empty` => `None`
-
-## to_opt
-
-```res sig
-let to_opt: t<'a> => option<'a>
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/nullable.mdx b/pages/docs/manual/v10.0.0/api/js/nullable.mdx
deleted file mode 100644
index 736dad78d..000000000
--- a/pages/docs/manual/v10.0.0/api/js/nullable.mdx
+++ /dev/null
@@ -1,114 +0,0 @@
-# Nullable
-
-<Intro>
-
-Provide utilities around `Js.null_undefined`.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a> = Js.null_undefined<'a>
-```
-
-Local alias for `Js.null_undefined<'a>`.
-
-## return
-
-```res sig
-let return: 'a => t<'a>
-```
-
-Constructs a value of `Js.null_undefined<'a>` containing a value of `'a`.
-
-## test
-
-```res sig
-let test: t<'a> => bool
-```
-
-## isNullable
-
-```res sig
-let isNullable: t<'a> => bool
-```
-
-Returns `true` if the given value is null or undefined, `false` otherwise.
-
-## null
-
-```res sig
-let null: t<'a>
-```
-
-The null value of type `Js.null_undefined<'a>`.
-
-## undefined
-
-```res sig
-let undefined: t<'a>
-```
-
-The undefined value of type `Js.null_undefined<'a>`.
-
-## bind
-
-```res sig
-let bind: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-Maps the contained value using the given function.
-If `Js.null_undefined<'a>` contains a value, that value is unwrapped, mapped to a `'b` using the given function `a' => 'b`, then wrapped back up and returned as `Js.null_undefined<'b>`.
-
-```res example
-let maybeGreetWorld = (maybeGreeting: Js.null_undefined<string>) =>
-  Js.Nullable.bind(maybeGreeting, (. greeting) => greeting ++ " world!")
-```
-
-## iter
-
-```res sig
-let iter: (t<'a>, (. 'a) => unit) => unit
-```
-
-Iterates over the contained value with the given function.
-If `Js.null_undefined<'a>` contains a value, that value is unwrapped and applied to the given function.
-
-```res example
-let maybeSay = (maybeMessage: Js.null_undefined<string>) =>
-  Js.Nullable.iter(maybeMessage, (. message) => Js.log(message))
-```
-
-## fromOption
-
-```res sig
-let fromOption: option<'a> => t<'a>
-```
-
-Maps `option<'a>` to `Js.null_undefined<'a>`.
-`Some(a)` => `a`
-`None` => `undefined`
-
-## from_opt
-
-```res sig
-let from_opt: option<'a> => t<'a>
-```
-
-## toOption
-
-```res sig
-let toOption: t<'a> => option<'a>
-```
-
-Maps `Js.null_undefined<'a>` to `option<'a>`.
-`a` => `Some(a)`
-`undefined` => `None`
-`null` => `None`
-
-## to_opt
-
-```res sig
-let to_opt: t<'a> => option<'a>
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/obj.mdx b/pages/docs/manual/v10.0.0/api/js/obj.mdx
deleted file mode 100644
index f8b082345..000000000
--- a/pages/docs/manual/v10.0.0/api/js/obj.mdx
+++ /dev/null
@@ -1,57 +0,0 @@
-# Obj
-
-<Intro>
-
-Provide utilities for Js.t.
-
-</Intro>
-
-## empty
-
-```res sig
-let empty: unit => {..}
-```
-
-`empty()` returns the empty object `{}`.
-
-## assign
-
-```res sig
-let assign: ({..}, {..}) => {..}
-```
-
-`assign(target, source)` copies properties from source to target.
-Properties in `target` will be overwritten by properties in `source` if they have the same key.
-Returns `target`.
-
-```res example
-/* Copy an object */
-
-let obj = {"a": 1}
-
-let copy = Js.Obj.assign(Js.Obj.empty(), obj)
-
-/* prints "{ a: 1 }" */
-Js.log(copy)
-
-/* Merge objects with same properties */
-
-let target = {"a": 1, "b": 1}
-let source = {"b": 2}
-
-let obj = Js.Obj.assign(target, source)
-
-/* prints "{ a: 1, b: 2 }" */
-Js.log(obj)
-
-/* prints "{ a: 1, b: 2 }", target is modified */
-Js.log(target)
-```
-
-## keys
-
-```res sig
-let keys: {..} => array<string>
-```
-
-`keys(obj)` returns an `array` of the keys of `obj`'s own enumerable properties.
diff --git a/pages/docs/manual/v10.0.0/api/js/option.mdx b/pages/docs/manual/v10.0.0/api/js/option.mdx
deleted file mode 100644
index ed23e8a64..000000000
--- a/pages/docs/manual/v10.0.0/api/js/option.mdx
+++ /dev/null
@@ -1,170 +0,0 @@
-# Option
-
-<Intro>
-
-Provide utilities for handling `option`.
-
-</Intro>
-
-## t
-
-```res sig
-type t<'a> = option<'a>
-```
-
-## some
-
-```res sig
-let some: 'a => option<'a>
-```
-Wraps the given value in `Some()`
-
-```res example
-Js.Option.some(1066) == Some(1066)
-```
-
-## isSome
-
-```res sig
-let isSome: option<'a> => bool
-```
-
-Returns `true` if the argument is `Some(value)`; `false` if the argument is `None`.
-
-## isSomeValue
-
-```res sig
-let isSomeValue: ((. 'a, 'a) => bool, 'a, option<'a>) => bool
-```
-
-The first argument to `isSomeValue` is an uncurried function `eq()` that takes two arguments and returns `true` if they are considered to be equal. It is used to compare a plain value `v1`(the second argument) with an `option` value. If the `option` value is `None`, `isSomeValue()` returns `false`; if the third argument is `Some(v2)`, `isSomeValue()` returns the result of calling `eq(v1, v2)`.
-
-```res example
-let clockEqual = (. a, b) => mod(a, 12) == mod(b, 12)
-Js.Option.isSomeValue(clockEqual, 3, Some(15)) == true
-Js.Option.isSomeValue(clockEqual, 3, Some(4)) == false
-Js.Option.isSomeValue(clockEqual, 3, None) == false
-```
-
-## isNone
-
-```res sig
-let isNone: option<'a> => bool
-```
-
-Returns `true` if the argument is `None`; `false` otherwise.
-
-## getExn
-
-```res sig
-let getExn: option<'a> => 'a
-```
-
-If the argument to `getExn()` is of the form `Some(value)`, returns `value`. If given `None`, it throws a `getExn` exception.
-
-## equal
-
-```res sig
-let equal: ((. 'a, 'b) => bool, option<'a>, option<'b>) => bool
-```
-
-The first argument to `equal` is an uncurried function `eq()` that takes two arguments and returns `true` if they are considered to be equal. The second and third arguments are `option` values.
-
-If the second and third arguments are of the form:
-
-* `Some(v1)` and `Some(v2)`: returns `eq(v1, v2)`
-* `Some(v1)` and `None`: returns `false`
-* `None` and `Some(v2)`: returns `false`
-* `None` and `None`: returns `true`
-
-```res example
-let clockEqual = (. a, b) => mod(a, 12) == mod(b, 12)
-Js.Option.equal(clockEqual, Some(3), Some(15)) == true
-Js.Option.equal(clockEqual, Some(3), Some(16)) == false
-Js.Option.equal(clockEqual, Some(3), None) == false
-Js.Option.equal(clockEqual, None, Some(15)) == false
-Js.Option.equal(clockEqual, None, None) == true
-```
-
-## andThen
-
-```res sig
-let andThen: ((. 'a) => option<'b>, option<'a>) => option<'b>
-```
-
-The first argument to `andThen()` is an uncurried function `f()` that takes a plain value and returns an `option` result. The second argument is an `option` value. If the second argument is `None`, the return value is `None`. If the second argument is `Some(v)`, the return value is `f(v)`.
-
-```res example
-let reciprocal = (. x) => x == 0 ? None : Some(1.0 /. Belt.Int.toFloat(x))
-Js.Option.andThen(reciprocal, Some(5)) == Some(0.2)
-Js.Option.andThen(reciprocal, Some(0)) == None
-Js.Option.andThen(reciprocal, None) == None
-```
-
-## map
-
-```res sig
-let map: ((. 'a) => 'b, option<'a>) => option<'b>
-```
-
-The first argument to `map()` is an uncurried function `f()` that takes a plain value and returns a plain result. The second argument is an `option` value. If it is of the form `Some(v)`, `map()` returns `Some(f(v))`; if it is `None`, the return value is `None`, and function `f()` is not called.
-
-```res example
-let square = (. x) => x * x
-Js.Option.map(square, Some(3)) == Some(9)
-Js.Option.map(square, None) == None
-```
-
-## getWithDefault
-
-```res sig
-let getWithDefault: ('a, option<'a>) => 'a
-```
-
-The first argument to `getWithDefault()` is a default value. If the second argument is of the form `Some(v)`, `getWithDefault()` returns `v`; if the second argument is `None`, the return value is the default value.
-
-```res example
-Js.Option.getWithDefault(1066, Some(15)) == 15
-Js.Option.getWithDefault(1066, None) == 1066
-```
-
-## default
-
-```res sig
-let default: ('a, option<'a>) => 'a
-```
-
-**See:** [getWithDefault](#getWithDefault)
-
-## filter
-
-```res sig
-let filter: ((. 'a) => bool, option<'a>) => option<'a>
-```
-
-The first argument to `filter()` is an uncurried function that takes a plain value and returns a boolean. The second argument is an `option` value.
-
-If the second argument is of the form `Some(v)` and `f(v)` is `true`,
-the return value is `Some(v)`. Otherwise, the return value is `None`.
-
-```res example
-let isEven = (. x) => mod(x, 2) == 0
-Js.Option.filter(isEven, Some(2)) == Some(2)
-Js.Option.filter(isEven, Some(3)) == None
-Js.Option.filter(isEven, None) == None
-```
-
-## firstSome
-
-```res sig
-let firstSome: (option<'a>, option<'a>) => option<'a>
-```
-
-The `firstSome()` function takes two `option` values; if the first is of the form `Some(v1)`, that is the return value. Otherwise, `firstSome()` returns the second value.
-
-```res example
-Js.Option.firstSome(Some("one"), Some("two")) == Some("one")
-Js.Option.firstSome(Some("one"), None) == Some("one")
-Js.Option.firstSome(None, Some("two")) == Some("two")
-Js.Option.firstSome(None, None) == None
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/promise.mdx b/pages/docs/manual/v10.0.0/api/js/promise.mdx
deleted file mode 100644
index 52d06c41d..000000000
--- a/pages/docs/manual/v10.0.0/api/js/promise.mdx
+++ /dev/null
@@ -1,91 +0,0 @@
-# Promise
-
-<Intro>
-
-Provide bindings to JS promise.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<+'a>
-```
-
-## error
-
-```res prelude
-type error
-```
-
-## make
-
-```res sig
-let make: ((~resolve: (. 'a) => unit, ~reject: (. exn) => unit) => unit) => t<'a>
-```
-
-## resolve
-
-```res sig
-let resolve: 'a => t<'a>
-```
-
-## reject
-
-```res sig
-let reject: exn => t<'a>
-```
-
-## all
-
-```res sig
-let all: array<t<'a>> => t<array<'a>>
-```
-
-## all2
-
-```res sig
-let all2: ((t<'a0>, t<'a1>)) => t<('a0, 'a1)>
-```
-
-## all3
-
-```res sig
-let all3: ((t<'a0>, t<'a1>, t<'a2>)) => t<('a0, 'a1, 'a2)>
-```
-
-## all4
-
-```res sig
-let all4: ((t<'a0>, t<'a1>, t<'a2>, t<'a3>)) => t<('a0, 'a1, 'a2, 'a3)>
-```
-
-## all5
-
-```res sig
-let all5: ((t<'a0>, t<'a1>, t<'a2>, t<'a3>, t<'a4>)) => t<('a0, 'a1, 'a2, 'a3, 'a4)>
-```
-
-## all6
-
-```res sig
-let all6: ((t<'a0>, t<'a1>, t<'a2>, t<'a3>, t<'a4>, t<'a5>)) => t<('a0, 'a1, 'a2, 'a3, 'a4, 'a5)>
-```
-
-## race
-
-```res sig
-let race: array<t<'a>> => t<'a>
-```
-
-## then_
-
-```res sig
-let then_: ('a => t<'b>, t<'a>) => t<'b>
-```
-
-## catch
-
-```res sig
-let catch: (error => t<'a>, t<'a>) => t<'a>
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/re.mdx b/pages/docs/manual/v10.0.0/api/js/re.mdx
deleted file mode 100644
index 665eb7a2d..000000000
--- a/pages/docs/manual/v10.0.0/api/js/re.mdx
+++ /dev/null
@@ -1,238 +0,0 @@
-# Re
-
-<Intro>
-
-Provide bindings to JS regular expressions (RegExp).
-
-</Intro>
-
-## t
-
-```res prelude
-type t
-```
-
-The RegExp object.
-
-## result
-
-```res prelude
-type result
-```
-
-The result of a executing a RegExp on a string.
-
-## captures
-
-```res sig
-let captures: result => array<Js.nullable<string>>
-```
-
-An `array` of the match and captures, the first is the full match and the remaining are the substring captures.
-
-## matches
-
-```res sig
-let matches: result => array<string>
-```
-
-Deprecated. Use captures instead.
-An `array` of the matches, the first is the full match and the remaining are the substring matches.
-
-## index
-
-```res sig
-let index: result => int
-```
-
-0-based index of the match in the input string.
-
-## input
-
-```res sig
-let input: result => string
-```
-
-The original input string.
-
-## fromString
-
-```res sig
-let fromString: string => t
-```
-
-Constructs a RegExp object (Js.Re.t) from a `string`.
-Regex literals `%re("/.../")` should generally be preferred, but `fromString` is useful when you need to dynamically construct a regex using strings, exactly like when you do so in JavaScript.
-
-```res example
-let firstReScriptFileExtension = (filename, content) => {
-  let result = Js.Re.fromString(filename ++ "\.(res|resi)")->Js.Re.exec_(content)
-  switch result {
-  | Some(r) => Js.Nullable.toOption(Js.Re.captures(r)[1])
-  | None => None
-  }
-}
-
-// outputs "res"
-firstReScriptFileExtension("School", "School.res School.resi Main.js School.bs.js")
-```
-
-## fromStringWithFlags
-
-```res sig
-let fromStringWithFlags: (string, ~flags: string) => t
-```
-
-Constructs a RegExp object (`Js.Re.t`) from a string with the given flags.
-See `Js.Re.fromString`.
-
-Valid flags:
-
-g global
-i ignore case
-m multiline
-u unicode (es2015)
-y sticky (es2015)
-
-## flags
-
-```res sig
-let flags: t => string
-```
-
-Returns the enabled flags as a string.
-
-## global
-
-```res sig
-let global: t => bool
-```
-
-Returns a `bool` indicating whether the global flag is set.
-
-## ignoreCase
-
-```res sig
-let ignoreCase: t => bool
-```
-
-Returns a `bool` indicating whether the ignoreCase flag is set.
-
-## lastIndex
-
-```res sig
-let lastIndex: t => int
-```
-
-Returns the index where the next match will start its search.
-This property will be modified when the RegExp object is used, if the global ("g") flag is set.
-
-```res example
-let re = %re("/ab*/g")
-let str = "abbcdefabh"
-
-let break = ref(false)
-while !break.contents {
-  switch Js.Re.exec_(re, str) {
-  | Some(result) => Js.Nullable.iter(Js.Re.captures(result)[0], (. match_) => {
-      let next = Belt.Int.toString(Js.Re.lastIndex(re))
-      Js.log("Found " ++ (match_ ++ (". Next match starts at " ++ next)))
-    })
-  | None => break := true
-  }
-}
-```
-
-## setLastIndex
-
-```res sig
-let setLastIndex: (t, int) => unit
-```
-
-Sets the index at which the next match will start its search from.
-
-## multiline
-
-```res sig
-let multiline: t => bool
-```
-
-Returns a `bool` indicating whether the multiline flag is set.
-
-## source
-
-```res sig
-let source: t => string
-```
-
-Returns the pattern as a `string`.
-
-## sticky
-
-```res sig
-let sticky: t => bool
-```
-
-Returns a `bool` indicating whether the sticky flag is set.
-
-## unicode
-
-```res sig
-let unicode: t => bool
-```
-
-Returns a `bool` indicating whether the unicode flag is set.
-
-## exec\_
-
-```res sig
-let exec_: (t, string) => option<result>
-```
-
-Executes a search on a given string using the given RegExp object.
-Returns `Some(Js.Re.result)` if a match is found, `None` otherwise.
-
-```res example
-/* Match "quick brown" followed by "jumps", ignoring characters in between
- * Remember "brown" and "jumps"
- * Ignore case
- */
-
-let re = %re("/quick\s(brown).+?(jumps)/ig")
-let result = Js.Re.exec_(re, "The Quick Brown Fox Jumps Over The Lazy Dog")
-```
-
-## exec
-
-```res sig
-let exec: (string, t) => option<result>
-```
-
-Deprecated. please use `Js.Re.exec_` instead.
-
-## test\_
-
-```res sig
-let test_: (t, string) => bool
-```
-
-Tests whether the given RegExp object will match a given `string`.
-Returns true if a match is found, false otherwise.
-
-```res example
-/* A simple implementation of Js.String.startsWith */
-
-let str = "hello world!"
-
-let startsWith = (target, substring) => Js.Re.fromString("^" ++ substring)->Js.Re.test_(target)
-
-Js.log(str->startsWith("hello")) /* prints "true" */
-```
-
-## test
-
-```res sig
-let test: (string, t) => bool
-```
-
-Deprecated. please use `Js.Re.test_` instead.
diff --git a/pages/docs/manual/v10.0.0/api/js/result.mdx b/pages/docs/manual/v10.0.0/api/js/result.mdx
deleted file mode 100644
index b9a747f95..000000000
--- a/pages/docs/manual/v10.0.0/api/js/result.mdx
+++ /dev/null
@@ -1,15 +0,0 @@
-# Result
-
-<Intro>
-
-Define the interface for result.
-
-</Intro>
-
-## t
-
-```res sig
-type t<'good, 'bad> =
-  | Ok('good)
-  | Error('bad)
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/string-2.mdx b/pages/docs/manual/v10.0.0/api/js/string-2.mdx
deleted file mode 100644
index b87aac35c..000000000
--- a/pages/docs/manual/v10.0.0/api/js/string-2.mdx
+++ /dev/null
@@ -1,794 +0,0 @@
-# String2
-
-<Intro>
-
-Provide bindings to JS string. Optimized for pipe-first.
-
-</Intro>
-
-## t
-
-```res prelude
-type t = string
-```
-
-## make
-
-```res sig
-let make: 'a => t
-```
-
-`make(value)` converts the given value to a `string`.
-
-```res example
-Js.String2.make(3.5) == "3.5"
-Js.String2.make([1, 2, 3]) == "1,2,3"
-```
-
-## fromCharCode
-
-```res sig
-let fromCharCode: int => t
-```
-
-`fromCharCode(n)` creates a `string` containing the character corresponding to that number; `n` ranges from 0 to 65535.
-If out of range, the lower 16 bits of the value are used. Thus, `fromCharCode(0x1F63A)` gives the same result as `fromCharCode(0xF63A)`. See [`String.fromCharCode`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode) on MDN.
-
-```res example
-Js.String2.fromCharCode(65) == "A"
-Js.String2.fromCharCode(0x3c8) == `ψ`
-Js.String2.fromCharCode(0xd55c) == `한`
-Js.String2.fromCharCode(-64568) == `ψ`
-```
-
-## fromCharCodeMany
-
-```res sig
-let fromCharCodeMany: array<int> => t
-```
-
-`fromCharCodeMany([n1, n2, n3])` creates a `string` from the characters corresponding to the given numbers, using the same rules as `fromCharCode`. See [`String.fromCharCode`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode) on MDN.
-
-## fromCodePoint
-
-```res sig
-let fromCodePoint: int => t
-```
-
-`fromCodePoint(n)` creates a `string` containing the character corresponding to that numeric code point.
-If the number is not a valid code point, it raises `RangeError`.
-Thus, `fromCodePoint(0x1F63A)` will produce a correct value, unlike `fromCharCode(0x1F63A)`, and `fromCodePoint(-5)` will raise a `RangeError`. See [`String.fromCodePoint`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint) on MDN.
-
-```res example
-Js.String2.fromCodePoint(65) == "A"
-Js.String2.fromCodePoint(0x3c8) == `ψ`
-Js.String2.fromCodePoint(0xd55c) == `한`
-Js.String2.fromCodePoint(0x1f63a) == `😺`
-```
-
-## fromCodePointMany
-
-```res sig
-let fromCodePointMany: array<int> => t
-```
-
-`fromCodePointMany([n1, n2, n3])` creates a `string` from the characters corresponding to the given code point numbers, using the same rules as `fromCodePoint`. See [`String.fromCodePoint`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint) on MDN.
-
-```res example
-Js.String2.fromCodePointMany([0xd55c, 0xae00, 0x1f63a]) == `한글😺`
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-`length(s)` returns the length of the given `string`. See [`String.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length) on MDN.
-
-```res example
-Js.String2.length("abcd") == 4
-```
-
-## get
-
-```res sig
-let get: (t, int) => t
-```
-
-`get(s, n)` returns as a `string` the character at the given index number.
-If `n` is out of range, this function returns `undefined`, so at some point this function may be modified to return `option<string>`.
-
-```res example
-Js.String2.get("Reason", 0) == "R"
-Js.String2.get("Reason", 4) == "o"
-Js.String2.get(`Rẽasöń`, 5) == `ń`
-```
-
-## charAt
-
-```res sig
-let charAt: (t, int) => t
-```
-
-`charAt(s, n)` gets the character at index `n` within string `s`.
-If `n` is negative or greater than the length of `s`, it returns the empty string.
-If the string contains characters outside the range \u0000-\uffff, it will return the first 16-bit value at that position in the string. See [`String.charAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charAt) on MDN.
-
-```res example
-Js.String2.charAt("Reason", 0) == "R"
-Js.String2.charAt("Reason", 12) == ""
-Js.String2.charAt(`Rẽasöń`, 5) == `ń`
-```
-
-## charCodeAt
-
-```res sig
-let charCodeAt: (t, int) => float
-```
-
-`charCodeAt(s, n)` returns the character code at position `n` in string `s`; the result is in the range 0-65535, unlke `codePointAt`, so it will not work correctly for characters with code points greater than or equal to 0x10000.
-The return type is `float` because this function returns NaN if `n` is less than zero or greater than the length of the string. See [`String.charCodeAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charCodeAt) on MDN.
-
-```res example
-Js.String2.charCodeAt(`😺`, 0) == 0xd83d->Belt.Int.toFloat
-Js.String2.codePointAt(`😺`, 0) == Some(0x1f63a)
-```
-
-## codePointAt
-
-```res sig
-let codePointAt: (t, int) => option<int>
-```
-
-`codePointAt(s, n)` returns the code point at position `n` within string `s` as a `Some(value)`.
-The return value handles code points greater than or equal to 0x10000.
-If there is no code point at the given position, the function returns `None`. See [`String.codePointAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/codePointAt) on MDN.
-
-```res example
-Js.String2.codePointAt(`¿😺?`, 1) == Some(0x1f63a)
-Js.String2.codePointAt("abc", 5) == None
-```
-
-## concat
-
-```res sig
-let concat: (t, t) => t
-```
-
-`concat(original, append)` returns a new `string` with `append` added after `original`. See [`String.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat) on MDN.
-
-```res example
-Js.String2.concat("cow", "bell") == "cowbell"
-```
-
-## concatMany
-
-```res sig
-let concatMany: (t, array<t>) => t
-```
-
-`concat(original, arr)` returns a new `string` consisting of each item of an array of strings added to the `original` string. See [`String.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat) on MDN.
-
-```res example
-Js.String2.concatMany("1st", ["2nd", "3rd", "4th"]) == "1st2nd3rd4th"
-```
-
-## endsWith
-
-```res sig
-let endsWith: (t, t) => bool
-```
-
-ES2015: `endsWith(str, substr)` returns `true` if the `str` ends with `substr`, `false` otherwise. See [`String.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith) on MDN.
-
-```res example
-Js.String2.endsWith("BuckleScript", "Script") == true
-Js.String2.endsWith("BuckleShoes", "Script") == false
-```
-
-## endsWithFrom
-
-```res sig
-let endsWithFrom: (t, t, int) => bool
-```
-
-`endsWithFrom(str, ending, len)` returns `true` if the first len characters of `str` end with `ending`, `false` otherwise.
-If `len` is greater than or equal to the length of `str`, then it works like `endsWith`. (Honestly, this should have been named endsWithAt, but oh well.) See [`String.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith) on MDN.
-
-```res example
-Js.String2.endsWithFrom("abcd", "cd", 4) == true
-Js.String2.endsWithFrom("abcde", "cd", 3) == false
-Js.String2.endsWithFrom("abcde", "cde", 99) == true
-Js.String2.endsWithFrom("example.dat", "ple", 7) == true
-```
-
-## includes
-
-```res sig
-let includes: (t, t) => bool
-```
-
-ES2015: `includes(str, searchValue)` returns `true` if `searchValue` is found anywhere within `str`, false otherwise. See [`String.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes) on MDN.
-
-```res example
-Js.String2.includes("programmer", "gram") == true
-Js.String2.includes("programmer", "er") == true
-Js.String2.includes("programmer", "pro") == true
-Js.String2.includes("programmer.dat", "xyz") == false
-```
-
-## includesFrom
-
-```res sig
-let includesFrom: (t, t, int) => bool
-```
-
-ES2015: `includes(str, searchValue start)` returns `true` if `searchValue` is found anywhere within `str` starting at character number `start` (where 0 is the first character), `false` otherwise. See [`String.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes) on MDN.
-
-```res example
-Js.String2.includesFrom("programmer", "gram", 1) == true
-Js.String2.includesFrom("programmer", "gram", 4) == false
-Js.String2.includesFrom(`대한민국`, `한`, 1) == true
-```
-
-## indexOf
-
-```res sig
-let indexOf: (t, t) => int
-```
-
-ES2015: `indexOf(str, searchValue)` returns the position at which `searchValue` was first found within `str`, or -1 if `searchValue` is not in `str`. See [`String.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf) on MDN.
-
-```res example
-Js.String2.indexOf("bookseller", "ok") == 2
-Js.String2.indexOf("bookseller", "sell") == 4
-Js.String2.indexOf("beekeeper", "ee") == 1
-Js.String2.indexOf("bookseller", "xyz") == -1
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (t, t, int) => int
-```
-`indexOfFrom(str, searchValue, start)` returns the position at which `searchValue` was found within `str` starting at character position `start`, or -1 if `searchValue` is not found in that portion of `str`.
-The return value is relative to the beginning of the string, no matter where the search started from. See [`String.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf) on MDN.
-
-```res example
-Js.String2.indexOfFrom("bookseller", "ok", 1) == 2
-Js.String2.indexOfFrom("bookseller", "sell", 2) == 4
-Js.String2.indexOfFrom("bookseller", "sell", 5) == -1
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (t, t) => int
-```
-
-`lastIndexOf(str, searchValue)` returns the position of the last occurrence of `searchValue` within `str`, searching backwards from the end of the string.
-Returns -1 if `searchValue` is not in `str`. The return value is always relative to the beginning of the string. See [`String.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf) on MDN.
-
-```res example
-Js.String2.lastIndexOf("bookseller", "ok") == 2
-Js.String2.lastIndexOf("beekeeper", "ee") == 4
-Js.String2.lastIndexOf("abcdefg", "xyz") == -1
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (t, t, int) => int
-```
-
-`lastIndexOfFrom(str, searchValue, start)` returns the position of the last occurrence of `searchValue` within `str`, searching backwards from the given start position.
-Returns -1 if `searchValue` is not in `str`. The return value is always relative to the beginning of the string. See [`String.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf) on MDN.
-
-```res example
-Js.String2.lastIndexOfFrom("bookseller", "ok", 6) == 2
-Js.String2.lastIndexOfFrom("beekeeper", "ee", 8) == 4
-Js.String2.lastIndexOfFrom("beekeeper", "ee", 3) == 1
-Js.String2.lastIndexOfFrom("abcdefg", "xyz", 4) == -1
-```
-
-## localeCompare
-
-```res sig
-let localeCompare: (t, t) => float
-```
-
-`localeCompare(reference, comparison)` returns
-- a negative value if reference comes before comparison in sort order
-- zero if reference and comparison have the same sort order
-- a positive value if reference comes after comparison in sort order
-
-See [`String.localeCompare`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare) on MDN.
-
-```res example
-Js.String2.localeCompare("zebra", "ant") > 0.0
-Js.String2.localeCompare("ant", "zebra") < 0.0
-Js.String2.localeCompare("cat", "cat") == 0.0
-Js.String2.localeCompare("CAT", "cat") > 0.0
-```
-
-## match
-
-```res sig
-let match_: (t, Js_re.t) => option<array<option<t>>>
-```
-
-`match(str, regexp)` matches a `string` against the given `regexp`. If there is no match, it returns `None`. For regular expressions without the g modifier, if there is a match, the return value is `Some(array)` where the array contains:
-- The entire matched string
-- Any capture groups if the regexp had parentheses
-
-For regular expressions with the g modifier, a matched expression returns `Some(array)` with all the matched substrings and no capture groups. Javscript String.prototype.match can return `undefined`  for optional capture groups that are not found, thus the element of the returned array is typed `option<t>`. See [`String.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match) on MDN.
-
-```res example
-Js.String2.match_("The better bats", %re("/b[aeiou]t/")) == Some([Some("bet")])
-Js.String2.match_("The better bats", %re("/b[aeiou]t/g")) == Some([Some("bet"), Some("bat")])
-Js.String2.match_("Today is 2018-04-05.", %re("/(\d+)-(\d+)-(\d+)/")) ==
-  Some([Some("2018-04-05"), Some("2018"), Some("04"), Some("05")])
-Js.String2.match_("The large container.", %re("/b[aeiou]g/")) == None
-```
-
-## normalize
-
-```res sig
-let normalize: t => t
-```
-
-`normalize(str)` returns the normalized Unicode string using Normalization Form Canonical (NFC) Composition.
-Consider the character ã, which can be represented as the single codepoint \u00e3 or the combination of a lower case letter A \u0061 and a combining tilde \u0303.
-Normalization ensures that both can be stored in an equivalent binary representation. See [`String.normalize`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize) on MDN. See also [Unicode technical report #15](https://unicode.org/reports/tr15/) for details.
-
-## normalizeByForm
-
-```res sig
-let normalizeByForm: (t, t) => t
-```
-
-ES2015: `normalize(str, form)` returns the normalized Unicode string using the specified form of normalization, which may be one of:
-- "NFC" — Normalization Form Canonical Composition.
-- "NFD" — Normalization Form Canonical Decomposition.
-- "NFKC" — Normalization Form Compatibility Composition.
-- "NFKD" — Normalization Form Compatibility Decomposition.
-
-See [`String.normalize`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize) on MDN. See also [Unicode technical report #15](https://unicode.org/reports/tr15/) for details..
-
-## repeat
-
-```res sig
-let repeat: (t, int) => t
-```
-
-`repeat(str, n)` returns a `string` that consists of `n` repetitions of `str`. Raises `RangeError` if `n` is negative. See [`String.repeat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat) on MDN.
-
-```res example
-Js.String2.repeat("ha", 3) == "hahaha"
-Js.String2.repeat("empty", 0) == ""
-```
-
-## replace
-
-```res sig
-let replace: (t, t, t) => t
-```
-
-ES2015: `replace(str, substr, newSubstr)` returns a new `string` which is identical to `str` except with the first matching instance of `substr` replaced by `newSubstr`.
-`substr` is treated as a verbatim string to match, not a regular expression. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-Js.String2.replace("old string", "old", "new") == "new string"
-Js.String2.replace("the cat and the dog", "the", "this") == "this cat and the dog"
-```
-
-## replaceByRe
-
-```res sig
-let replaceByRe: (t, Js_re.t, t) => t
-```
-
-`replaceByRe(str, regex, replacement)` returns a new `string` where occurrences matching regex have been replaced by `replacement`. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-Js.String2.replaceByRe("vowels be gone", %re("/[aeiou]/g"), "x") == "vxwxls bx gxnx"
-Js.String2.replaceByRe("Juan Fulano", %re("/(\w+) (\w+)/"), "$2, $1") == "Fulano, Juan"
-```
-
-## unsafeReplaceBy0
-
-```res sig
-let unsafeReplaceBy0: (t, Js_re.t, (t, int, t) => t) => t
-```
-
-Returns a new `string` with some or all matches of a pattern with no capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-let str = "beautiful vowels"
-let re = %re("/[aeiou]/g")
-let matchFn = (matchPart, _offset, _wholeString) => Js.String2.toUpperCase(matchPart)
-
-Js.String2.unsafeReplaceBy0(str, re, matchFn) == "bEAUtIfUl vOwEls"
-```
-
-## unsafeReplaceBy1
-
-```res sig
-let unsafeReplaceBy1: (t, Js_re.t, (t, t, int, t) => t) => t
-```
-
-Returns a new `string` with some or all matches of a pattern with one set of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured string, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-let str = "Jony is 40"
-let re = %re("/(Jony is )\d+/g")
-let matchFn = (_match, part1, _offset, _wholeString) => {
-  part1 ++ "41"
-}
-
-Js.String2.unsafeReplaceBy1(str, re, matchFn) == "Jony is 41"
-```
-
-## unsafeReplaceBy2
-
-```res sig
-let unsafeReplaceBy2: (t, Js_re.t, (t, t, t, int, t) => t) => t
-```
-
-Returns a new `string` with some or all matches of a pattern with two sets of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured strings, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-let str = "7 times 6"
-let re = %re("/(\d+) times (\d+)/")
-let matchFn = (_match, p1, p2, _offset, _wholeString) => {
-  switch (Belt.Int.fromString(p1), Belt.Int.fromString(p2)) {
-  | (Some(x), Some(y)) => Belt.Int.toString(x * y)
-  | _ => "???"
-  }
-}
-
-Js.String2.unsafeReplaceBy2(str, re, matchFn) == "42"
-```
-
-## unsafeReplaceBy3
-
-```res sig
-let unsafeReplaceBy3: (t, Js_re.t, (t, t, t, t, int, t) => t) => t
-```
-
-Returns a new `string` with some or all matches of a pattern with three sets of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured strings, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-## search
-
-```res sig
-let search: (t, Js_re.t) => int
-```
-
-`search(str, regexp)` returns the starting position of the first match of `regexp` in the given `str`, or -1 if there is no match. See [`String.search`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/search) on MDN.
-
-```res example
-Js.String2.search("testing 1 2 3", %re("/\d+/")) == 8
-Js.String2.search("no numbers", %re("/\d+/")) == -1
-```
-
-## slice
-
-```res sig
-let slice: (t, ~from: int, ~to_: int) => t
-```
-
-`slice(str, from:n1, to_:n2)` returns the substring of `str` starting at character `n1` up to but not including `n2`.
-- If either `n1` or `n2` is negative, then it is evaluated as `length(str - n1)` or `length(str - n2)`.
-- If `n2` is greater than the length of `str`, then it is treated as `length(str)`.
-- If `n1` is greater than `n2`, slice returns the empty string.
-
-See [`String.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice) on MDN.
-
-```res example
-Js.String2.slice("abcdefg", ~from=2, ~to_=5) == "cde"
-Js.String2.slice("abcdefg", ~from=2, ~to_=9) == "cdefg"
-Js.String2.slice("abcdefg", ~from=-4, ~to_=-2) == "de"
-Js.String2.slice("abcdefg", ~from=5, ~to_=1) == ""
-```
-
-## sliceToEnd
-
-```res sig
-let sliceToEnd: (t, ~from: int) => t
-```
-
-`sliceToEnd(str, from:n)` returns the substring of `str` starting at character `n` to the end of the string.
-- If `n` is negative, then it is evaluated as `length(str - n)`.
-- If `n` is greater than the length of `str`, then sliceToEnd returns the empty string.
-
-See [`String.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice) on MDN.
-
-```res example
-Js.String2.sliceToEnd("abcdefg", ~from=4) == "efg"
-Js.String2.sliceToEnd("abcdefg", ~from=-2) == "fg"
-Js.String2.sliceToEnd("abcdefg", ~from=7) == ""
-```
-
-## split
-
-```res sig
-let split: (t, t) => array<t>
-```
-
-`split(str, delimiter)` splits the given `str` at every occurrence of `delimiter` and returns an array of the resulting substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```res example
-Js.String2.split("2018-01-02", "-") == ["2018", "01", "02"]
-Js.String2.split("a,b,,c", ",") == ["a", "b", "", "c"]
-Js.String2.split("good::bad as great::awful", "::") == ["good", "bad as great", "awful"]
-Js.String2.split("has-no-delimiter", ";") == ["has-no-delimiter"]
-```
-
-## splitAtMost
-
-```res sig
-let splitAtMost: (t, t, ~limit: int) => array<t>
-```
-
-`splitAtMost(str, delimiter, ~limit:n)` splits the given `str` at every occurrence of `delimiter` and returns an array of the first `n` resulting substrings.
-If `n` is negative or greater than the number of substrings, the array will contain all the substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```res example
-Js.String2.splitAtMost("ant/bee/cat/dog/elk", "/", ~limit=3) == ["ant", "bee", "cat"]
-Js.String2.splitAtMost("ant/bee/cat/dog/elk", "/", ~limit=0) == []
-Js.String2.splitAtMost("ant/bee/cat/dog/elk", "/", ~limit=9) == [
-    "ant",
-    "bee",
-    "cat",
-    "dog",
-    "elk",
-  ]
-```
-
-## splitByRe
-
-```res sig
-let splitByRe: (t, Js_re.t) => array<option<t>>
-```
-
-`splitByRe(str, regex)` splits the given `str` at every occurrence of `regex` and returns an array of the resulting substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```res example
-Js.String2.splitByRe("art; bed , cog ;dad", %re("/\s*[,;]\s*/")) == [
-    Some("art"),
-    Some("bed"),
-    Some("cog"),
-    Some("dad"),
-  ]
-```
-
-## splitByReAtMost
-
-```res sig
-let splitByReAtMost: (t, Js_re.t, ~limit: int) => array<option<t>>
-```
-
-`splitByReAtMost(str, regex, ~limit:n)` splits the given `str` at every occurrence of `regex` and returns an array of the first `n` resulting substrings.
-If `n` is negative or greater than the number of substrings, the array will contain all the substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```res example
-Js.String2.splitByReAtMost("one: two: three: four", %re("/\s*:\s*/"), ~limit=3) == [
-    Some("one"),
-    Some("two"),
-    Some("three"),
-  ]
-
-Js.String2.splitByReAtMost("one: two: three: four", %re("/\s*:\s*/"), ~limit=0) == []
-
-Js.String2.splitByReAtMost("one: two: three: four", %re("/\s*:\s*/"), ~limit=8) == [
-    Some("one"),
-    Some("two"),
-    Some("three"),
-    Some("four"),
-  ]
-```
-
-## startsWith
-
-```res sig
-let startsWith: (t, t) => bool
-```
-
-ES2015: `startsWith(str, substr)` returns `true` if the `str` starts with `substr`, `false` otherwise. See [`String.startsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith) on MDN.
-
-```res example
-Js.String2.startsWith("BuckleScript", "Buckle") == true
-Js.String2.startsWith("BuckleScript", "") == true
-Js.String2.startsWith("JavaScript", "Buckle") == false
-```
-
-## startsWithFrom
-
-```res sig
-let startsWithFrom: (t, t, int) => bool
-```
-
-ES2015: `startsWithFrom(str, substr, n)` returns `true` if the `str` starts with `substr` starting at position `n`, false otherwise.
-If `n` is negative, the search starts at the beginning of `str`. See [`String.startsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith) on MDN.
-
-```res example
-Js.String2.startsWithFrom("BuckleScript", "kle", 3) == true
-Js.String2.startsWithFrom("BuckleScript", "", 3) == true
-Js.String2.startsWithFrom("JavaScript", "Buckle", 2) == false
-```
-
-## substr
-
-```res sig
-let substr: (t, ~from: int) => t
-```
-
-`substr(str, ~from:n)` returns the substring of `str` from position `n` to the end of the string.
-- If `n` is less than zero, the starting position is the length of `str - n`.
-- If `n` is greater than or equal to the length of `str`, returns the empty string.
-
-JavaScript’s `String.substr()` is a legacy function. When possible, use `substring()` instead. See [`String.substr`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr) on MDN.
-
-```res example
-Js.String2.substr("abcdefghij", ~from=3) == "defghij"
-Js.String2.substr("abcdefghij", ~from=-3) == "hij"
-Js.String2.substr("abcdefghij", ~from=12) == ""
-```
-
-## substrAtMost
-
-```res sig
-let substrAtMost: (t, ~from: int, ~length: int) => t
-```
-
-`substrAtMost(str, ~from: pos, ~length: n)` returns the substring of `str` of length `n` starting at position `pos`.
-- If `pos` is less than zero, the starting position is the length of `str - pos`.
-- If `pos` is greater than or equal to the length of `str`, returns the empty string.
-- If `n` is less than or equal to zero, returns the empty string.
-
-JavaScript’s `String.substr()` is a legacy function. When possible, use `substring()` instead. See [`String.substr`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr) on MDN.
-
-```res example
-Js.String2.substrAtMost("abcdefghij", ~from=3, ~length=4) == "defg"
-Js.String2.substrAtMost("abcdefghij", ~from=-3, ~length=4) == "hij"
-Js.String2.substrAtMost("abcdefghij", ~from=12, ~length=2) == ""
-```
-
-## substring
-
-```res sig
-let substring: (t, ~from: int, ~to_: int) => t
-```
-
-`substring(str, ~from: start, ~to_: finish)` returns characters `start` up to but not including finish from `str`.
-- If `start` is less than zero, it is treated as zero.
-- If `finish` is zero or negative, the empty string is returned.
-- If `start` is greater than `finish`, the `start` and `finish` points are swapped.
-
-See [`String.substring`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring) on MDN.
-
-```res example
-Js.String2.substring("playground", ~from=3, ~to_=6) == "ygr"
-Js.String2.substring("playground", ~from=6, ~to_=3) == "ygr"
-Js.String2.substring("playground", ~from=4, ~to_=12) == "ground"
-```
-
-## substringToEnd
-
-```res sig
-let substringToEnd: (t, ~from: int) => t
-```
-
-`substringToEnd(str, ~from: start)` returns the substring of `str` from position `start` to the end.
-- If `start` is less than or equal to zero, the entire string is returned.
-- If `start` is greater than or equal to the length of `str`, the empty string is returned.
-
-See [`String.substring`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring) on MDN.
-
-```res example
-Js.String2.substringToEnd("playground", ~from=4) == "ground"
-Js.String2.substringToEnd("playground", ~from=-3) == "playground"
-Js.String2.substringToEnd("playground", ~from=12) == ""
-```
-
-## toLowerCase
-
-```res sig
-let toLowerCase: t => t
-```
-
-`toLowerCase(str)` converts `str` to lower case using the locale-insensitive case mappings in the Unicode Character Database.
-Notice that the conversion can give different results depending upon context, for example with the Greek letter sigma, which has two different lower case forms; one when it is the last character in a string and another when it is not. See [`String.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase) on MDN.
-
-```res example
-Js.String2.toLowerCase("ABC") == "abc"
-Js.String2.toLowerCase(`ΣΠ`) == `σπ`
-Js.String2.toLowerCase(`ΠΣ`) == `πς`
-```
-
-## toLocaleLowerCase
-
-```res sig
-let toLocaleLowerCase: t => t
-```
-
-`toLocaleLowerCase(str)` converts `str` to lower case using the current locale. See [`String.toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase) on MDN.
-
-## toUpperCase
-
-```res sig
-let toUpperCase: t => t
-```
-
-`toUpperCase(str)` converts `str` to upper case using the locale-insensitive case mappings in the Unicode Character Database.
-Notice that the conversion can expand the number of letters in the result; for example the German ß capitalizes to two Ses in a row. See [`String.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) on MDN.
-
-```res example
-Js.String2.toUpperCase("abc") == "ABC"
-Js.String2.toUpperCase(`Straße`) == `STRASSE`
-Js.String2.toUpperCase(`πς`) == `ΠΣ`
-```
-
-## toLocaleUpperCase
-
-```res sig
-let toLocaleUpperCase: t => t
-```
-
-`toLocaleUpperCase(str)` converts `str` to upper case using the current locale. See [`String.to:LocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase) on MDN.
-
-## trim
-
-```res sig
-let trim: t => t
-```
-
-`trim(str)` returns a string that is `str` with whitespace stripped from both ends. Internal whitespace is not removed. See [`String.trim`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trim) on MDN.
-
-```res example
-Js.String2.trim("   abc def   ") == "abc def"
-Js.String2.trim("\n\r\t abc def \n\n\t\r ") == "abc def"
-```
-
-## anchor
-
-```res sig
-let anchor: (t, t) => t
-```
-
-`anchor(anchorText, anchorName)` creates a string with an HTML `<a>` element with name attribute of `anchorName` and `anchorText` as its content. Please do not use this method, as it has been removed from the relevant web standards. See [`String.anchor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/anchor) on MDN.
-
-```res example
-Js.String2.anchor("Page One", "page1") == "<a name=\"page1\">Page One</a>"
-```
-
-## link
-
-```res sig
-let link: (t, t) => t
-```
-
-ES2015: `link(linkText, urlText)` creates a string with an HTML `<a>` element with href attribute of `urlText` and `linkText` as its content. Please do not use this method, as it has been removed from the relevant web standards. See [`String.link`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/link) on MDN.
-
-```res example
-Js.String2.link("Go to page two", "page2.html") == "<a href=\"page2.html\">Go to page two</a>"
-```
-
-## castToArrayLike
-
-```res sig
-let castToArrayLike: t => Js_array2.array_like<t>
-```
-
-Casts its argument to an `array_like` entity that can be processed by functions such as `Js.Array2.fromMap()`
-
-```res example
-let s = "abcde"
-let arr = Js.Array2.fromMap(Js.String2.castToArrayLike(s), x => x)
-arr == ["a", "b", "c", "d", "e"]
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/string.mdx b/pages/docs/manual/v10.0.0/api/js/string.mdx
deleted file mode 100644
index a41a65dde..000000000
--- a/pages/docs/manual/v10.0.0/api/js/string.mdx
+++ /dev/null
@@ -1,804 +0,0 @@
-# String
-
-<Intro>
-
-Provide bindings to JS string. Optimized for pipe-last.
-
-</Intro>
-
-## t
-
-```res prelude
-type t = string
-```
-
-## make
-
-```res sig
-let make: 'a => t
-```
-
-`make(value)` converts the given value to a `string`.
-
-```res example
-Js.String2.make(3.5) == "3.5"
-Js.String2.make([1, 2, 3]) == "1,2,3"
-```
-
-## fromCharCode
-
-```res sig
-let fromCharCode: int => t
-```
-
-`fromCharCode(n)` creates a `string` containing the character corresponding to that number; `n` ranges from 0 to 65535.
-If out of range, the lower 16 bits of the value are used. Thus, `fromCharCode(0x1F63A)` gives the same result as `fromCharCode(0xF63A)`. See [`String.fromCharCode`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode) on MDN.
-
-```res example
-Js.String2.fromCharCode(65) == "A"
-Js.String2.fromCharCode(0x3c8) == `ψ`
-Js.String2.fromCharCode(0xd55c) == `한`
-Js.String2.fromCharCode(-64568) == `ψ`
-```
-
-## fromCharCodeMany
-
-```res sig
-let fromCharCodeMany: array<int> => t
-```
-
-`fromCharCodeMany([n1, n2, n3])` creates a `string` from the characters corresponding to the given numbers, using the same rules as `fromCharCode`. See [`String.fromCharCode`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode) on MDN.
-
-## fromCodePoint
-
-```res sig
-let fromCodePoint: int => t
-```
-
-`fromCodePoint(n)` creates a `string` containing the character corresponding to that numeric code point.
-If the number is not a valid code point, it raises `RangeError`.
-Thus, `fromCodePoint(0x1F63A)` will produce a correct value, unlike `fromCharCode(0x1F63A)`, and `fromCodePoint(-5)` will raise a `RangeError`. See [`String.fromCodePoint`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint) on MDN.
-
-```res example
-Js.String2.fromCodePoint(65) == "A"
-Js.String2.fromCodePoint(0x3c8) == `ψ`
-Js.String2.fromCodePoint(0xd55c) == `한`
-Js.String2.fromCodePoint(0x1f63a) == `😺`
-```
-
-## fromCodePointMany
-
-```res sig
-let fromCodePointMany: array<int> => t
-```
-
-`fromCodePointMany([n1, n2, n3])` creates a `string` from the characters corresponding to the given code point numbers, using the same rules as `fromCodePoint`. See [`String.fromCodePoint`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint) on MDN.
-
-```res example
-Js.String2.fromCodePointMany([0xd55c, 0xae00, 0x1f63a]) == `한글😺`
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-`length(s)` returns the length of the given `string`. See [`String.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length) on MDN.
-
-```res example
-Js.String2.length("abcd") == 4
-```
-
-## get
-
-```res sig
-let get: (t, int) => t
-```
-
-`get(s, n)` returns as a `string` the character at the given index number.
-If `n` is out of range, this function returns `undefined`, so at some point this function may be modified to return `option<string>`.
-
-```res example
-Js.String2.get("Reason", 0) == "R"
-Js.String2.get("Reason", 4) == "o"
-Js.String2.get(`Rẽasöń`, 5) == `ń`
-```
-
-## charAt
-
-```res sig
-let charAt: (int, t) => t
-```
-
-`charAt(n, s)` gets the character at index `n` within string `s`.
-If `n` is negative or greater than the length of `s`, it returns the empty string.
-If the string contains characters outside the range \u0000-\uffff, it will return the first 16-bit value at that position in the string. See [`String.charAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charAt) on MDN.
-
-```res example
-Js.String.charAt(0, "Reason") == "R"
-Js.String.charAt(12, "Reason") == ""
-Js.String.charAt(5, `Rẽasöń`) == `ń`
-```
-
-## charCodeAt
-
-```res sig
-let charCodeAt: (int, t) => float
-```
-
-`charCodeAt(n, s)` returns the character code at position `n` in string `s`; the result is in the range 0-65535, unlke `codePointAt`, so it will not work correctly for characters with code points greater than or equal to 0x10000.
-The return type is `float` because this function returns NaN if `n` is less than zero or greater than the length of the string. See [`String.charCodeAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charCodeAt) on MDN.
-
-```res example
-Js.String.charCodeAt(0, `😺`) == 0xd83d->Belt.Int.toFloat
-Js.String.codePointAt(0, `😺`) == Some(0x1f63a)
-```
-
-## codePointAt
-
-```res sig
-let codePointAt: (int, t) => option<int>
-```
-
-`codePointAt(n, s)` returns the code point at position `n` within string `s` as a `Some(value)`.
-The return value handles code points greater than or equal to 0x10000.
-If there is no code point at the given position, the function returns `None`. See [`String.codePointAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/codePointAt) on MDN.
-
-```res example
-Js.String.codePointAt(1, `¿😺?`) == Some(0x1f63a)
-Js.String.codePointAt(5, "abc") == None
-```
-
-## concat
-
-```res sig
-let concat: (t, t) => t
-```
-
-`concat(append, original)` returns a new `string` with `append` added after `original`. See [`String.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat) on MDN.
-
-```res example
-Js.String.concat("bell", "cow") == "cowbell"
-```
-
-## concatMany
-
-```res sig
-let concatMany: (array<t>, t) => t
-```
-
-`concat(arr, original)` returns a new `string` consisting of each item of an array of strings added to the `original` string. See [`String.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat) on MDN.
-
-```res example
-Js.String.concatMany(["2nd", "3rd", "4th"], "1st") == "1st2nd3rd4th"
-```
-
-## endsWith
-
-```res sig
-let endsWith: (t, t) => bool
-```
-
-ES2015: `endsWith(substr, str)` returns `true` if the `str` ends with `substr`, `false` otherwise. See [`String.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith) on MDN.
-
-```res example
-Js.String.endsWith("Script", "BuckleScript") == true
-Js.String.endsWith("Script", "BuckleShoes") == false
-```
-
-## endsWithFrom
-
-```res sig
-let endsWithFrom: (t, int, t) => bool
-```
-
-`endsWithFrom(ending, len, str)` returns `true` if the first len characters of `str` end with `ending`, `false` otherwise.
-If `len` is greater than or equal to the length of `str`, then it works like `endsWith`. (Honestly, this should have been named endsWithAt, but oh well.) See [`String.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith) on MDN.
-
-```res example
-Js.String.endsWithFrom("cd", 4, "abcd") == true
-Js.String.endsWithFrom("cd", 3, "abcde") == false
-Js.String.endsWithFrom("cde", 99, "abcde") == true
-Js.String.endsWithFrom("ple", 7, "example.dat") == true
-```
-
-## includes
-
-```res sig
-let includes: (t, t) => bool
-```
-
-ES2015: `includes(searchValue, str)` returns `true` if `searchValue` is found anywhere within `str`, false otherwise. See [`String.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes) on MDN.
-
-```res example
-Js.String.includes("gram", "programmer") == true
-Js.String.includes("er", "programmer") == true
-Js.String.includes("pro", "programmer") == true
-Js.String.includes("xyz", "programmer.dat") == false
-```
-
-## includesFrom
-
-```res sig
-let includesFrom: (t, int, t) => bool
-```
-
-ES2015: `includes(searchValue start, str)` returns `true` if `searchValue` is found anywhere within `str` starting at character number `start` (where 0 is the first character), `false` otherwise. See [`String.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes) on MDN.
-
-```res example
-Js.String.includesFrom("gram", 1, "programmer") == true
-Js.String.includesFrom("gram", 4, "programmer") == false
-Js.String.includesFrom(`한`, 1, `대한민국`) == true
-```
-
-## indexOf
-
-```res sig
-let indexOf: (t, t) => int
-```
-
-ES2015: `indexOf(searchValue, str)` returns the position at which `searchValue` was first found within `str`, or -1 if `searchValue` is not in `str`. See [`String.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf) on MDN.
-
-```res example
-Js.String.indexOf("ok", "bookseller") == 2
-Js.String.indexOf("sell", "bookseller") == 4
-Js.String.indexOf("ee", "beekeeper") == 1
-Js.String.indexOf("xyz", "bookseller") == -1
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (t, t, int) => int
-```
-`indexOfFrom(searchValue, start, str)` returns the position at which `searchValue` was found within `str` starting at character position `start`, or -1 if `searchValue` is not found in that portion of `str`.
-The return value is relative to the beginning of the string, no matter where the search started from. See [`String.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf) on MDN.
-
-```res example
-Js.String.indexOfFrom("ok", 1, "bookseller") == 2
-Js.String.indexOfFrom("sell", 2, "bookseller") == 4
-Js.String.indexOfFrom("sell", 5, "bookseller") == -1
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (t, t) => int
-```
-
-`lastIndexOf(searchValue, str)` returns the position of the last occurrence of `searchValue` within `str`, searching backwards from the end of the string.
-Returns -1 if `searchValue` is not in `str`. The return value is always relative to the beginning of the string. See [`String.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf) on MDN.
-
-```res example
-Js.String.lastIndexOf("ok", "bookseller") == 2
-Js.String.lastIndexOf("ee", "beekeeper") == 4
-Js.String.lastIndexOf("xyz", "abcdefg") == -1
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (t, int, t) => int
-```
-
-`lastIndexOfFrom(searchValue, start, str)` returns the position of the last occurrence of `searchValue` within `str`, searching backwards from the given start position.
-Returns -1 if `searchValue` is not in `str`. The return value is always relative to the beginning of the string. See [`String.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf) on MDN.
-
-```res example
-Js.String.lastIndexOfFrom("ok", 6, "bookseller") == 2
-Js.String.lastIndexOfFrom("ee", 8, "beekeeper") == 4
-Js.String.lastIndexOfFrom("ee", 3, "beekeeper") == 1
-Js.String.lastIndexOfFrom("xyz", 4, "abcdefg") == -1
-```
-
-## localeCompare
-
-```res sig
-let localeCompare: (t, t) => float
-```
-
-`localeCompare(comparison, reference)` returns
-- a negative value if reference comes before comparison in sort order
-- zero if reference and comparison have the same sort order
-- a positive value if reference comes after comparison in sort order
-
-See [`String.localeCompare`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare) on MDN.
-
-```res example
-Js.String.localeCompare("ant", "zebra") > 0.0
-Js.String.localeCompare("zebra", "ant") < 0.0
-Js.String.localeCompare("cat", "cat") == 0.0
-Js.String.localeCompare("cat", "CAT") > 0.0
-```
-
-## match
-
-```res sig
-let match_: (Js_re.t, t) => option<array<option<t>>>
-```
-
-`match(regexp, str)` matches a `string` against the given `regexp`. If there is no match, it returns `None`. For regular expressions without the g modifier, if there is a match, the return value is `Some(array)` where the array contains:
-- The entire matched string
-- Any capture groups if the regexp had parentheses
-
-For regular expressions with the g modifier, a matched expression returns `Some(array)` with all the matched substrings and no capture groups. Javscript String.prototype.match can return `undefined`  for optional capture groups that are not found, thus the element of the returned array is typed `option<t>`. See [`String.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match) on MDN.
-
-```res example
-Js.String.match_(%re("/b[aeiou]t/"), "The better bats") == Some([Some("bet")])
-Js.String.match_(%re("/b[aeiou]t/g"), "The better bats") == Some([Some("bet"), Some("bat")])
-Js.String.match_(%re("/(\d+)-(\d+)-(\d+)/"), "Today is 2018-04-05.") ==
-  Some([Some("2018-04-05"), Some("2018"), Some("04"), Some("05")])
-Js.String.match_(%re("/b[aeiou]g/"), "The large container.") == None
-```
-
-## normalize
-
-```res sig
-let normalize: t => t
-```
-
-`normalize(str)` returns the normalized Unicode string using Normalization Form Canonical (NFC) Composition.
-Consider the character ã, which can be represented as the single codepoint \u00e3 or the combination of a lower case letter A \u0061 and a combining tilde \u0303.
-Normalization ensures that both can be stored in an equivalent binary representation. See [`String.normalize`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize) on MDN. See also [Unicode technical report #15](https://unicode.org/reports/tr15/) for details.
-
-## normalizeByForm
-
-```res sig
-let normalizeByForm: (t, t) => t
-```
-
-ES2015: `normalize(form, str)` returns the normalized Unicode string using the specified form of normalization, which may be one of:
-- "NFC" — Normalization Form Canonical Composition.
-- "NFD" — Normalization Form Canonical Decomposition.
-- "NFKC" — Normalization Form Compatibility Composition.
-- "NFKD" — Normalization Form Compatibility Decomposition.
-
-See [`String.normalize`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize) on MDN. See also [Unicode technical report #15](https://unicode.org/reports/tr15/) for details.
-
-## repeat
-
-```res sig
-let repeat: (t, int) => t
-```
-
-`repeat(n, str)` returns a `string` that consists of `n` repetitions of `str`. Raises `RangeError` if `n` is negative. See [`String.repeat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat) on MDN.
-
-```res example
-Js.String.repeat(3, "ha") == "hahaha"
-Js.String.repeat(0, "empty") == ""
-```
-
-## replace
-
-```res sig
-let replace: (t, t, t) => t
-```
-
-ES2015: `replace(substr, newSubstr, str)` returns a new `string` which is identical to `str` except with the first matching instance of `substr` replaced by `newSubstr`.
-`substr` is treated as a verbatim string to match, not a regular expression. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-Js.String.replace("old", "new", "old string") == "new string"
-Js.String.replace("the", "this", "the cat and the dog") == "this cat and the dog"
-```
-
-## replaceByRe
-
-```res sig
-let replaceByRe: (Js_re.t, t, t) => t
-```
-
-`replaceByRe(regex, replacement, str)` returns a new `string` where occurrences matching regex have been replaced by `replacement`. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-Js.String.replaceByRe(%re("/[aeiou]/g"), "x", "vowels be gone") == "vxwxls bx gxnx"
-Js.String.replaceByRe(%re("/(\w+) (\w+)/"), "$2, $1", "Juan Fulano") == "Fulano, Juan"
-```
-
-## unsafeReplaceBy0
-
-```res sig
-let unsafeReplaceBy0: (Js_re.t, (t, int, t) => t, t) => t
-```
-
-Returns a new `string` with some or all matches of a pattern with no capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-let str = "beautiful vowels"
-let re = %re("/[aeiou]/g")
-let matchFn = (matchPart, _offset, _wholeString) => Js.String.toUpperCase(matchPart)
-
-Js.String.unsafeReplaceBy0(re, matchFn, str) == "bEAUtIfUl vOwEls"
-```
-
-## unsafeReplaceBy1
-
-```res sig
-let unsafeReplaceBy1: (Js_re.t, (t, t, int, t) => t, t) => t
-```
-
-Returns a new `string` with some or all matches of a pattern with one set of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured string, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-let str = "Jony is 40"
-let re = %re("/(Jony is )\d+/g")
-let matchFn = (_match, part1, _offset, _wholeString) => {
-  part1 ++ "41"
-}
-
-Js.String.unsafeReplaceBy1(re, matchFn, str) == "Jony is 41"
-```
-
-## unsafeReplaceBy2
-
-```res sig
-let unsafeReplaceBy2: (Js_re.t, (t, t, t, int, t) => t, t) => t
-```
-
-Returns a new `string` with some or all matches of a pattern with two sets of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured strings, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-let str = "7 times 6"
-let re = %re("/(\d+) times (\d+)/")
-let matchFn = (_match, p1, p2, _offset, _wholeString) => {
-  switch (Belt.Int.fromString(p1), Belt.Int.fromString(p2)) {
-  | (Some(x), Some(y)) => Belt.Int.toString(x * y)
-  | _ => "???"
-  }
-}
-
-Js.String.unsafeReplaceBy2(re, matchFn, str) == "42"
-```
-
-## unsafeReplaceBy3
-
-```res sig
-let unsafeReplaceBy3: (Js_re.t, (t, t, t, t, int, t) => t, t) => t
-```
-
-Returns a new `string` with some or all matches of a pattern with three sets of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured strings, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-## search
-
-```res sig
-let search: (Js_re.t, t) => int
-```
-
-`search(regexp, str)` returns the starting position of the first match of `regexp` in the given `str`, or -1 if there is no match. See [`String.search`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/search) on MDN.
-
-```res example
-Js.String.search(%re("/\d+/"), "testing 1 2 3") == 8
-Js.String.search(%re("/\d+/"), "no numbers") == -1
-```
-
-## slice
-
-```res sig
-let slice: (~from: int, ~to_: int, t) => t
-```
-
-`slice(from:n1, to_:n2, str)` returns the substring of `str` starting at character `n1` up to but not including `n2`.
-- If either `n1` or `n2` is negative, then it is evaluated as `length(str - n1)` or `length(str - n2)`.
-- If `n2` is greater than the length of `str`, then it is treated as `length(str)`.
-- If `n1` is greater than `n2`, slice returns the empty string.
-
-See [`String.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice) on MDN.
-
-```res example
-Js.String.slice(~from=2, ~to_=5, "abcdefg") == "cde"
-Js.String.slice(~from=2, ~to_=9, "abcdefg") == "cdefg"
-Js.String.slice(~from=-4, ~to_=-2, "abcdefg") == "de"
-Js.String.slice(~from=5, ~to_=1, "abcdefg") == ""
-```
-
-## sliceToEnd
-
-```res sig
-let sliceToEnd: (~from: int, t) => t
-```
-
-`sliceToEnd(str, from:n)` returns the substring of `str` starting at character `n` to the end of the string.
-- If `n` is negative, then it is evaluated as `length(str - n)`.
-- If `n` is greater than the length of `str`, then sliceToEnd returns the empty string.
-
-See [`String.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice) on MDN.
-
-```res example
-Js.String.sliceToEnd(~from=4, "abcdefg") == "efg"
-Js.String.sliceToEnd(~from=-2, "abcdefg") == "fg"
-Js.String.sliceToEnd(~from=7, "abcdefg") == ""
-```
-
-## split
-
-```res sig
-let split: (t, t) => array<t>
-```
-
-`split(delimiter, str)` splits the given `str` at every occurrence of `delimiter` and returns an array of the resulting substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```res example
-Js.String.split("-", "2018-01-02") == ["2018", "01", "02"]
-Js.String.split(",", "a,b,,c") == ["a", "b", "", "c"]
-Js.String.split("::", "good::bad as great::awful") == ["good", "bad as great", "awful"]
-Js.String.split(";", "has-no-delimiter") == ["has-no-delimiter"]
-```
-
-## splitAtMost
-
-```res sig
-let splitAtMost: (t, ~limit: int, t) => array<t>
-```
-
-`splitAtMost(delimiter, ~limit:n, str)` splits the given `str` at every occurrence of `delimiter` and returns an array of the first `n` resulting substrings.
-If `n` is negative or greater than the number of substrings, the array will contain all the substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```res example
-Js.String.splitAtMost("/", ~limit=3, "ant/bee/cat/dog/elk") == ["ant", "bee", "cat"]
-Js.String.splitAtMost("/", ~limit=0, "ant/bee/cat/dog/elk") == []
-Js.String.splitAtMost("/", ~limit=9, "ant/bee/cat/dog/elk") == ["ant", "bee", "cat", "dog", "elk"]
-```
-
-## splitLimited
-
-```res sig
-let splitLimited: (t, int, t) => array<t>
-```
-
-Deprecated - Please use splitAtMost.
-
-## splitByRe
-
-```res sig
-let splitByRe: (Js_re.t, t) => array<option<t>>
-```
-
-`splitByRe(regex, str)` splits the given `str` at every occurrence of `regex` and returns an array of the resulting substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```res example
-Js.String.splitByRe(%re("/\s*[,;]\s*/"), "art; bed , cog ;dad") == [
-    Some("art"),
-    Some("bed"),
-    Some("cog"),
-    Some("dad"),
-  ]
-```
-
-## splitByReAtMost
-
-```res sig
-let splitByReAtMost: (Js_re.t, ~limit: int, t) => array<option<t>>
-```
-
-`splitByReAtMost(regex, ~limit:n, str)` splits the given `str` at every occurrence of `regex` and returns an array of the first `n` resulting substrings.
-If `n` is negative or greater than the number of substrings, the array will contain all the substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```res example
-Js.String.splitByReAtMost(%re("/\s*:\s*/"), ~limit=3, "one: two: three: four") == [
-    Some("one"),
-    Some("two"),
-    Some("three"),
-  ]
-
-Js.String.splitByReAtMost(%re("/\s*:\s*/"), ~limit=0, "one: two: three: four") == []
-
-Js.String.splitByReAtMost(%re("/\s*:\s*/"), ~limit=8, "one: two: three: four") == [
-    Some("one"),
-    Some("two"),
-    Some("three"),
-    Some("four"),
-  ]
-```
-
-## splitRegexpLimited
-
-```res sig
-let splitRegexpLimited: (Js_re.t, int, t) => array<t>
-```
-
-Deprecated - Please use splitByReAtMost.
-
-## startsWith
-
-```res sig
-let startsWith: (t, t) => bool
-```
-
-ES2015: `startsWith(substr, str)` returns `true` if the `str` starts with `substr`, `false` otherwise. See [`String.startsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith) on MDN.
-
-```res example
-Js.String.startsWith("Buckle", "BuckleScript") == true
-Js.String.startsWith("", "BuckleScript") == true
-Js.String.startsWith("Buckle", "JavaScript") == false
-```
-
-## startsWithFrom
-
-```res sig
-let startsWithFrom: (t, int, t) => bool
-```
-
-ES2015: `startsWithFrom(substr, n, str)` returns `true` if the `str` starts with `substr` starting at position `n`, false otherwise.
-If `n` is negative, the search starts at the beginning of `str`. See [`String.startsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith) on MDN.
-
-```res example
-Js.String.startsWithFrom("kle", 3, "BuckleScript") == true
-Js.String.startsWithFrom("", 3, "BuckleScript") == true
-Js.String.startsWithFrom("Buckle", 2, "JavaScript") == false
-```
-
-## substr
-
-```res sig
-let substr: (~from: int, t) => t
-```
-
-`substr(~from:n, str)` returns the substring of `str` from position `n` to the end of the string.
-- If `n` is less than zero, the starting position is the length of `str - n`.
-- If `n` is greater than or equal to the length of `str`, returns the empty string.
-
-JavaScript’s `String.substr()` is a legacy function. When possible, use `substring()` instead. See [`String.substr`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr) on MDN.
-
-```res example
-Js.String.substr(~from=3, "abcdefghij") == "defghij"
-Js.String.substr(~from=-3, "abcdefghij") == "hij"
-Js.String.substr(~from=12, "abcdefghij") == ""
-```
-
-## substrAtMost
-
-```res sig
-let substrAtMost: (~from: int, ~length: int, t) => t
-```
-
-`substrAtMost(~from: pos, ~length: n, str)` returns the substring of `str` of length `n` starting at position `pos`.
-- If `pos` is less than zero, the starting position is the length of `str - pos`.
-- If `pos` is greater than or equal to the length of `str`, returns the empty string.
-- If `n` is less than or equal to zero, returns the empty string.
-
-JavaScript’s `String.substr()` is a legacy function. When possible, use `substring()` instead. See [`String.substr`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr) on MDN.
-
-```res example
-Js.String.substrAtMost(~from=3, ~length=4, "abcdefghij") == "defg"
-Js.String.substrAtMost(~from=-3, ~length=4, "abcdefghij") == "hij"
-Js.String.substrAtMost(~from=12, ~length=2, "abcdefghij") == ""
-```
-
-## substring
-
-```res sig
-let substring: (~from: int, ~to_: int, t) => t
-```
-
-`substring(~from: start, ~to_: finish, str)` returns characters `start` up to but not including finish from `str`.
-- If `start` is less than zero, it is treated as zero.
-- If `finish` is zero or negative, the empty string is returned.
-- If `start` is greater than `finish`, the `start` and `finish` points are swapped.
-
-See [`String.substring`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring) on MDN.
-
-```res example
-Js.String.substring(~from=3, ~to_=6, "playground") == "ygr"
-Js.String.substring(~from=6, ~to_=3, "playground") == "ygr"
-Js.String.substring(~from=4, ~to_=12, "playground") == "ground"
-```
-
-## substringToEnd
-
-```res sig
-let substringToEnd: (~from: int, t) => t
-```
-
-`substringToEnd(~from: start, str)` returns the substring of `str` from position `start` to the end.
-- If `start` is less than or equal to zero, the entire string is returned.
-- If `start` is greater than or equal to the length of `str`, the empty string is returned.
-
-See [`String.substring`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring) on MDN.
-
-```res example
-Js.String.substringToEnd(~from=4, "playground") == "ground"
-Js.String.substringToEnd(~from=-3, "playground") == "playground"
-Js.String.substringToEnd(~from=12, "playground") == ""
-```
-
-## toLowerCase
-
-```res sig
-let toLowerCase: t => t
-```
-
-`toLowerCase(str)` converts `str` to lower case using the locale-insensitive case mappings in the Unicode Character Database.
-Notice that the conversion can give different results depending upon context, for example with the Greek letter sigma, which has two different lower case forms; one when it is the last character in a string and another when it is not. See [`String.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase) on MDN.
-
-```res example
-Js.String.toLowerCase("ABC") == "abc"
-Js.String.toLowerCase(`ΣΠ`) == `σπ`
-Js.String.toLowerCase(`ΠΣ`) == `πς`
-```
-
-## toLocaleLowerCase
-
-```res sig
-let toLocaleLowerCase: t => t
-```
-
-`toLocaleLowerCase(str)` converts `str` to lower case using the current locale. See [`String.toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase) on MDN.
-
-## toUpperCase
-
-```res sig
-let toUpperCase: t => t
-```
-
-`toUpperCase(str)` converts `str` to upper case using the locale-insensitive case mappings in the Unicode Character Database.
-Notice that the conversion can expand the number of letters in the result; for example the German ß capitalizes to two Ses in a row. See [`String.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) on MDN.
-
-```res example
-Js.String.toUpperCase("abc") == "ABC"
-Js.String.toUpperCase(`Straße`) == `STRASSE`
-Js.String.toUpperCase(`πς`) == `ΠΣ`
-```
-
-## toLocaleUpperCase
-
-```res sig
-let toLocaleUpperCase: t => t
-```
-
-`toLocaleUpperCase(str)` converts `str` to upper case using the current locale. See [`String.to:LocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase) on MDN.
-
-## trim
-
-```res sig
-let trim: t => t
-```
-
-`trim(str)` returns a string that is `str` with whitespace stripped from both ends. Internal whitespace is not removed. See [`String.trim`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trim) on MDN.
-
-```res example
-Js.String.trim("   abc def   ") == "abc def"
-Js.String.trim("\n\r\t abc def \n\n\t\r ") == "abc def"
-```
-
-## anchor
-
-```res sig
-let anchor: (t, t) => t
-```
-
-`anchor(anchorName, anchorText)` creates a string with an HTML `<a>` element with name attribute of `anchorName` and `anchorText` as its content. Please do not use this method, as it has been removed from the relevant web standards. See [`String.anchor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/anchor) on MDN.
-
-```res example
-Js.String.anchor("page1", "Page One") == "<a name=\"page1\">Page One</a>"
-```
-
-## link
-
-```res sig
-let link: (t, t) => t
-```
-
-ES2015: `link(urlText, linkText)` creates a string with an HTML `<a>` element with href attribute of `urlText` and `linkText` as its content. Please do not use this method, as it has been removed from the relevant web standards. See [`String.link`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/link) on MDN.
-
-```res example
-Js.String.link("page2.html", "Go to page two") == "<a href=\"page2.html\">Go to page two</a>"
-```
-
-## castToArrayLike
-
-```res sig
-let castToArrayLike: t => Js_array2.array_like<t>
-```
-
-Casts its argument to an `array_like` entity that can be processed by functions such as `Js.Array2.fromMap()`
-
-```res example
-let s = "abcde"
-let arr = Js.Array2.fromMap(Js.String.castToArrayLike(s), x => x)
-arr == ["a", "b", "c", "d", "e"]
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array-2.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array-2.mdx
deleted file mode 100644
index 617e9324d..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array-2.mdx
+++ /dev/null
@@ -1,31 +0,0 @@
-# TypedArray2
-
-<Intro>
-
-Provide bindings to JS typed array.
-
-</Intro>
-
-## array_buffer
-
-```res sig
-type array_buffer
-```
-
-## array_like
-
-```res sig
-type array_like<'a>
-```
-
-## module ArrayBuffer
-## module Int8Array
-## module Uint8Array
-## module Uint8ClampedArray
-## module Int16Array
-## module Uint16Array
-## module Int32Array
-## module Uint32Array
-## module Float32Array
-## module Float64Array
-## module DataView
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array-2_array-buffer.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array-2_array-buffer.mdx
deleted file mode 100644
index 5bef6f7e8..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array-2_array-buffer.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# TypedArray2.ArrayBuffer
-
-<Intro>
-
-Provide bindings to JS typed array ArrayBuffer.
-
-</Intro>
-
-## t
-
-```res prelude
-type t = Js_typed_array2.array_buffer
-```
-
-## make
-
-```res sig
-let make: int => t
-```
-
-Takes length. initializes elements to 0.
-
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## slice
-
-```res sig
-let slice: (t, ~start: int, ~end_: int) => Js_typed_array2.array_buffer
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (t, int) => Js_typed_array2.array_buffer
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array-2_data-view.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array-2_data-view.mdx
deleted file mode 100644
index 0b65c8da7..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array-2_data-view.mdx
+++ /dev/null
@@ -1,223 +0,0 @@
-# TypedArray2.DataView
-
-<Intro>
-
-Provide bindings to JS typed array DataView.
-
-</Intro>
-
-## t
-
-```res prelude
-type t
-```
-
-## make
-
-```res sig
-let make: Js_typed_array2.array_buffer => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## getInt8
-
-```res sig
-let getInt8: (t, int) => int
-```
-
-## getUint8
-
-```res sig
-let getUint8: (t, int) => int
-```
-
-## getInt16
-
-```res sig
-let getInt16: (t, int) => int
-```
-
-## getInt16LittleEndian
-
-```res sig
-let getInt16LittleEndian: (t, int) => int
-```
-
-## getUint16
-
-```res sig
-let getUint16: (t, int) => int
-```
-
-## getUint16LittleEndian
-
-```res sig
-let getUint16LittleEndian: (t, int) => int
-```
-
-## getInt32
-
-```res sig
-let getInt32: (t, int) => int
-```
-
-## getInt32LittleEndian
-
-```res sig
-let getInt32LittleEndian: (t, int) => int
-```
-
-## getUint32
-
-```res sig
-let getUint32: (t, int) => int
-```
-
-## getUint32LittleEndian
-
-```res sig
-let getUint32LittleEndian: (t, int) => int
-```
-
-## getFloat32
-
-```res sig
-let getFloat32: (t, int) => float
-```
-
-## getFloat32LittleEndian
-
-```res sig
-let getFloat32LittleEndian: (t, int) => float
-```
-
-## getFloat64
-
-```res sig
-let getFloat64: (t, int) => float
-```
-
-## getFloat64LittleEndian
-
-```res sig
-let getFloat64LittleEndian: (t, int) => float
-```
-
-## setInt8
-
-```res sig
-let setInt8: (t, int, int) => unit
-```
-
-## setUint8
-
-```res sig
-let setUint8: (t, int, int) => unit
-```
-
-## setInt16
-
-```res sig
-let setInt16: (t, int, int) => unit
-```
-
-## setInt16LittleEndian
-
-```res sig
-let setInt16LittleEndian: (t, int, int) => unit
-```
-
-## setUint16
-
-```res sig
-let setUint16: (t, int, int) => unit
-```
-
-## setUint16LittleEndian
-
-```res sig
-let setUint16LittleEndian: (t, int, int) => unit
-```
-
-## setInt32
-
-```res sig
-let setInt32: (t, int, int) => unit
-```
-
-## setInt32LittleEndian
-
-```res sig
-let setInt32LittleEndian: (t, int, int) => unit
-```
-
-## setUint32
-
-```res sig
-let setUint32: (t, int, int) => unit
-```
-
-## setUint32LittleEndian
-
-```res sig
-let setUint32LittleEndian: (t, int, int) => unit
-```
-
-## setFloat32
-
-```res sig
-let setFloat32: (t, int, float) => unit
-```
-
-## setFloat32LittleEndian
-
-```res sig
-let setFloat32LittleEndian: (t, int, float) => unit
-```
-
-## setFloat64
-
-```res sig
-let setFloat64: (t, int, float) => unit
-```
-
-## setFloat64LittleEndian
-
-```res sig
-let setFloat64LittleEndian: (t, int, float) => unit
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array-2_float-32-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array-2_float-32-array.mdx
deleted file mode 100644
index 2bfec4069..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array-2_float-32-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Float32Array
-
-<Intro>
-
-Provide bindings to JS typed array Float32Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = float
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array-2_float-64-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array-2_float-64-array.mdx
deleted file mode 100644
index 5cf59253b..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array-2_float-64-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Float64Array
-
-<Intro>
-
-Provide bindings to JS typed array Float64Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = float
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array-2_int-16-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array-2_int-16-array.mdx
deleted file mode 100644
index 6452ee5ef..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array-2_int-16-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Int16Array
-
-<Intro>
-
-Provide bindings to JS typed array Int16Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array-2_int-32-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array-2_int-32-array.mdx
deleted file mode 100644
index da230b64b..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array-2_int-32-array.mdx
+++ /dev/null
@@ -1,375 +0,0 @@
-# TypedArray2.Int32Array
-
-<Intro>
-
-Provide bindings to JS typed array Int32Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int32
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
-
-## create
-
-```res sig
-let create: array<elt> => t
-```
-
-## of_buffer
-
-```res sig
-let of_buffer: Js_typed_array2.array_buffer => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array-2_int-8-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array-2_int-8-array.mdx
deleted file mode 100644
index d0676dce3..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array-2_int-8-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Int8Array
-
-<Intro>
-
-Provide bindings to JS typed array Int8Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array-2_uint-16-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array-2_uint-16-array.mdx
deleted file mode 100644
index 67ad8e6db..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array-2_uint-16-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Uint16Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint16Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array-2_uint-32-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array-2_uint-32-array.mdx
deleted file mode 100644
index e27f5075f..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array-2_uint-32-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.UInt32Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint32Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array-2_uint-8-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array-2_uint-8-array.mdx
deleted file mode 100644
index 3af6a295d..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array-2_uint-8-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Uint8Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint8Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array-2_uint-8-clamped-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array-2_uint-8-clamped-array.mdx
deleted file mode 100644
index 4a015d3ba..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array-2_uint-8-clamped-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Uint8ClampedArray
-
-<Intro>
-
-Provide bindings to JS typed array Uint8ClampedArray.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array.mdx
deleted file mode 100644
index b62f9e668..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# TypedArray
-
-<Intro>
-
-Provide bindings to JS typed array.
-
-</Intro>
-
-## array_buffer
-
-```res sig
-type array_buffer
-```
-
-## array_like
-
-```res sig
-type array_like<'a>
-```
-
-## module type Type
-
-```res sig
-module type Type = {
-  type t
-}
-```
-
-## module ArrayBuffer
-## module type S
-## module Int8Array
-## module Uint8Array
-## module Uint8ClampedArray
-## module Int16Array
-## module Uint16Array
-## module Int32Array
-## module Uint32Array
-## module Float32Array
-## module Float64Array
-## module DataView
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array_array-buffer.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array_array-buffer.mdx
deleted file mode 100644
index f5dbd3860..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array_array-buffer.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# TypedArray.ArrayBuffer
-
-<Intro>
-
-Provide bindings to JS typed array ArrayBuffer.
-
-</Intro>
-
-## t
-
-```res prelude
-type t = Js_typed_array.array_buffer
-```
-
-## make
-
-```res sig
-let make: int => t
-```
-
-Takes length. initializes elements to 0.
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => Js_typed_array.array_buffer
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => Js_typed_array.array_buffer
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array_data-view.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array_data-view.mdx
deleted file mode 100644
index 6a02034ff..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array_data-view.mdx
+++ /dev/null
@@ -1,223 +0,0 @@
-# TypedArray.DataView
-
-<Intro>
-
-Provide bindings to JS typed array DataView.
-
-</Intro>
-
-## t
-
-```res prelude
-type t = Js_typed_array2.DataView.t
-```
-
-## make
-
-```res sig
-let make: Js_typed_array.array_buffer => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## getInt8
-
-```res sig
-let getInt8: (t, int) => int
-```
-
-## getUint8
-
-```res sig
-let getUint8: (t, int) => int
-```
-
-## getInt16
-
-```res sig
-let getInt16: (t, int) => int
-```
-
-## getInt16LittleEndian
-
-```res sig
-let getInt16LittleEndian: (t, int) => int
-```
-
-## getUint16
-
-```res sig
-let getUint16: (t, int) => int
-```
-
-## getUint16LittleEndian
-
-```res sig
-let getUint16LittleEndian: (t, int) => int
-```
-
-## getInt32
-
-```res sig
-let getInt32: (t, int) => int
-```
-
-## getInt32LittleEndian
-
-```res sig
-let getInt32LittleEndian: (t, int) => int
-```
-
-## getUint32
-
-```res sig
-let getUint32: (t, int) => int
-```
-
-## getUint32LittleEndian
-
-```res sig
-let getUint32LittleEndian: (t, int) => int
-```
-
-## getFloat32
-
-```res sig
-let getFloat32: (t, int) => float
-```
-
-## getFloat32LittleEndian
-
-```res sig
-let getFloat32LittleEndian: (t, int) => float
-```
-
-## getFloat64
-
-```res sig
-let getFloat64: (t, int) => float
-```
-
-## getFloat64LittleEndian
-
-```res sig
-let getFloat64LittleEndian: (t, int) => float
-```
-
-## setInt8
-
-```res sig
-let setInt8: (t, int, int) => unit
-```
-
-## setUint8
-
-```res sig
-let setUint8: (t, int, int) => unit
-```
-
-## setInt16
-
-```res sig
-let setInt16: (t, int, int) => unit
-```
-
-## setInt16LittleEndian
-
-```res sig
-let setInt16LittleEndian: (t, int, int) => unit
-```
-
-## setUint16
-
-```res sig
-let setUint16: (t, int, int) => unit
-```
-
-## setUint16LittleEndian
-
-```res sig
-let setUint16LittleEndian: (t, int, int) => unit
-```
-
-## setInt32
-
-```res sig
-let setInt32: (t, int, int) => unit
-```
-
-## setInt32LittleEndian
-
-```res sig
-let setInt32LittleEndian: (t, int, int) => unit
-```
-
-## setUint32
-
-```res sig
-let setUint32: (t, int, int) => unit
-```
-
-## setUint32LittleEndian
-
-```res sig
-let setUint32LittleEndian: (t, int, int) => unit
-```
-
-## setFloat32
-
-```res sig
-let setFloat32: (t, int, float) => unit
-```
-
-## setFloat32LittleEndian
-
-```res sig
-let setFloat32LittleEndian: (t, int, float) => unit
-```
-
-## setFloat64
-
-```res sig
-let setFloat64: (t, int, float) => unit
-```
-
-## setFloat64LittleEndian
-
-```res sig
-let setFloat64LittleEndian: (t, int, float) => unit
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array_float-32-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array_float-32-array.mdx
deleted file mode 100644
index c10ae364d..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array_float-32-array.mdx
+++ /dev/null
@@ -1,375 +0,0 @@
-# TypedArray.Float32Array
-
-<Intro>
-
-Provide bindings to JS typed array Float32Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = float
-type typed_array<'a> = Js_typed_array2.Float32Array.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
-
-## create
-
-```res sig
-let create: array<elt> => t
-```
-
-## of_buffer
-
-```res sig
-let of_buffer: Js_typed_array.array_buffer => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array_float-64-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array_float-64-array.mdx
deleted file mode 100644
index d7222de99..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array_float-64-array.mdx
+++ /dev/null
@@ -1,375 +0,0 @@
-# TypedArray.Float64Array
-
-<Intro>
-
-Provide bindings to JS typed array Float64Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = float
-type typed_array<'a> = Js_typed_array2.Float64Array.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
-
-## create
-
-```res sig
-let create: array<elt> => t
-```
-
-## of_buffer
-
-```res sig
-let of_buffer: Js_typed_array.array_buffer => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array_int-16-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array_int-16-array.mdx
deleted file mode 100644
index f49f8162a..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array_int-16-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.Int16Array
-
-<Intro>
-
-Provide bindings to JS typed array Int16Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a> = Js_typed_array2.Int16Array.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array_int-32-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array_int-32-array.mdx
deleted file mode 100644
index 7147de119..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array_int-32-array.mdx
+++ /dev/null
@@ -1,375 +0,0 @@
-# TypedArray.Int32Array
-
-<Intro>
-
-Provide bindings to JS typed array Int32Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int32
-type typed_array<'a> = Js_typed_array2.Int32Array.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
-
-## create
-
-```res sig
-let create: array<elt> => t
-```
-
-## of_buffer
-
-```res sig
-let of_buffer: Js_typed_array.array_buffer => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array_int-8-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array_int-8-array.mdx
deleted file mode 100644
index 5336025ae..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array_int-8-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.Int8Array
-
-<Intro>
-
-Provide bindings to JS typed array Int8Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a> = Js_typed_array2.Int8Array.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array_type-s.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array_type-s.mdx
deleted file mode 100644
index d71e5dcd7..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array_type-s.mdx
+++ /dev/null
@@ -1,309 +0,0 @@
-# TypedArray type S
-
-<Intro>
-
-TODO
-
-</Intro>
-
-## t
-
-```res prelude
-type elt
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array_uint-16-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array_uint-16-array.mdx
deleted file mode 100644
index 6ac15af3c..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array_uint-16-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.Uint16Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint16Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a> = Js_typed_array2.Uint16Array.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array_uint-32-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array_uint-32-array.mdx
deleted file mode 100644
index fbd25e7fa..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array_uint-32-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.UInt32Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint32Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a> = Js_typed_array2.Uint32Array.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array_uint-8-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array_uint-8-array.mdx
deleted file mode 100644
index 75bf7449a..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array_uint-8-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.Uint8Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint8Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a> = Js_typed_array2.Uint8Array.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/typed-array_uint-8-clamped-array.mdx b/pages/docs/manual/v10.0.0/api/js/typed-array_uint-8-clamped-array.mdx
deleted file mode 100644
index 57f4a5288..000000000
--- a/pages/docs/manual/v10.0.0/api/js/typed-array_uint-8-clamped-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.Uint8ClampedArray
-
-<Intro>
-
-Provide bindings to JS typed array Uint8ClampedArray.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a> = Js_typed_array2.Uint8ClampedArray.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/types.mdx b/pages/docs/manual/v10.0.0/api/js/types.mdx
deleted file mode 100644
index bf19e7d0b..000000000
--- a/pages/docs/manual/v10.0.0/api/js/types.mdx
+++ /dev/null
@@ -1,78 +0,0 @@
-# Types
-
-<Intro>
-
-Provide utilities for manipulating JS types.
-
-</Intro>
-
-## symbol
-
-```res prelude
-type symbol
-```
-
-## obj_val
-
-```res prelude
-type obj_val
-```
-
-## undefined_val
-
-```res prelude
-type undefined_val
-```
-
-## null_val
-
-```res prelude
-type null_val
-```
-
-## function_val
-
-```res prelude
-type function_val
-```
-
-## t
-
-```res prelude
-type rec t<'a> =
-  | Undefined: t<undefined_val>
-  | Null: t<null_val>
-  | Boolean: t<bool>
-  | Number: t<float>
-  | String: t<string>
-  | Function: t<function_val>
-  | Object: t<obj_val>
-  | Symbol: t<symbol>
-```
-
-## test
-
-```res sig
-let test: ('a, t<'b>) => bool
-```
-
-## tagged_t
-
-```res prelude
-type tagged_t =
-  | JSFalse
-  | JSTrue
-  | JSNull
-  | JSUndefined
-  | JSNumber(float)
-  | JSString(string)
-  | JSFunction(function_val)
-  | JSObject(obj_val)
-  | JSSymbol(symbol)
-```
-
-## classify
-
-```res sig
-let classify: 'a => tagged_t
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/undefined.mdx b/pages/docs/manual/v10.0.0/api/js/undefined.mdx
deleted file mode 100644
index 9f318ed12..000000000
--- a/pages/docs/manual/v10.0.0/api/js/undefined.mdx
+++ /dev/null
@@ -1,119 +0,0 @@
-# Undefined
-
-<Intro>
-
-Provide utilities around `Js.undefined`.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a> = Js.undefined<'a>
-```
-
-Local alias for 'a Js.undefined.
-
-## return
-
-```res sig
-let return: 'a => t<'a>
-```
-
-Constructs a value of `Js.undefined<'a>` containing a value of `'a`.
-
-## test
-
-```res sig
-let test: t<'a> => bool
-```
-
-Returns `true` if the given value is empty (undefined), `false` otherwise.
-
-## testAny
-
-```res sig
-let testAny: 'a => bool
-```
-
-Since 1.6.1 Returns `true` if the given value is empty (undefined).
-
-## empty
-
-```res sig
-let empty: t<'a>
-```
-
-The empty value, `undefined`.
-
-## getUnsafe
-
-```res sig
-let getUnsafe: t<'a> => 'a
-```
-
-## getExn
-
-```res sig
-let getExn: t<'a> => 'a
-```
-
-## bind
-
-```res sig
-let bind: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-Maps the contained value using the given function.
-If `Js.undefined<'a>` contains a value, that value is unwrapped, mapped to a `'b` using the given function `a' => 'b`, then wrapped back up and returned as `Js.undefined<'b>`.
-
-```res example
-let maybeGreetWorld = (maybeGreeting: Js.undefined<string>) =>
-  Js.Undefined.bind(maybeGreeting, (. greeting) => greeting ++ " world!")
-```
-
-## iter
-
-```res sig
-let iter: (t<'a>, (. 'a) => unit) => unit
-```
-
-Iterates over the contained value with the given function.
-If `Js.undefined<'a>` contains a value, that value is unwrapped and applied to the given function.
-
-```res example
-let maybeSay = (maybeMessage: Js.undefined<string>) =>
-  Js.Undefined.iter(maybeMessage, (. message) => Js.log(message))
-```
-
-## fromOption
-
-```res sig
-let fromOption: option<'a> => t<'a>
-```
-
-Maps `option<'a>` to `Js.undefined<'a>`.
-`Some(a)` => `a`
-`None` => `empty`
-
-## from_opt
-
-```res sig
-let from_opt: option<'a> => t<'a>
-```
-
-## toOption
-
-```res sig
-let toOption: t<'a> => option<'a>
-```
-
-Maps `Js.undefined<'a>` to `option<'a>`
-`a` => `Some(a)`
-`empty` => `None`
-
-## to_opt
-
-```res sig
-let to_opt: t<'a> => option<'a>
-```
diff --git a/pages/docs/manual/v10.0.0/api/js/vector.mdx b/pages/docs/manual/v10.0.0/api/js/vector.mdx
deleted file mode 100644
index cefea9a87..000000000
--- a/pages/docs/manual/v10.0.0/api/js/vector.mdx
+++ /dev/null
@@ -1,157 +0,0 @@
-# Vector
-
-<Intro>
-
-Provide vector utilities.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a> = array<'a>
-```
-
-## filterInPlace
-
-```res sig
-let filterInPlace: ((. 'a) => bool, t<'a>) => unit
-```
-
-p : predicate
-a : array
-
-## empty
-
-```res sig
-let empty: t<'a> => unit
-```
-
-## pushBack
-
-```res sig
-let pushBack: ('a, t<'a>) => unit
-```
-
-## copy
-
-```res sig
-let copy: t<'a> => t<'a>
-```
-
-Create a shallow copy of a vector.
-
-## memByRef
-
-```res sig
-let memByRef: ('a, t<'a>) => bool
-```
-
-Find by JS (===) equality.
-
-## iter
-
-```res sig
-let iter: ((. 'a) => unit, t<'a>) => unit
-```
-
-## iteri
-
-```res sig
-let iteri: ((. int, 'a) => unit, t<'a>) => unit
-```
-
-## toList
-
-```res sig
-let toList: t<'a> => list<'a>
-```
-
-## map
-
-```res sig
-let map: ((. 'a) => 'b, t<'a>) => t<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. int, 'a) => 'b, t<'a>) => t<'b>
-```
-
-## foldLeft
-
-```res sig
-let foldLeft: ((. 'a, 'b) => 'a, 'a, t<'b>) => 'a
-```
-
-## foldRight
-
-```res sig
-let foldRight: ((. 'b, 'a) => 'a, t<'b>, 'a) => 'a
-```
-
-## length
-
-```res sig
-let length: t<'a> => int
-```
-
-Return the length (number of elements) of the given array.
-
-## get
-
-```res sig
-let get: (t<'a>, int) => 'a
-```
-
-`Vector.get(a, n)` returns the element number `n` of vector `a`. The first element has number 0. The last element has number `Vector.length(a) - 1`. You can also write `a[n]` instead of `Vector.get(a, n)`.
-Raise `Invalid_argument "index out of bounds"` if `n` is outside the range 0 to (`Array.length(a) - 1`).
-
-## set
-
-```res sig
-let set: (t<'a>, int, 'a) => unit
-```
-
-`Vector.set(a, n, x)` modifies vector `a` in place, replacing element number `n` with `x`.
-Raise `Invalid_argument "index out of bounds"` if `n` is outside the range 0 to `Array.length(a) - 1`.
-
-## make
-
-```res sig
-let make: (int, 'a) => t<'a>
-```
-
-`Vector.make(n, x)` returns a fresh vector of length `n`, initialized with `x`. All the elements of this new vector are initially physically equal to `x` (in the sense of the `==` predicate).
-Consequently, if `x` is mutable, it is shared among all elements of the array, and modifying `x` through one of the array entries will modify all other entries at the same time.
-Raise `Invalid_argument` if `n < 0` or `n > Sys.max_array_length`. If the value of `x` is a floating-point number, then the maximum size is only `Sys.max_array_length / 2`.
-
-## init
-
-```res sig
-let init: (int, (. int) => 'a) => t<'a>
-```
-
-Raises `RangeError` when n is negative.
-n : size
-
-## append
-
-```res sig
-let append: ('a, t<'a>) => t<'a>
-```
-
-`append(x, a)` returns a fresh vector with `x` appended to `a`.
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t<'a>, int) => 'a
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t<'a>, int, 'a) => unit
-```
diff --git a/pages/docs/manual/v10.0.0/array-and-list.mdx b/pages/docs/manual/v10.0.0/array-and-list.mdx
deleted file mode 100644
index f6b0f80c2..000000000
--- a/pages/docs/manual/v10.0.0/array-and-list.mdx
+++ /dev/null
@@ -1,147 +0,0 @@
----
-title: "Array & List"
-description: "Arrays and List data structures"
-canonical: "/docs/manual/latest/array-and-list"
----
-
-# Array and List
-
-## Array
-
-Arrays are our main ordered data structure. They work the same way as JavaScript arrays: they can be randomly accessed, dynamically resized, updated, etc.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myArray = ["hello", "world", "how are you"]
-```
-```js
-var myArray = ["hello", "world", "how are you"];
-```
-
-</CodeTab>
-
-ReScript arrays' items must have the same type, i.e. homogeneous.
-
-### Usage
-
-See the [Js.Array](api/js/array) API.
-
-Access & update an array item like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myArray = ["hello", "world", "how are you"]
-
-let firstItem = myArray[0] // "hello"
-
-myArray[0] = "hey" // now ["hey", "world", "how are you"]
-
-let pushedValue = Js.Array2.push(myArray, "bye")
-```
-```js
-var myArray = ["hello", "world", "how are you"];
-
-var firstItem = myArray[0];
-
-myArray[0] = "hey";
-
-var pushedValue = myArray.push("bye");
-```
-
-</CodeTab>
-
-## List
-
-ReScript provides a singly linked list too. Lists are:
-
-- immutable
-- fast at prepending items
-- fast at getting the head
-- slow at everything else
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myList = list{1, 2, 3}
-```
-```js
-var myList = {
-  hd: 1,
-  tl: {
-    hd: 2,
-    tl: {
-      hd: 3,
-      tl: 0
-    }
-  }
-};
-```
-
-</CodeTab>
-
-Like arrays, lists' items need to be of the same type.
-
-### Usage
-
-You'd use list for its resizability, its fast prepend (adding at the head), and its fast split, all of which are immutable and relatively efficient.
-
-Do **not** use list if you need to randomly access an item or insert at non-head position. Your code would end up obtuse and/or slow.
-
-The standard lib provides a [List module](api/belt/list).
-
-#### Immutable Prepend
-
-Use the spread syntax:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let myList = list{1, 2, 3}
-let anotherList = list{0, ...myList}
-```
-```js
-var myList = {
-  hd: 1,
-  tl: {
-    hd: 2,
-    tl: {
-      hd: 3,
-      tl: 0
-    }
-  }
-};
-
-var anotherList = {
-  hd: 0,
-  tl: myList
-};
-```
-
-</CodeTab>
-
-`myList` didn't mutate. `anotherList` is now `list{0, 1, 2, 3}`. This is efficient (constant time, not linear). `anotherList`'s last 3 elements are shared with `myList`!
-
-**Note that `list{a, ...b, ...c}` was a syntax error** before compiler v10.1. In general, the pattern should be used with care as its performance and allocation overhead are linear (`O(n)`).
-
-#### Access
-
-`switch` (described in the [pattern matching section](pattern-matching-destructuring.md)) is usually used to access list items:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let message =
-  switch myList {
-  | list{} => "This list is empty"
-  | list{a, ...rest} => "The head of the list is the string " ++ Js.Int.toString(a)
-  }
-```
-```js
-var message = myList
-  ? "The head of the list is the string " + (1).toString()
-  : "This list is empty";
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v10.0.0/async-await.mdx b/pages/docs/manual/v10.0.0/async-await.mdx
deleted file mode 100644
index 0f53753f4..000000000
--- a/pages/docs/manual/v10.0.0/async-await.mdx
+++ /dev/null
@@ -1,338 +0,0 @@
----
-title: "Async / Await"
-description: "Async / await for asynchronous operations"
-canonical: "/docs/manual/latest/async-await"
----
-
-<!-- This prelude is used in many different followup examples, so we use it to shorten the noise of the example code. -->
-<div className="hidden">
-
-```res prelude
-@val external fetchUserMail: string => promise<string> = "GlobalAPI.fetchUserMail"
-@val external sendAnalytics: string => promise<unit> = "GlobalAPI.sendAnalytics"
-```
-
-</div>
-
-<!-- See https://github.com/cristianoc/rescript-compiler-experiments/pull/1#issuecomment-1131182023 for all async/await use-case examples -->
-
-# Async / Await
-
-**Since 10.1**
-
-ReScript comes with `async` / `await` support to make asynchronous, `Promise` based code easier to read and write. This feature is very similar to its JS equivalent, so if you are already familiar with JS' `async` / `await`, you will feel right at home.
-
-## How it looks 
-
-Let's start with a quick example to show-case the syntax:
-
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Some fictive functionality that offers asynchronous network actions
-@val external fetchUserMail: string => promise<string> = "GlobalAPI.fetchUserMail"
-@val external sendAnalytics: string => promise<unit> = "GlobalAPI.sendAnalytics"
-
-// We use the `async` keyword to allow the use of `await` in the function body
-let logUserDetails = async (userId: string) => {
-  // We use `await` to fetch the user email from our fictive user endpoint
-  let email = await fetchUserMail(userId)
-
-  await sendAnalytics(`User details have been logged for ${userId}`)
-
-  Js.log(`Email address for user ${userId}: ${email}`)
-}
-```
-
-```js
-async function logUserDetails(userId) {
-  var email = await GlobalAPI.fetchUserMail(userId);
-  await GlobalAPI.sendAnalytics("User details have been logged for " + userId + "");
-  console.log("Email address for user " + userId + ": " + email + "");
-}
-```
-
-</CodeTab>
-
-As we can see above, an `async` function is defined via the `async` keyword right before the function's parameter list. In the function body, we are now able to use the `await` keyword to explicitly wait for a `Promise` value and assign its content to a let binding `email`.
-
-You will probably notice that this looks very similar to `async` / `await` in JS, but there are still a few details that are specific to ReScript. The next few sections will go through all the details that are specific to the ReScript type system.
-
-## Basics
-
-- You may only use `await` in `async` function bodies
-- `await` may only be called on a `promise` value
-- `await` calls are expressions, therefore they can be used in pattern matching (`switch`)
-- A function returning a `promise<'a>` is equivalent to an `async` function returning a value `'a` (important for writing signature files and bindings)
-- `promise` values and types returned from an `async` function don't auto-collapse into a "flat promise" like in JS (more on this later)
-
-
-## Types and `async` functions
-
-### `async` function type signatures
-
-Function type signatures (i.e defined in signature files) don't require any special keywords for `async` usage. Whenever you want to type an `async` function, use a `promise` return type.
-
-```resi
-// Demo.resi
-
-let fetchUserMail: string => promise<string>
-```
-
-The same logic applies to type definitions in `.res` files:
-
-```res example
-// function type
-type someAsyncFn = int => promise<int>
-
-// Function type annotation
-let fetchData: string => promise<string> = async (userId) => {
-  await fetchUserMail(userId)
-}
-```
-
-**BUT:** When typing `async` functions in your implementation files, you need to omit the `promise<'a>` type:
-
-```res
-// This function is compiled into a `string => promise<string>` type.
-// The promise<...> part is implicitly added by the compiler.
-let fetchData = async (userId: string): string => {
-  await fetchUserMail("test")
-}
-```
-
-For completeness reasons, let's expand the full signature and inline type definitions in one code snippet:
-
-```res
-// Note how the inline return type uses `string`, while the type definition uses `promise<string>`
-let fetchData: string => promise<string> = async (userId: string): string {
-  await fetchUserMail(userId)
-}
-```
-
-**Note:** In a practical scenario you'd either use a type signature, or inline types, not both at the same time. In case you are interested in the design decisions, check out [this discussion](https://github.com/rescript-lang/rescript/pull/5913#issuecomment-1359003870).
-
-### `async` uncurried functions
-
-The `async` keyword does also work for uncurried functions.
-
-```res
-let fetchData = async (. userId: string): string {
-  await fetchUserMail(userId)
-}
-```
-
-### Promises don't auto-collapse in async functions
-
-In JS, nested promises (i.e. `promise<promise<'a>>`) will automatically collapse into a flat promise (`promise<'a>`). This is not the case in ReScript. Use the `await` function to manually unwrap any nested promises within an `async` function instead.
-
-```res
-let fetchData = async (userId: string): string => {
-  // We can't just return the result of `fetchUserMail`, otherwise we'd get a
-  // type error due to our function return type of type `string`
-  await fetchUserMail(userId)
-}
-```
-
-## Error handling
-
-You may use `try / catch` or `switch` to handle exceptions during async execution.
-
-```res
-// For simulation purposes
-let authenticate = async () => {
-  raise(Js.Exn.raiseRangeError("Authentication failed."))
-}
-
-let checkAuth = async () => {
-  try {
-    await authenticate()
-  } catch {
-  | Js.Exn.Error(e) =>
-    switch Js.Exn.message(e) {
-    | Some(msg) => Js.log("JS error thrown: " ++ msg)
-    | None => Js.log("Some other exception has been thrown")
-    }
-  }
-}
-```
-
-Note how we are essentially catching JS errors the same way as described in our [Exception](exception#catch-rescript-exceptions-from-js) section.
-
-You may unify error and value handling in a single switch as well:
-
-```res
-let authenticate = async () => {
-  raise(Js.Exn.raiseRangeError("Authentication failed."))
-}
-
-let checkAuth = async () => {
-  switch await authenticate() {
-  | _ => Js.log("ok")
-  | exception Js.Exn.Error(e) => 
-    switch Js.Exn.message(e) {
-    | Some(msg) => Js.log("JS error thrown: " ++ msg)
-    | None => Js.log("Some other exception has been thrown")
-    }
-  }
-}
-```
-
-**Important:** When using `await` with a `switch`, always make sure to put the actual await call in the `switch` expression, otherwise your `await` error will not be caught.
-
-## Piping `await` calls
-
-You may want to pipe the result of an `await` call right into another function.
-This can be done by wrapping your `await` calls in a new `{}` closure.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external fetchUserMail: string => promise<string> = "GlobalAPI.fetchUserMail"
-
-let fetchData = async () => {
-  let mail = {await fetchUserMail("1234")}->Js.String2.toUpperCase
-  Js.log(`All upper-cased mail: ${mail}`)
-}
-```
-
-```js
-async function fetchData(param) {
-  var mail = (await GlobalAPI.fetchUserMail("1234")).toUpperCase();
-  console.log("All upper-cased mail: " + mail + "");
-}
-```
-
-</CodeTab>
-
-Note how the original closure was removed in the final JS output. No extra allocations!
-
-## Pattern matching on `await` calls
-
-`await` calls are just another kind of expression, so you can use `switch` pattern matching for more complex logic.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external fetchUserMail: string => promise<string> = "GlobalAPI.fetchUserMail"
-
-let fetchData = async () => {
-  switch (await fetchUserMail("user1"), await fetchUserMail("user2")) {
-  | (user1Mail, user2Mail) => {
-      Js.log("user 1 mail: " ++ user1Mail)
-      Js.log("user 2 mail: " ++ user2Mail)
-    }
-
-  | exception JsError(err) => Js.log2("Some error occurred", err)
-  }
-}
-```
-
-```js
-async function fetchData(param) {
-  var val;
-  var val$1;
-  try {
-    val = await GlobalAPI.fetchUserMail("user1");
-    val$1 = await GlobalAPI.fetchUserMail("user2");
-  }
-  catch (raw_err){
-    var err = Caml_js_exceptions.internalToOCamlException(raw_err);
-    if (err.RE_EXN_ID === "JsError") {
-      console.log("Some error occurred", err._1);
-      return ;
-    }
-    throw err;
-  }
-  console.log("user 1 mail: " + val);
-  console.log("user 2 mail: " + val$1);
-}
-```
-
-</CodeTab>
-
-## `await` multiple promises
-
-We can utilize the `Js.Promise2` module to handle multiple promises. E.g. let's use `Js.Promise2.all` to wait for multiple promises before continuing the program:
-
-```res
-let pauseReturn = (value, timeout) => {
-  Js.Promise2.make((~resolve, ~reject) => {
-    Js.Global.setTimeout(() => {
-      resolve(. value)
-    }, timeout)->ignore
-  })
-}
-
-let logMultipleValues = async () => {
-  let promise1 = pauseReturn("value1", 2000)
-  let promise2 = pauseReturn("value2", 1200)
-  let promise3 = pauseReturn("value3", 500)
-
-  let all = await Js.Promise2.all([promise1, promise2, promise3])
-
-  switch all {
-  | [v1, v2, v3] => Js.log(`All values: ${v1}, ${v2}, ${v3}`)
-  | _ => Js.log("this should never happen")
-  }
-}
-```
-
-## JS Interop with `async` functions
-
-`async` / `await` practically works with any function that returns a `promise<'a>` value. Map your `promise` returning function via an `external`, and use it in an `async` function as usual.
-
-Here's a full example of using the MDN `fetch` API, using `async` / `await` to simulate a login:
-
-```res
-// A generic Response type for typing our fetch requests
-module Response = {
-  type t<'data>
-  @send external json: t<'data> => promise<'data> = "json"
-}
-
-// A binding to our globally available `fetch` function. `fetch` is a
-// standardized function to retrieve data from the network that is available in
-// all modern browsers.
-@val @scope("globalThis")
-external fetch: (
-  string,
-  'params,
-) => promise<Response.t<{"token": Js.Nullable.t<string>, "error": Js.Nullable.t<string>}>> =
-  "fetch"
-
-// We now use our asynchronous `fetch` function to simulate a login.
-// Note how we use `await` with regular functions returning a `promise`.
-let login = async (email: string, password: string) => {
-  let body = {
-    "email": email,
-    "password": password,
-  }
-
-  let params = {
-    "method": "POST",
-    "headers": {
-      "Content-Type": "application/json",
-    },
-    "body": Js.Json.stringifyAny(body),
-  }
-
-  try {
-    let response = await fetch("https://reqres.in/api/login", params)
-    let data = await response->Response.json
-
-    switch Js.Nullable.toOption(data["error"]) {
-    | Some(msg) => Error(msg)
-    | None =>
-      switch Js.Nullable.toOption(data["token"]) {
-      | Some(token) => Ok(token)
-      | None => Error("Didn't return a token")
-      }
-    }
-  } catch {
-  | _ => Error("Unexpected network error occurred")
-  }
-}
-```
-
diff --git a/pages/docs/manual/v10.0.0/attribute.mdx b/pages/docs/manual/v10.0.0/attribute.mdx
deleted file mode 100644
index 6392dccb9..000000000
--- a/pages/docs/manual/v10.0.0/attribute.mdx
+++ /dev/null
@@ -1,90 +0,0 @@
----
-title: "Attribute (Decorator)"
-description: "Annotations in ReScript"
-canonical: "/docs/manual/latest/attribute"
----
-
-# Attribute (Decorator)
-
-Like many other languages, ReScript allows annotating a piece of code to express extra functionality. Here's an example:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@inline
-let mode = "dev"
-
-let mode2 = mode
-```
-```js
-var mode2 = "dev";
-```
-
-</CodeTab>
-
-The `@inline` annotation tells `mode`'s value to be inlined into its usage sites (see output). We call such annotation "attribute" (or "decorator" in JavaScript).
-
-An attribute starts with `@` and goes before the item it annotates. In the above example, it's hooked onto the let binding.
-
-## Usage
-
-> **Note:** In previous versions (< 8.3) all our interop related attributes started with a `bs.` prefix (`bs.module`, `bs.val`). Our formatter will automatically drop them in newer ReScript versions.
-
-You can put an attribute almost anywhere. You can even add extra data to them by using them visually like a function call. Here are a few famous attributes (explained in other sections):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@@warning("-27")
-
-
-@unboxed
-type a = Name(string)
-
-@val external message: string = "message"
-
-type student = {
-  age: int,
-  @as("aria-label") ariaLabel: string,
-}
-
-@deprecated
-let customDouble = foo => foo * 2
-
-@deprecated("Use SomeOther.customTriple instead")
-let customTriple = foo => foo * 3 
-```
-```js
-```
-
-</CodeTab>
-
-1. `@@warning("-27")` is a standalone attribute that annotates the entire file. Those attributes start with `@@`. Here, it carries the data `"-27"`. You can find a full list of all available warnings [here](./warning-numbers).
-2. `@unboxed` annotates the type definition.
-3. `@val` annotates the `external` statement.
-4. `@as("aria-label")` annotates the `ariaLabel` record field.
-5. `@deprecated` annotates the `customDouble` expression. This shows a warning while compiling telling consumers to not rely on this method long-term.
-6. `@deprecated("Use SomeOther.customTriple instead")` annotates the `customTriple` expression with a string to describe the reason for deprecation.
-
-For a list of all decorators and their usage, please refer to the [Syntax Lookup](/syntax-lookup) page.
-
-## Extension Point
-
-There's a second category of attributes, called "extension points" (a remnant term of our early systems):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-%raw("var a = 1")
-```
-```js
-var a = 1
-```
-
-</CodeTab>
-
-Extension points are attributes that don't _annotate_ an item; they _are_ the item. Usually they serve as placeholders for the compiler to implicitly substitute them with another item.
-
-Extension points start with `%`. A standalone extension point (akin to a standalone regular attribute) starts with `%%`.
-
-For a list of all extension points and their usage, please refer to the [Syntax Lookup](/syntax-lookup) page.
\ No newline at end of file
diff --git a/pages/docs/manual/v10.0.0/bind-to-global-js-values.mdx b/pages/docs/manual/v10.0.0/bind-to-global-js-values.mdx
deleted file mode 100644
index 65038f1bf..000000000
--- a/pages/docs/manual/v10.0.0/bind-to-global-js-values.mdx
+++ /dev/null
@@ -1,145 +0,0 @@
----
-title: "Bind to Global JS Values"
-description: "JS interop with global JS values in ReScript"
-canonical: "/docs/manual/latest/bind-to-global-js-values"
----
-
-# Bind to Global JS Values
-
-**First**, make sure the value you'd like to model doesn't already exist in our [provided API](api/js).
-
-Some JS values, like `setTimeout`, live in the global scope. You can bind to them like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external setTimeout: (unit => unit, int) => float = "setTimeout"
-@val external clearTimeout: float => unit = "clearTimeout"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-(We already provide `setTimeout`, `clearTimeout` and others in the [Js.Global](api/js/global) module).
-
-This binds to the JavaScript [`setTimeout`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrworkerGlobalScope/setTimeout) methods and the corresponding `clearTimeout`. The `external`'s type annotation specifies that `setTimeout`:
-
-- Takes a function that accepts `unit` and returns `unit` (which on the JS side turns into a function that accepts nothing and returns nothing aka `undefined`),
-- and an integer that specifies the duration before calling said function,
-- returns a number that is the timeout's ID. This number might be big, so we're modeling it as a float rather than the 32-bit int.
-
-### Tips & Tricks
-
-**The above isn't ideal**. See how `setTimeout` returns a `float` and `clearTimeout` accepts one. There's no guarantee that you're passing the float created by `setTimeout` into `clearTimeout`! For all we know, someone might pass it `Math.random()` into the latter.
-
-We're in a language with a great type system now! Let's leverage a popular feature to solve this problem: abstract types.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type timerId
-@val external setTimeout: (unit => unit, int) => timerId = "setTimeout"
-@val external clearTimeout: timerId => unit = "clearTimeout"
-
-let id = setTimeout(() => Js.log("hello"), 100)
-clearTimeout(id)
-```
-```js
-var id = setTimeout(function (param) {
-  console.log("hello");
-}, 100);
-
-clearTimeout(id);
-```
-
-</CodeTab>
-
-Clearly, `timerId` is a type that can only be created by `setTimeout`! Now we've guaranteed that `clearTimeout` _will_ be passed a valid ID. Whether it's a number under the hood is now a mere implementation detail.
-
-Since `external`s are inlined, we end up with JS output as readable as hand-written JS.
-
-## Global Modules
-
-If you want to bind to a value inside a global module, e.g. `Math.random`, attach a `scope` to your `val` external:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@scope("Math") @val external random: unit => float = "random"
-let someNumber = random()
-```
-```js
-var someNumber = Math.random();
-```
-
-</CodeTab>
-
-you can bind to an arbitrarily deep object by passing a tuple to `scope`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val @scope(("window", "location", "ancestorOrigins"))
-external length: int = "length"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-This binds to `window.location.ancestorOrigins.length`.
-
-## Special Global Values
-
-Global values like `__filename` and `__DEV__` don't always exist; you can't even model them as an `option`, since the mere act of referring to them in ReScript (then compiled into JS) would trigger the usual `Uncaught ReferenceError: __filename is not defined` error in e.g. the browser environment.
-
-For these troublesome global values, ReScript provides a special approach: `%external(a_single_identifier)`.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch %external(__DEV__) {
-| Some(_) => Js.log("dev mode")
-| None => Js.log("production mode")
-}
-```
-```js
-var match = typeof __DEV__ === "undefined" ? undefined : __DEV__;
-
-if (match !== undefined) {
-  console.log("dev mode");
-} else {
-  console.log("production mode");
-}
-```
-
-</CodeTab>
-
-That first line's `typeof` check won't trigger a JS ReferenceError.
-
-Another example:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch %external(__filename) {
-| Some(f) => Js.log(f)
-| None => Js.log("non-node environment")
-};
-```
-```js
-var match = typeof (__filename) === "undefined" ? undefined : (__filename);
-
-if (match !== undefined) {
-  console.log(match);
-} else {
-  console.log("non-node environment");
-}
-```
-
-</CodeTab>
-
-<!-- TODO: revamp this page. Not good. Tell to use globalThis["foo"], and look in our stdlib -->
diff --git a/pages/docs/manual/v10.0.0/bind-to-js-function.mdx b/pages/docs/manual/v10.0.0/bind-to-js-function.mdx
deleted file mode 100644
index 891042463..000000000
--- a/pages/docs/manual/v10.0.0/bind-to-js-function.mdx
+++ /dev/null
@@ -1,502 +0,0 @@
----
-title: "Bind to JS Function"
-description: "JS interop with functions in ReScript"
-canonical: "/docs/manual/latest/bind-to-js-function"
----
-
-# Function
-
-Binding a JS function is like binding any other value:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// Import nodejs' path.dirname
-@module("path") external dirname: string => string = "dirname"
-let root = dirname("/User/github") // returns "User"
-```
-```js
-var Path = require("path");
-var root = Path.dirname("/User/github");
-```
-
-</CodeTab>
-
-We also expose a few special features, described below.
-
-## Labeled Arguments
-
-ReScript has [labeled arguments](function.md#labeled-arguments) (that can also be optional). These work on an `external` too! You'd use them to _fix_ a JS function's unclear usage. Assuming we're modeling this:
-
-```js
-// MyGame.js
-
-function draw(x, y, border) {
-   // suppose `border` is optional and defaults to false
-}
-draw(10, 20)
-draw(20, 20, true)
-```
-
-It'd be nice if on ReScript's side, we can bind & call `draw` while labeling things a bit:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("MyGame")
-external draw: (~x: int, ~y: int, ~border: bool=?, unit) => unit = "draw"
-
-draw(~x=10, ~y=20, ~border=true, ())
-draw(~x=10, ~y=20, ())
-```
-```js
-var MyGame = require("MyGame");
-
-MyGame.draw(10, 20, true);
-MyGame.draw(10, 20, undefined);
-```
-
-</CodeTab>
-
-We've compiled to the same function, but now the usage is much clearer on the ReScript side thanks to labels!
-
-**Note**: in this particular case, you need a unit, `()` after `border`, since `border` is an [optional argument at the last position](function.md#optional-labeled-arguments). Not having a unit to indicate you've finished applying the function would generate a warning.
-
-Note that you can freely reorder the labels on the ReScript side; they'll always correctly appear in their declaration order in the JavaScript output:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("MyGame")
-external draw: (~x: int, ~y: int, ~border: bool=?, unit) => unit = "draw"
-
-draw(~x=10, ~y=20, ())
-draw(~y=20, ~x=10, ())
-```
-```js
-var MyGame = require("MyGame");
-
-MyGame.draw(10, 20, undefined);
-MyGame.draw(10, 20, undefined);
-```
-
-</CodeTab>
-
-## Object Method
-
-Functions attached to JS objects (other than JS modules) require a special way of binding to them, using `send`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type document // abstract type for a document object
-@send external getElementById: (document, string) => Dom.element = "getElementById"
-@val external doc: document = "document"
-
-let el = getElementById(doc, "myId")
-```
-```js
-var el = document.getElementById("myId");
-```
-
-</CodeTab>
-
-In a `send`, the object is always the first argument. Actual arguments of the method follow (this is a bit what modern OOP objects are really).
-
-### Chaining
-
-Ever used `foo().bar().baz()` chaining ("fluent api") in JS OOP? We can model that in ReScript too, through the [pipe operator](pipe.md).
-
-## Variadic Function Arguments
-
-You might have JS functions that take an arbitrary amount of arguments. ReScript supports modeling those, under the condition that the arbitrary arguments part is homogenous (aka of the same type). If so, add `variadic` to your `external`.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("path") @variadic
-external join: array<string> => string = "join"
-
-let v = join(["a", "b"])
-```
-```js
-var Path = require("path");
-var v = Path.join("a", "b");
-```
-
-</CodeTab>
-
-`module` will be explained in [Import from/Export to JS](import-from-export-to-js.md).
-
-## Modeling Polymorphic Function
-
-Apart from the above special-case, JS function in general are often arbitrary overloaded in terms of argument types and number. How would you bind to those?
-
-### Trick 1: Multiple `external`s
-
-If you can exhaustively enumerate the many forms an overloaded JS function can take, simply bind to each differently:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("MyGame") external drawCat: unit => unit = "draw"
-@module("MyGame") external drawDog: (~giveName: string) => unit = "draw"
-@module("MyGame") external draw: (string, ~useRandomAnimal: bool) => unit = "draw"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Note how all three externals bind to the same JS function, `draw`.
-
-### Trick 2: Polymorphic Variant + `unwrap`
-
-If you have the irresistible urge of saying "if only this JS function argument was a variant instead of informally being either `string` or `int`", then good news: we do provide such `external` features through annotating a parameter as a polymorphic variant! Assuming you have the following JS function you'd like to bind to:
-
-```js
-function padLeft(value, padding) {
-  if (typeof padding === "number") {
-    return Array(padding + 1).join(" ") + value;
-  }
-  if (typeof padding === "string") {
-    return padding + value;
-  }
-  throw new Error(`Expected string or number, got '${padding}'.`);
-}
-```
-
-Here, `padding` is really conceptually a variant. Let's model it as such.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val
-external padLeft: (
-  string,
-  @unwrap [
-    | #Str(string)
-    | #Int(int)
-  ])
-  => string = "padLeft"
-padLeft("Hello World", #Int(4))
-padLeft("Hello World", #Str("Message from ReScript: "))
-```
-```js
-padLeft("Hello World", 4);
-padLeft("Hello World", "Message from ReScript: ");
-```
-
-</CodeTab>
-
-Obviously, the JS side couldn't have an argument that's a polymorphic variant! But here, we're just piggy backing on poly variants' type checking and syntax. The secret is the `@unwrap` annotation on the type. It strips the variant constructors and compile to just the payload's value. See the output.
-
-## Constrain Arguments Better
-
-Consider the Node `fs.readFileSync`'s second argument. It can take a string, but really only a defined set: `"ascii"`, `"utf8"`, etc. You can still bind it as a string, but we can use poly variants + `string` to ensure that our usage's more correct:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("fs")
-external readFileSync: (
-  ~name: string,
-  @string [
-    | #utf8
-    | @as("ascii") #useAscii
-  ],
-) => string = "readFileSync"
-
-readFileSync(~name="xx.txt", #useAscii)
-```
-```js
-var Fs = require("fs");
-Fs.readFileSync("xx.txt", "ascii");
-```
-
-</CodeTab>
-
-- Attaching `@string` to the whole poly variant type makes its constructor compile to a string of the same name.
-- Attaching a `@as("bla")` to a constructor lets you customize the final string.
-
-And now, passing something like `"myOwnUnicode"` or other variant constructor names to `readFileSync` would correctly error.
-
-Aside from string, you can also compile an argument to an int, using `int` instead of `string` in a similar way:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val
-external testIntType: (
-  @int [
-    | #onClosed
-    | @as(20) #onOpen
-    | #inBinary
-  ])
-  => int = "testIntType"
-testIntType(#inBinary)
-```
-```js
-testIntType(21);
-```
-
-</CodeTab>
-
-`onClosed` compiles to `0`, `onOpen` to `20` and `inBinary` to **`21`**.
-
-## Unknown for type safety
-
-It is best practice to inspect data received from untrusted external functions to ensure it contains what you expect. This helps avoid run-time crashes and unexpected behavior. If you're certain about what an external function returns, simply assert the return value as `string` or `array<int>` or whatever you want it to be. Otherwise use `unknown`. The ReScript type system will prevent you from using an `unknown` until you first inspect it and "convert" it using JSON parsing utilities or similar tools.
-
-Consider the example below of two external functions that access the value of a property on a JavaScript object. `getPropertyUnsafe` returns an `'a`, which means "anything you want it to be." ReScript allows you to use this value as a `string` or `array` or any other type. Quite convenient! But if the property is missing or contains something unexpected, your code might break. You can make the binding more safe by changing `'a` to `string` or `option<'a>`, but this doesn't completely eliminate the problem.
-
-The `getPropertySafe` function returns an `unknown`, which could be `null` or a `string` or anything else. But ReScript prevents you from using this value inappropriately until it has been safely parsed.
-
-```res example
-@get_index external getPropertyUnsafe: ({..}, string) => 'a = ""
-@get_index external getPropertySafe: ({..}, string) => unknown = ""
-
-let person = {"name": "Bob", "age": 12}
-
-let greeting1 = "Hello, " ++ getPropertyUnsafe(person, "name") // works (this time!)
-// let greeting2 = "Hello, " ++ getPropertySafe(person, "name") // syntax error
-```
-
-## Special-case: Event Listeners
-
-One last trick with polymorphic variants:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type readline
-
-@send
-external on: (
-    readline,
-    @string [
-      | #close(unit => unit)
-      | #line(string => unit)
-    ]
-  )
-  => readline = "on"
-
-let register = rl =>
-  rl
-  ->on(#close(event => ()))
-  ->on(#line(line => Js.log(line)));
-```
-```js
-function register(rl) {
-  return rl
-    .on("close", function($$event) {})
-    .on("line", function(line) {
-      console.log(line);
-    });
-}
-```
-
-</CodeTab>
-
-<!-- TODO: GADT phantom type -->
-
-## Fixed Arguments
-
-Sometimes it's convenient to bind to a function using an `external`, while passing predetermined argument values to the JS function:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val
-external processOnExit: (
-  @as("exit") _,
-  int => unit
-) => unit = "process.on"
-
-processOnExit(exitCode =>
-  Js.log("error code: " ++ Js.Int.toString(exitCode))
-);
-```
-```js
-process.on("exit", function (exitCode) {
-  console.log("error code: " + exitCode.toString());
-});
-```
-
-</CodeTab>
-
-The `@as("exit")` and the placeholder `_` argument together indicates that you want the first argument to compile to the string `"exit"`. You can also use any JSON literal with `as`: `` @as(json`true`) ``, `` @as(json`{"name": "John"}`) ``, etc.
-
-## Ignore arguments
-
-You can also explicitly "hide" `external` function parameters in the JS output, which may be useful if you want to add type constraints to other parameters without impacting the JS side:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@val external doSomething: (@ignore 'a, 'a) => unit = "doSomething"
-
-doSomething("this only shows up in ReScript code", "test")
-```
-
-```js
-doSomething("test");
-```
-
-</CodeTab>
-
-**Note:** It's a pretty niche feature, mostly used to map to polymorphic JS APIs.
-
-
-## Curry & Uncurry
-
-Curry is a delicious Indian dish. More importantly, in the context of ReScript (and functional programming in general), currying means that function taking multiple arguments can be applied a few arguments at time, until all the arguments are applied.
-
-See the `addFive` intermediate function? `add` takes in 3 arguments but received only 1. It's interpreted as "currying" the argument `5` and waiting for the next 2 arguments to be applied later on. Type signatures:
-
-```res sig
-let add: (int, int, int) => int
-let addFive: (int, int) => int
-let twelve: int
-```
-
-(In a dynamic language such as JS, currying would be dangerous, since accidentally forgetting to pass an argument doesn't error at compile time).
-
-### Drawback
-
-Unfortunately, due to JS not having currying because of the aforementioned reason, it's hard for ReScript multi-argument functions to map cleanly to JS functions 100% of the time:
-
-1. When all the arguments of a function are supplied (aka no currying), ReScript does its best to to compile e.g. a 3-arguments call into a plain JS call with 3 arguments.
-
-2. If it's too hard to detect whether a function application is complete\*, ReScript will use a runtime mechanism (the `Curry` module) to curry as many args as we can and check whether the result is fully applied.
-
-3. Some JS APIs like `throttle`, `debounce` and `promise` might mess with context, aka use the function `bind` mechanism, carry around `this`, etc. Such implementation clashes with the previous currying logic.
-
-\* If the call site is typed as having 3 arguments, we sometimes don't know whether it's a function that's being curried, or if the original one indeed has only 3 arguments.
-
-ReScript tries to do #1 as much as it can. Even when it bails and uses #2's currying mechanism, it's usually harmless.
-
-**However**, if you encounter #3, heuristics are not good enough: you need a guaranteed way of fully applying a function, without intermediate currying steps. We provide such guarantee through the use of the ["uncurrying" syntax](./function#uncurried-function) on a function declaration & call site.
-
-### Solution: Use Guaranteed Uncurrying
-
-[Uncurried function](function.md#uncurried-function) annotation also works on `external`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type timerId
-@val external setTimeout: ((. unit) => unit, int) => timerId = "setTimeout"
-
-let id = setTimeout((.) => Js.log("hello"), 1000)
-```
-```js
-var id = setTimeout(function () {
-  console.log("hello");
-}, 1000);
-```
-
-</CodeTab>
-
-#### Extra Solution
-
-The above solution is safe, guaranteed, and performant, but sometimes visually a little burdensome. We provide an alternative solution if:
-
-- you're using `external`
-- the `external` function takes in an argument that's another function
-- you want the user **not** to need to annotate the call sites with the dot
-
-<!-- TODO: is this up-to-date info? -->
-
-Then try `@uncurry`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@send external map: (array<'a>, @uncurry ('a => 'b)) => array<'b> = "map"
-map([1, 2, 3], x => x + 1)
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-In general, `uncurry` is recommended; the compiler will do lots of optimizations to resolve the currying to uncurrying at compile time. However, there are some cases the compiler can't optimize it. In these cases, it will be converted to a runtime check.
-
-## Modeling `this`-based Callbacks
-
-Many JS libraries have callbacks which rely on this (the source), for example:
-
-```js
-x.onload = function(v) {
-  console.log(this.response + v)
-}
-```
-
-Here, `this` would point to `x` (actually, it depends on how `onload` is called, but we digress). It's not correct to declare `x.onload` of type `(. unit) -> unit`. Instead, we introduced a special attribute, `this`, which allows us to type `x` as so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type x
-@val external x: x = "x"
-@set external setOnload: (x, @this ((x, int) => unit)) => unit = "onload"
-@get external resp: x => int = "response"
-setOnload(x, @this ((o, v) => Js.log(resp(o) + v)))
-```
-```js
-x.onload = function (v) {
-  var o = this;
-  console.log((o.response + v) | 0);
-};
-```
-
-</CodeTab>
-
-`this` has its first parameter is reserved for `this` and for arity of 0, there is no need for a redundant `unit` type.
-
-## Function Nullable Return Value Wrapping
-
-For JS functions that return a value that can also be `undefined` or `null`, we provide `@return(...)`. To automatically convert that value to an `option` type (recall that ReScript `option` type's `None` value only compiles to `undefined` and not `null`).
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type element
-type dom
-
-@send @return(nullable)
-external getElementById: (dom, string) => option<element> = "getElementById"
-
-let test = dom => {
-  let elem = dom->(getElementById("haha"))
-  switch (elem) {
-  | None => 1
-  | Some(_ui) => 2
-  }
-}
-```
-```js
-function test(dom) {
-  var elem = dom.getElementById("haha");
-  if (elem == null) {
-    return 1;
-  } else {
-    console.log(elem);
-    return 2;
-  }
-}
-
-```
-
-</CodeTab>
-
-`return(nullable)` attribute will automatically convert `null` and `undefined` to `option` type.
-
-Currently 4 directives are supported: `null_to_opt`, `undefined_to_opt`, `nullable` and `identity`.
-
-<!-- When the return type is unit: the compiler will append its return value with an OCaml unit literal to make sure it does return unit. Its main purpose is to make the user consume FFI in idiomatic OCaml code, the cost is very very small and the compiler will do smart optimizations to remove it when the returned value is not used (mostly likely). -->
-
-`identity` will make sure that compiler will do nothing about the returned value. It is rarely used, but introduced here for debugging purpose.
diff --git a/pages/docs/manual/v10.0.0/bind-to-js-object.mdx b/pages/docs/manual/v10.0.0/bind-to-js-object.mdx
deleted file mode 100644
index 1c50166ce..000000000
--- a/pages/docs/manual/v10.0.0/bind-to-js-object.mdx
+++ /dev/null
@@ -1,197 +0,0 @@
----
-title: "Bind to JS Object"
-description: "Interop with JS objects in ReScript"
-canonical: "/docs/manual/latest/bind-to-js-object"
----
-
-# Bind to JS Object
-
-JavaScript objects are a combination of several use-cases:
-
-- As a "record" or "struct" in other languages (like ReScript and C).
-- As a hash map.
-- As a class.
-- As a module to import/export.
-
-ReScript cleanly separates the binding methods for JS object based on these 4 use-cases. This page documents the first three. Binding to JS module objects is described in the [Import from/Export to JS](import-from-export-to-js.md) section.
-
-<!-- TODO: mention scope here too? -->
-
-## Bind to Record-like JS Objects
-
-### Bind Using ReScript Record
-
-If your JavaScript object has fixed fields, then it's conceptually like a ReScript record. Since a ReScript record compiles to a clean JavaScript object, you can definitely type a JS object as a ReScript record!
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type person = {
-  name: string,
-  friends: array<string>,
-  age: int,
-}
-
-@module("MySchool") external john: person = "john"
-
-let johnName = john.name
-```
-```js
-var MySchool = require("MySchool");
-
-var johnName = MySchool.john.name;
-```
-
-</CodeTab>
-
-External is documented [here](external.md). `@module` is documented [here](import-from-export-to-js.md).
-
-If you want or need to use different field names on the ReScript and the JavaScript side, you can use the `@as` decorator:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type action = {
-  @as("type") type_: string
-}
-
-let action = {type_: "ADD_USER"}
-```
-```js
-var action = {
-  type: "ADD_USER"
-};
-```
-
-</CodeTab>
-
-This is useful to map to JavaScript attribute names that cannot be expressed in ReScript (such as keywords).
-
-It is also possible to map a ReScript record to a JavaScript array by passing indices to the `@as` decorator:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type t = {
-  @as("0") foo: int,
-  @as("1") bar: string,
-}
-
-let value = {foo: 7, bar: "baz"}
-```
-
-```js
-var value = [
-  7,
-  "baz"
-];
-```
-
-</CodeTab>
-
-
-### Bind Using ReScript Object
-
-Alternatively, you can use [ReScript object](object.md) to model a JS object too:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type person = {
-  "name": string,
-  "friends": array<string>,
-  "age": int,
-}
-
-@module("MySchool") external john: person = "john"
-
-let johnName = john["name"]
-```
-```js
-var MySchool = require("MySchool");
-
-var johnName = MySchool.john.name;
-```
-
-</CodeTab>
-
-### Bind Using Special Getter and Setter Attributes
-
-Alternatively, you can use `get` and `set` to bind to individual fields of a JS object:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type textarea
-@set external setName: (textarea, string) => unit = "name"
-@get external getName: textarea => string = "name"
-```
-```js
-```
-
-</CodeTab>
-
-You can also use `get_index` and `set_index` to access a dynamic property or an index:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type t
-@new external create: int => t = "Int32Array"
-@get_index external get: (t, int) => int = ""
-@set_index external set: (t, int, int) => unit = ""
-
-let i32arr = create(3)
-i32arr->set(0, 42)
-Js.log(i32arr->get(0))
-```
-```js
-var i32arr = new Int32Array(3);
-i32arr[0] = 42;
-console.log(i32arr[0]);
-```
-
-</CodeTab>
-
-## Bind to Hash Map-like JS Object
-
-If your JavaScript object:
-
-- might or might not add/remove keys
-- contains only values that are of the same type
-
-Then it's not really an object, it's a hash map. Use [Js.Dict](api/js/dict), which contains operations like `get`, `set`, etc. and cleanly compiles to a JavaScript object still.
-
-## Bind to a JS Object That's a Class
-
-Use `new` to emulate e.g. `new Date()`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type t
-@new external createDate: unit => t = "Date"
-
-let date = createDate()
-```
-```js
-var date = new Date();
-```
-
-</CodeTab>
-
-You can chain `new` and `module` if the JS module you're importing is itself a class:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type t
-@new @module external book: unit => t = "Book"
-let myBook = book()
-```
-```js
-var Book = require("Book");
-var myBook = new Book();
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v10.0.0/browser-support-polyfills.mdx b/pages/docs/manual/v10.0.0/browser-support-polyfills.mdx
deleted file mode 100644
index c1de7a491..000000000
--- a/pages/docs/manual/v10.0.0/browser-support-polyfills.mdx
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: "Browser Support & Polyfills"
-description: "Note on browser support in ReScript"
-canonical: "/docs/manual/latest/browser-support-polyfills"
----
-
-# Browser Support & Polyfills
-
-ReScript compiles to JavaScript **ES5**, with the exception of optionally allowing to compile to ES6's module import & export.
-
-For [old browsers](https://caniuse.com/#search=typed%20array), you also need to polyfill TypedArray. The following standard library functions require it:
-
-- `Int64.float_of_bits`
-- `Int64.bits_of_float`
-- `Int32.float_of_bits`
-- `Int32.bits_of_float`
-
-If you don't use these functions, you're fine. Otherwise, it'll be a runtime failure.
diff --git a/pages/docs/manual/v10.0.0/build-configuration-schema.mdx b/pages/docs/manual/v10.0.0/build-configuration-schema.mdx
deleted file mode 100644
index 21e098dfb..000000000
--- a/pages/docs/manual/v10.0.0/build-configuration-schema.mdx
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: "Configuration Schema"
-metaTitle: "Build System Configuration Schema"
-description: "Schema exploration widget for the ReScript configuration file"
-canonical: "/docs/manual/latest/build-configuration-schema"
----
-
-import dynamic from "next/dynamic";
-
-export const Docson = dynamic(
-  () =>
-    import("src/components/Docson").then((comp) => {
-      return comp.make;
-    }),
-  {
-    ssr: false,
-    loading: () => <div> Loading... </div>,
-  }
-);
-
-export default function BuildConfigurationSchemaPage() {
-  return <Docson tag="master" />;
-}
diff --git a/pages/docs/manual/v10.0.0/build-configuration.mdx b/pages/docs/manual/v10.0.0/build-configuration.mdx
deleted file mode 100644
index cf73a1da4..000000000
--- a/pages/docs/manual/v10.0.0/build-configuration.mdx
+++ /dev/null
@@ -1,200 +0,0 @@
----
-title: "Configuration"
-metaTitle: "Build System Configuration"
-description: "Details about the configuration of the ReScript build system (bsconfig.json)"
-canonical: "/docs/manual/latest/build-configuration"
----
-
-# Configuration
-
-`bsconfig.json` is the single, mandatory build meta file needed for `rescript`.
-
-**The complete configuration schema is [here](./build-configuration-schema)**. We'll _non-exhaustively_ highlight the important parts in prose below.
-
-## name, namespace
-
-`name` is the name of the library, used as its "namespace". You can activate namespacing through `"namespace": true` in your `bsconfig.json`. Namespacing is almost **mandatory**; we haven't turned it on by default yet to preserve backward-compatibility.
-
-**Explanation**: by default, your files, once used as a third-party dependency, are available globally to the consumer. E.g. if you have an `Util.re` and the consumer also has a file of the same name, they will clash. Turning on `namespace` avoids this by wrapping all your own project's files into an extra module layer; instead of a global `Util` module, the consumer will see you as `MyProject.Util`. **The namespacing affects your consumers, not yourself**.
-
-Aka, in ReScript, "namespace" is just a fancy term for an auto-generated module that wraps all your project's files (efficiently and correctly, of course!) for third-party consumption.
-
-We don't do folder-level namespacing for your own project; all your own file names must be unique. This is a constraint that enables several features such as fast search and easier project reorganization.
-
-**Note**: the `bsconfig.json` `name` should be the same as the `package.json` `name`, to avoid confusing corner-cases. However, this means that you can't use a camelCased names such as `MyProject`, since `package.json` and npm forbid you to do so (some file systems are case-insensitive). To have the namespace/module as `MyProject`, write `"name": "my-project"`. ReScript will turn that into the camelCased name correctly.
-
-**Note on custom namespacing**: if for some reason, you need a namespace that is different from what your `name` will produce, you can directly send a string to the `namespace` option. For example, if your package is a binding named `bs-some-thing`, you can use `"namespace": "some-thing"` to get `SomeThing` namespace instead of `BsSomeThing`.
-
-## sources
-
-Your source files need to be specified explicitly (we don't want to accidentally drill down into some unrelated directories). Examples:
-
-```json
-{
-  "sources": ["src", "examples"]
-}
-```
-
-```json
-{
-  "sources": {
-    "dir": "src",
-    "subdirs": ["page"]
-  }
-}
-```
-
-```json
-{
-  "sources": [
-    "examples",
-    {
-      "dir": "src",
-      "subdirs": true // recursively builds every subdirectory
-    }
-  ]
-}
-```
-
-You can mark your directories as dev-only (for e.g. tests). These won't be built and exposed to third-parties, or even to other "dev" directories in the same project:
-
-```json
-{
-  "sources": {
-    "dir": "test",
-    "type": "dev"
-  }
-}
-```
-
-You can also explicitly allow which modules can be seen from outside. This feature is especially useful for library authors who want to have a single entry point for their users.  
-Here, the file `src/MyMainModule.res` is exposed to outside consumers, while all other files are private.
-
-```json
-{
-  "sources": {
-    "dir": "src",
-    "public": ["MyMainModule"]
-  }
-}
-```
-
-## bs-dependencies, bs-dev-dependencies
-
-List of ReScript dependencies. Just like `package.json`'s dependencies, they'll be searched in `node_modules`.
-
-Note that only sources marked with `"type":"dev"` will be able to resolve modules from `bs-dev-dependencies`.
-
-## pinned-dependencies
-
-**Since 8.4**: List of pinned dependencies. A pinned dependency will always be rebuilt whenever you build a toplevel package (e.g. your main app) with `rescript`.
-
-This is useful for working on multiple independent ReScript packages simultaneously. More usage details can be found in our dedicated [pinned dependencies](./build-pinned-dependencies) page.
-
-## external-stdlib
-
-**Since 9.0**: This setting allows depending on an externally built stdlib package (instead of a locally built stdlib runtime). Useful for shipping packages that are only consumed in JS or TS without any dependencies to the ReScript development toolchain.
-
-More details can be found on our [external stdlib](./build-external-stdlib) page.
-
-## reason, refmt (old)
-
-`reason` config is enabled by default. To turn on JSX for [ReasonReact](https://reasonml.github.io/reason-react/), specify:
-
-```json
-{
-  "reason": { "react-jsx": 3 },
-  "refmt": 3
-}
-```
-
-The `refmt` config **should be explicitly specified** as `3`.
-
-## js-post-build
-
-Hook that's invoked every time a file is recompiled. Good for JS build system interop, but please use it **sparingly**. Calling your custom command for every recompiled file slows down your build and worsens the building experience for even third-party users of your lib.
-
-Example:
-
-```json
-{
-  "js-post-build": {
-    "cmd": "/path/to/node ../../postProcessTheFile.js"
-  }
-}
-```
-
-Note that the path resolution for the command (`node` in this case) is done so:
-
-- `/myCommand` is resolved into `/myCommand`
-- `package/myCommand` is resolved into `node_modules/package/myCommand`
-- `./myCommand` is resolved into `myProjectRoot/myCommand`
-- `myCommand` is just called as `myCommand`, aka a globally available executable. But note that ReScript doesn't read into your shell's environment, so if you put e.g. `node`, it won't find it unless you specify an absolute path. Alternatively, add `#!/usr/local/bin/node` to the top of your script to directly call it without prepending `node`.
-
-The command itself is called from inside `lib/bs`.
-
-## package-specs
-
-Output to either CommonJS (the default) or ES6 modules. Example:
-
-```json
-{
-  "package-specs": {
-    "module": "commonjs",
-    "in-source": true
-  }
-}
-```
-
-- `"module": "es6-global"` resolves `node_modules` using relative paths. Good for development-time usage of ES6 in conjunction with browsers like Safari and Firefox that support ES6 modules today. **No more dev-time bundling**!
-- `"in-source": true` generates output alongside source files. If you omit it, it'll generate the artifacts into `lib/js`. The output directory is not configurable otherwise.
-
-This configuration only applies to you, when you develop the project. When the project is used as a third-party library, the consumer's own `bsconfig.json` `package-specs` overrides the configuration here, logically.
-
-## suffix
-
-Either `".js"`, `".mjs"`, `".cjs"` or `".bs.js"`. Currently prefer `bs.js` for now.
-
-### Design Decisions
-
-Generating JS files with the `.bs.js` suffix means that, on the JS side, you can do `const myReScriptFile = require('./theFile.bs')`. The benefits:
-
-- It's immediately clear that we're dealing with a generated JS file here.
-- It avoids clashes with a potential `theFile.js` file in the same folder.
-- It avoids the need of using a build system loader for ReScript files. This + in-source build means integrating a ReScript project into your pure JS codebase **basically doesn't touch anything in your build pipeline at all**.
-- [genType](/docs/manual/latest/typescript-integration) requires `bs.js` for compiled JS artifacts. If you are using `genType`, you need to use `bs.js` for now.
-
-## warnings
-
-Selectively turn on/off certain warnings and/or turn them into hard errors. Example:
-
-```json
-{
-  "warnings": {
-    "number": "-44-102",
-    "error": "+5"
-  }
-}
-```
-
-Turn off warning `44` and `102` (polymorphic comparison). Turn warning `5` (partial application whose result has function type and is ignored) into a hard error.
-
-The warning numbers are shown in the build output when they're triggered. See [Warning Numbers](./warning-numbers) for the complete list.
-
-## bsc-flags
-
-Extra flags to pass to the compiler. For advanced usages.
-
-## Environment Variables
-
-We heavily disrecommend the usage of environment variables, but for certain cases, they're justified.
-
-### Error Output Coloring: `NINJA_ANSI_FORCED`
-
-This is mostly for other programmatic usage of `rescript` where outputting colors is not desired.
-
-When `NINJA_ANSI_FORCED` is set to `1`: `rescript` produces color.
-When `NINJA_ANSI_FORCED` is set to `0`: `rescript` doesn't produce color.
-When `NINJA_ANSI_FORCED` is not set: `rescript` might or might not produce color, depending on a smart detection of where it's outputted.
-
-> Note that the underlying compiler will always be passed `-color always`. See more details in [this issue](https://github.com/rescript-lang/rescript/issues/2984#issuecomment-410669163).
diff --git a/pages/docs/manual/v10.0.0/build-external-stdlib.mdx b/pages/docs/manual/v10.0.0/build-external-stdlib.mdx
deleted file mode 100644
index d11eaa7a0..000000000
--- a/pages/docs/manual/v10.0.0/build-external-stdlib.mdx
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: "External Stdlib"
-metaTitle: "External Stdlib"
-description: "Configuring an external ReScript stdlib package"
-canonical: "/docs/manual/latest/build-external-stdlib"
----
-
-# External Stdlib
-
-**Since 9.0**
-
-Your ReScript project depends on the `rescript` package as a [`devDependency`](https://docs.npmjs.com/specifying-dependencies-and-devdependencies-in-a-package-json-file), which includes our compiler, build system and runtime like `Belt`. However, you had to move it to `dependency` in `package.json` if you publish your code:
-- To Docker or other low-storage deployment devices.
-- For pure JS/TS consumers who probably won't install `bs-platform` in their own project.
-
-In these cases, the size or mere presence of `bs-platform` can be troublesome, since it includes not just our necessary runtime like `Belt`, but also our compiler and build system.
-
-To solve that, we now publish our runtime as a standalone package at [`@rescript/std`](https://www.npmjs.com/package/@rescript/std), whose versions mirror `bs-platform`'s. Now you can keep `bs-platform` as a `devDependency` and have only `@rescript/std` as your runtime `dependency`.
-
-**This is an advanced feature**. Please only use it in the aforementioned scenarios. If you already use a JS bundler with dead code elimination, you might not need this feature.
-
-## Configuration
-
-Say you want to publish a JS-only ReScript 9.0 library. Install the packages like this:
-
-```sh
-npm install bs-platform@9.0.0 --save-dev
-npm install @rescript/std@9.0.0
-```
-
-Then add this to `bsconfig.json`:
-
-```json
-{
-  // ...
-  "external-stdlib" : "@rescript/std"
-}
-```
-
-Now the compiled JS code will import using the path defined by `external-stdlib`. Check the JS output tab:
-
-<CodeTab labels={["ReScript", "JS output"]}>
-
-```res
-Belt.Array.forEach([1, 2, 3], num => Js.log(num))
-```
-
-```js
-// Note the require path starting with "@rescript/std".
-var Belt_Array = require("@rescript/std/lib/js/belt_Array.js");
-
-Belt_Array.forEach([1, 2, 3], function (num) {
-  console.log(num);
-});
-```
-
-</CodeTab>
-
-**Make sure the version number of `bs-platform` and `@rescript/std` match in your `package.json`** to avoid running into runtime issues due to mismatching stdlib assumptions.
diff --git a/pages/docs/manual/v10.0.0/build-overview.mdx b/pages/docs/manual/v10.0.0/build-overview.mdx
deleted file mode 100644
index 0788a8ed6..000000000
--- a/pages/docs/manual/v10.0.0/build-overview.mdx
+++ /dev/null
@@ -1,72 +0,0 @@
----
-title: "Overview"
-metaTitle: "Build System Overview"
-description: "Documentation about the ReScript build system and its toolchain"
-canonical: "/docs/manual/latest/build-overview"
----
-
-# Build System Overview
-
-ReScript comes with a build system, [`rescript`](https://www.npmjs.com/package/rescript), that's fast, lean and used as the authoritative build system of the community.
-
-Every ReScript project needs a build description file, `bsconfig.json`.
-
-## Options
-
-See `rescript -help`:
-
-```
-❯ rescript -help
-Available flags
--v, -version  display version number
--h, -help     display help
-Subcommands:
-    build
-    clean
-    format
-    convert
-    help
-Run rescript subcommand -h for more details,
-For example:
-    rescript build -h
-    rescript format -h
-The default `rescript` is equivalent to `rescript build` subcommand
-```
-
-## Build Project
-
-Each build will create build artifacts from your project's source files.
-
-**To build a project (including its dependencies / pinned-dependencies)**, run:
-
-```sh
-rescript
-```
-
-Which is an alias for `rescript build`.
-
-To keep a build watcher, run:
-
-```sh
-rescript build -w
-```
-
-Any new file change will be picked up and the build will re-run.
-
-**Note**: third-party libraries (in `node_modules`, or via `pinned-dependencies`) aren't watched, as doing so may exceed the node.js watcher count limit.
-
-**Note 2**: In case you want to set up a project in a JS-monorepo-esque approach (`npm` and `yarn` workspaces) where changes in your sub packages should be noticed by the build, you will need to define pinned dependencies in your main project's `bsconfig.json`. More details [here](./build-pinned-dependencies).
-
-## Clean Project
-
-If you ever get into a stale build for edge-case reasons, use:
-
-```sh
-rescript clean
-```
-
-This will clean your own project's build artifacts. To also clean the dependencies' artifacts:
-
-```sh
-rescript clean -with-deps
-```
diff --git a/pages/docs/manual/v10.0.0/build-performance.mdx b/pages/docs/manual/v10.0.0/build-performance.mdx
deleted file mode 100644
index 350443458..000000000
--- a/pages/docs/manual/v10.0.0/build-performance.mdx
+++ /dev/null
@@ -1,85 +0,0 @@
----
-title: "Performance"
-metaTitle: "Build Performance"
-description: "ReScript build performance and measuring tools"
-canonical: "/docs/manual/latest/build-performance"
----
-
-# Build Performance
-
-ReScript considers performance at install time, build time and run time as a serious feature; it's one of those things you don't notice until you realize it's missing.
-
-## Profile Your Build
-
-Sometime your build can be slow due to some confused infra setups. We provide an interactive visualization of your build's performance via `bstracing`:
-
-```sh
-./node_modules/.bin/bstracing
-```
-
-Run the above command at your ReScript project's root; it'll spit out a JSON file you can drag and drop into `chrome://tracing`.
-
-import Image from "src/components/Image";
-
-<Image withShadow={true} src="/static/img/bstracing.png" caption="Screenshot of bstracing result"/>
-
-## Under the Hood
-
-ReScript itself uses a build system under the hood, called [Ninja](https://ninja-build.org). Ninja is like Make, but cross-platform, minimal, focuses in perf and destined to be more of a low-level building block than a full-blown build system. In this regard, Ninja's a great implementation detail for `rescript`.
-
-ReScript reads into `bsconfig.json` and generates the Ninja build file in `lib/bs`. The file contains the low-level compiler commands, namespacing rules, intermediate artifacts generation & others. It then runs `ninja` for the actual build.
-
-## The JS Wrapper
-
-`rescript` itself is a Node.js wrapper which takes care of some miscellaneous tasks, plus the watcher. The lower-level, watcher-less, fast native `rescript` is called `rescript.exe`. It's located at `node_modules/rescript/{your-platform}/rescript.exe`.
-
-If you don't need the watcher, you can run said `rescript.exe`. This side-steps Node.js' long startup time, which can be in the order of `100ms`. Our editor plugin finds and uses this native `rescript.exe` for better performance.
-
-## Numbers
-
-Raw `rescript.exe` build on a small project should be around `70ms`. This doubles when you use the JS `rescript` wrapper which comes with a watcher, which is practically faster since you don't manually run the build at every change (though you should opt for the raw `rescript.exe` for programmatic usage, e.g. inserting rescript into your existing JS build pipeline).
-
-No-op build (when no file's changed) should be around `15ms`. Incremental rebuild (described soon) of a single file in a project is around `70ms` too.
-
-Cleaning the artifacts should be instantaneous.
-
-### Extreme Test
-
-We've stress-tested `rescript.exe` on a big project of 10,000 files (2 directories, 5000 files each, first 5000 no dependencies, last 5000 10 dependencies on files from the former directory) using https://github.com/rescript-lang/build-benchmark, on a Retina Macbook Pro Early 2015 (3.1 GHz Intel Core i7).
-
-<!-- TODO: better repro -->
-
-- No-op build of 10k files: `800ms` (the minimum amount of time required to check the mtimes of 10k files).
-- Clean build: \<3 minutes.
-- Incremental build: depends on the number of the dependents of the file. No dependent means `1s`.
-
-### Stability
-
-`rescript` is a file-based build system. We don't do in-memory build, even if that speeds up the build a lot. In-memory builds risk memory leaks, out-of-memory errors, corrupt halfway build and others. Our watcher mode stays open for days or months with no leak.
-
-The watcher is also just a thin file watcher that calls `rescript.exe`. We don't like babysitting daemon processes.
-
-## Incrementality & Correctness
-
-ReScript doesn't take whole seconds to run every time. The bulk of the build performance comes from incremental build, aka re-building a previously built project when a few files changed.
-
-In short, thanks to our compiler and the build system's architecture, we're able to **only build what's needed**. E.g. if `MyFile.res` isn't changed, then it's not recompiled. You can roughly emulate such incrementalism in languages like JavaScript, but the degree of correctness is unfortunately low. For example, if you rename or move a JS file, then the watcher might get confused and not pick up the "new" file or fail to clean things up correctly, resulting in you needing to clean your build and restart anew, which defeats the purpose.
-
-Say goodbye to stale build from your JavaScript ecosystem!
-
-## Speed Up Incremental Build
-
-ReScript uses the concept of interface files (`.resi`) (or, equivalently, [module signatures](module.md#signatures)). Exposing only what you need naturally speeds up incremental builds. E.g. if you change a `.res` file whose corresponding `.resi` file doesn't expose the changed part, then you've reduced the amount of dependent files you have to rebuild.
-
-## Programmatic Usage
-
-Unfortunately, JS build systems are usually the bottleneck for building a JS project nowadays. Having parts of the build blazingly fast doesn't matter much if the rest of the build takes seconds or literally minutes. Here are a few suggestions:
-
-- Convert more files into ReScript =). Fewer files going through fewer parts of the JS pipeline helps a ton.
-- Careful with bringing in more dependencies: libraries, syntax transforms (e.g. the unofficially supported PPX), build step loaders, etc. The bulk of these dragging down the editing & building experience might out-weight the API benefits they provide.
-
-## Hot Reloading
-
-Hot reloading refers to maintaining a dev server and listening to file changes in a way that allows the server to pipe some delta changes right into the currently running browser page. This provides a relatively fast iteration workflow while working in specific frameworks.
-
-However, hot reloading is fragile by nature, and counts on the occasional inconsistencies (bad state, bad eval, etc.) and the heavy devserver setup/config being less of a hassle than the benefits it provides. We err on the side of caution and stability in general, and decided not to provide a built-in hot reloading _yet_. **Note**: you can still use the hot reloading facility provided by your JS build pipeline.
diff --git a/pages/docs/manual/v10.0.0/build-pinned-dependencies.mdx b/pages/docs/manual/v10.0.0/build-pinned-dependencies.mdx
deleted file mode 100644
index 53fe31f58..000000000
--- a/pages/docs/manual/v10.0.0/build-pinned-dependencies.mdx
+++ /dev/null
@@ -1,112 +0,0 @@
----
-title: "Pinned Dependencies"
-metaTitle: "Pinned Dependencies"
-description: "Handling multiple packages within one ReScript project with pinned dependencies"
-canonical: "/docs/manual/latest/build-pinned-dependencies"
----
-
-# Pinned Dependencies
-
-**Since 8.4**
-
-Usually we'd recommend to use ReScript in a single-codebase style by using one `bsconfig.json` file for your whole codebase.
-
-There are scenarios where you still want to connect and build multiple independent ReScript packages for one main project though (`npm` workspaces-like "monorepos"). This is where `pinned-dependencies` come into play.
-
-## Package Types
-
-Before we go into detail, let's first explain all the different package types recognized by the build system:
-
-- Toplevel (this is usually the final app you are building, which has dependencies to other packages)
-- Pinned dependencies (these are your local packages that should always rebuild when you build your toplevel, those should be listed in `bs-dependencies` and `pinned-dependencies`)
-- Normal dependencies (these are packages that are consumed from npm and listed via `bs-dependencies`)
-
-Whenever a package is being built (`rescript build`), the build system will build the toplevel package with its pinned-dependencies. So any changes made in a pinned dependency will automatically be reflected in the final app.
-
-## Build System Package Rules
-
-The build system respects the following rules for each package type:
-
-**Toplevel**
-- Warnings reported
-- Warn-error respected
-- Builds dev dependencies
-- Builds pinned dependencies
-- Runs custom rules
-- Package-specs like ES6/CommonJS overrides all its dependencies
-
-**Pinned dependencies**
-- Warnings reported
-- Warn-error respected
-- Ignores pinned dependencies
-- Builds dev dependencies
-- Runs custom rules
-
-**Normal dependencies**
-- Warnings, warn-error ignored
-- Ignores dev directories
-- Ignores pinned dependencies
-- Ignores custom generator rules
-
-So with that knowledge in mind, let's dive into some more concrete examples to see our pinned dependencies in action.
-
-## Examples
-
-### Yarn workspaces
-
-Let's assume we have a codebase like this:
-
-```
-myproject/
-  app/
-   - src/App.res
-   - bsconfig.json
-  common/
-   - src/Header.res
-   - bsconfig.json
-  myplugin/
-   - src/MyPlugin.res
-   - bsconfig.json
-  package.json
-```
-
-Our `package.json` file within our codebase root would look like this:
-
-```json
-{
-  "name": "myproject",
-  "private": true,
-  "workspaces": {
-    "packages": [
-      "app",
-      "common",
-      "myplugin"
-    ]
-  }
-}
-```
-
-
-Our `app` folder would be our toplevel package, consuming our `common` and `myplugin` packages as `pinned-dependencies`. The configuration for `app/bsconfig.json` looks like this:
-
-```json
-{
-  "name": "app",
-  "version": "1.0.0",
-  "sources": {
-    "dir" : "src",
-    "subdirs" : true
-  },
-  /* ... */
-  "bs-dependencies": [
-    "common",
-    "myplugin"
-  ],
-  "pinned-dependencies": ["common", "myplugin"],
-  /* ... */
-}
-```
-
-Now, whenever we are running `rescript build` within our `app` package, the compiler would always rebuild any changes within its pinned dependencies as well.
-
-**Important:** ReScript will not rebuild any `pinned-dependencies` in watch mode! This is due to the complexity of file watching, so you'd need to set up your own file-watcher process that runs `rescript build` on specific file changes.
diff --git a/pages/docs/manual/v10.0.0/control-flow.mdx b/pages/docs/manual/v10.0.0/control-flow.mdx
deleted file mode 100644
index a7d391534..000000000
--- a/pages/docs/manual/v10.0.0/control-flow.mdx
+++ /dev/null
@@ -1,211 +0,0 @@
----
-title: "If-Else & Loops"
-description: "If, else, ternary, for, and while"
-canonical: "/docs/manual/latest/control-flow"
----
-
-# If-Else & Loops
-
-ReScript supports `if`, `else`, ternary expression (`a ? b : c`), `for` and `while`.
-
-ReScript also supports our famous pattern matching, which will be covered in [its own section](pattern-matching-destructuring.md)
-
-## If-Else & Ternary
-
-Unlike its JavaScript counterpart, ReScript's `if` is an expression; they evaluate to their body's content:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let message = if isMorning {
-  "Good morning!"
-} else {
-  "Hello!"
-}
-```
-```js
-var message = isMorning ? "Good morning!" : "Hello!";
-```
-
-</CodeTab>
-
-**Note:** an `if-else` expression without the final `else` branch implicitly gives `()` (aka the `unit` type). So this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-if showMenu {
-  displayMenu()
-}
-```
-```js
-if (showMenu) {
-  displayMenu();
-}
-```
-
-</CodeTab>
-
-is basically the same as:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-if showMenu {
-  displayMenu()
-} else {
-  ()
-}
-```
-```js
-if (showMenu) {
-  displayMenu()
-}
-```
-
-</CodeTab>
-
-Here's another way to look at it. This is clearly wrong:
-
-```res
-let result = if showMenu {
-  1 + 2
-}
-```
-
-It'll give a type error, saying basically that the implicit `else` branch has the type `unit` while the `if` branch has type `int`. Intuitively, this makes sense: what would `result`'s value be, if `showMenu` was `false`?
-
-We also have ternary sugar, but **we encourage you to prefer if-else when possible**.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let message = isMorning ? "Good morning!" : "Hello!"
-```
-```js
-var message = isMorning ? "Good morning!" : "Hello!";
-```
-
-</CodeTab>
-
-**`if-else` and ternary are much less used** in ReScript than in other languages; [Pattern-matching](pattern-matching-destructuring.md) kills a whole category of code that previously required conditionals.
-
-## For Loops
-
-For loops iterate from a starting value up to (and including) the ending value.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-for i in startValueInclusive to endValueInclusive {
-  Js.log(i)
-}
-```
-```js
-for(var i = startValueInclusive; i <= endValueInclusive; ++i){
-  console.log(i);
-}
-```
-
-</CodeTab>
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// prints: 1 2 3, one per line
-for x in 1 to 3 {
-  Js.log(x)
-}
-```
-```js
-for(var x = 1; x <= 3; ++x){
-  console.log(x);
-}
-```
-
-</CodeTab>
-
-You can make the `for` loop count in the opposite direction by using `downto`.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-for i in startValueInclusive downto endValueInclusive {
-  Js.log(i)
-}
-```
-```js
-for(var i = startValueInclusive; i >= endValueInclusive; --i){
-  console.log(i);
-}
-```
-
-</CodeTab>
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// prints: 3 2 1, one per line
-for x in 3 downto 1 {
-  Js.log(x)
-}
-```
-```js
-for(var x = 3; x >= 1; --x){
-  console.log(x);
-}
-```
-
-</CodeTab>
-
-## While Loops
-
-While loops execute its body code block while its condition is true.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-while testCondition {
-  // body here
-}
-```
-```js
-while (testCondition) {
-  // body here
-}
-```
-
-</CodeTab>
-
-### Tips & Tricks
-
-There's no loop-breaking `break` keyword (nor early `return` from functions, for that matter) in ReScript. However, we can break out of a while loop easily through using a [mutable binding](mutation.md).
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let break = ref(false)
-
-while !break.contents {
-  if Js.Math.random() > 0.3 {
-    break := true
-  } else {
-    Js.log("Still running")
-  }
-}
-```
-```js
-var $$break = {
-  contents: false
-};
-
-while(!$$break.contents) {
-  if (Math.random() > 0.3) {
-    $$break.contents = true;
-  } else {
-    console.log("Still running");
-  }
-};
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v10.0.0/converting-from-js.mdx b/pages/docs/manual/v10.0.0/converting-from-js.mdx
deleted file mode 100644
index df1dfdb2d..000000000
--- a/pages/docs/manual/v10.0.0/converting-from-js.mdx
+++ /dev/null
@@ -1,303 +0,0 @@
----
-title: "Converting from JS"
-description: "How to convert to ReScript with an existing JS codebase"
-canonical: "/docs/manual/latest/converting-from-js"
----
-
-# Converting from JS
-
-ReScript offers a unique project conversion methodology which:
-- Ensures minimal disruption to your teammates (very important!).
-- Remove the typical friction of verifying conversion's correctness and performance guarantees.
-- Doesn't force you to search for pre-made binding libraries made by others. **ReScript doesn't need the equivalent of TypeScript's `DefinitelyTyped`**.
-
-## Step 1: Install ReScript
-
-Run `npm install rescript` on your project, then imitate our [New Project](installation#new-project) workflow by adding a `bsconfig.json` at the root. Then start `npx rescript build -w`.
-
-## Step 2: Copy Paste the Entire JS File
-
-Let's work on converting a file called `src/main.js`.
-
-```js
-const school = require('school');
-
-const defaultId = 10;
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-```
-
-First, copy the entire file content over to a new file called `src/Main.res` by using our [`%%raw` JS embedding trick](embed-raw-javascript):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-%%raw(`
-const school = require('school');
-
-const defaultId = 10;
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-`)
-```
-```js
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-const school = require('school');
-
-const defaultId = 10;
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-
-/*  Not a pure module */
-```
-
-</CodeTab>
-
-Add this file to `bsconfig.json`:
-
-```json
-  "sources": {
-    "dir" : "src",
-    "subdirs" : true
-  },
-```
-
-Open an editor tab for `src/Main.bs.js`. Do a command-line `diff -u src/main.js src/Main.bs.js`. Aside from whitespaces, you should see only minimal, trivial differences. You're already a third of the way done!
-
-**Always make sure** that at each step, you keep the ReScript output `.bs.js` file open to compare against the existing JavaScript file. Our compilation output is very close to your hand-written JavaScript; you can simply eye the difference to catch conversion bugs!
-
-## Step 3: Extract Parts into Idiomatic ReScript
-
-Let's turn the `defaultId` variable into a ReScript let-binding:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let defaultId = 10
-
-%%raw(`
-const school = require('school');
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-`)
-```
-```js
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-const school = require('school');
-
-function queryResult(usePayload, payload) {
-  if usePayload {
-    return payload.student
-  } else {
-    return school.getStudentById(defaultId)
-  }
-}
-
-var defaultId = 10;
-
-exports.defaultId = defaultId;
-/*  Not a pure module */
-```
-
-</CodeTab>
-
-Check the output. Diff it. Code still works. Moving on! Extract the function:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-%%raw(`
-const school = require('school');
-`)
-
-let defaultId = 10
-
-let queryResult = (usePayload, payload) => {
-  if usePayload {
-    payload.student
-  } else {
-    school.getStudentById(defaultId)
-  }
-}
-```
-```js
-```
-
-</CodeTab>
-
-Format the code: `./node_modules/.bin/rescript format src/Main.res`.
-
-We have a type error: "The record field student can't be found". That's fine! **Always ensure your code is syntactically valid first**. Fixing type errors comes later.
-
-## Step 4: Add `external`s, Fix Types
-
-The previous type error is caused by `payload`'s record declaration (which supposedly contains the field `student`) not being found. Since we're trying to convert as quickly as possible, let's use our [object](object) feature to avoid needing type declaration ceremonies:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-%%raw(`
-const school = require('school');
-`)
-
-let defaultId = 10
-
-let queryResult = (usePayload, payload) => {
-  if usePayload {
-    payload["student"]
-  } else {
-    school["getStudentById"](. defaultId)
-  }
-}
-```
-```js
-```
-
-</CodeTab>
-
-Now this triggers the next type error, that `school` isn't found. Let's use [`external`](external) to bind to that module:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module external school: 'whatever = "school"
-
-let defaultId = 10
-
-let queryResult = (usePayload, payload) => {
-  if usePayload {
-    payload["student"]
-  } else {
-    school["getStudentById"](. defaultId)
-  }
-}
-```
-```js
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-var School = require("school");
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return School.getStudentById(10);
-  }
-}
-
-var defaultId = 10;
-
-exports.defaultId = defaultId;
-exports.queryResult = queryResult;
-/* school Not a pure module */
-```
-
-</CodeTab>
-
-We hurrily typed `school` as a polymorphic `'whatever` and let its type be inferred by its usage below. The inference is technically correct, but within the context of bringing it a value from JavaScript, slightly dangerous. This is just the interop trick we've shown in the [`external`](external) page.
-
-Anyway, the file passes the type checker again. Check the `.bs.js` output, diff with the original `.js`; we've now converted a file over to ReScript!
-
-Now, you can delete the original, hand-written `main.js` file, and grep the files importing `main.js` and change them to importing `Main.bs.js`.
-
-## (Optional) Step 5: Cleanup
-
-If you prefer more advanced, rigidly typed `payload` and `school`, feel free to do so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type school
-type student
-type payload = {
-  student: student
-}
-
-@module external school: school = "school"
-@send external getStudentById: (school, int) => student = "getStudentById"
-
-let defaultId = 10
-
-let queryResult = (usePayload, payload) => {
-  if usePayload {
-    payload.student
-  } else {
-    school->getStudentById(defaultId)
-  }
-}
-```
-```js
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-var School = require("school");
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return School.getStudentById(10);
-  }
-}
-
-var defaultId = 10;
-
-exports.defaultId = defaultId;
-exports.queryResult = queryResult;
-/* school Not a pure module */
-```
-
-</CodeTab>
-
-We've:
-- introduced an opaque types for `school` and `student` to prevent misusages their values
-- typed the payload as a record with only the `student` field
-- typed `getStudentById` as the sole method of `student`
-
-Check that the `.bs.js` output didn't change. How rigidly to type your JavaScript code is up to you; we recommend not typing them too elaborately; it's sometime an endless chase, and produces diminishing returns, especially considering that the elaborate-ness might turn off your potential teammates.
-
-## Tips & Tricks
-
-In the same vein of idea, **resist the urge to write your own wrapper functions for the JS code you're converting**. Use [`external`s](external), which are guaranteed to be erased in the output. And avoid trying to take the occasion to convert JS data structures into ReScript-specific data structures like variant or list. **This isn't the time for that**.
-
-The moment you produce extra conversion code in the output, your skeptical teammate's mental model might switch from "I recognize this output" to "this conversion might be introducing more problems than it solves. Why are we testing ReScript again?". Then you've lost.
-
-## Conclusion
-
-- Paste the JS code into a new ReScript file as embedded raw JS code.
-- Compile and keep the output file open. Check and diff against original JS file. Free regression tests.
-- Always make sure your file is syntactically valid. Don't worry about fixing types before that.
-- (Ab)use [object](object.md) accesses to quickly convert things over.
-- Optionally clean up the types for robustness.
-- Don't go overboard and turn off your boss and fellow teammates.
-- Proudly display that you've conserved the semantics and performance characteristics during the conversion by showing your teammates the eerily familiar output.
-- Get promoted for introducing a new technology the safer, mature way.
diff --git a/pages/docs/manual/v10.0.0/editor-plugins.mdx b/pages/docs/manual/v10.0.0/editor-plugins.mdx
deleted file mode 100644
index fc2dbb2ce..000000000
--- a/pages/docs/manual/v10.0.0/editor-plugins.mdx
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: "Editor Plugins"
-description: "List of ReScript editor plugins"
-canonical: "/docs/manual/latest/editor-plugins"
----
-
-# Editor Plugins
-
-- [VSCode](https://marketplace.visualstudio.com/items?itemName=chenglou92.rescript-vscode)
-- [Sublime Text](https://github.com/rescript-lang/rescript-sublime)
-- [Vim/Neovim](https://github.com/rescript-lang/vim-rescript)
-
-## Community Supported
-
-We don't officially support these; use them at your own risk!
-
-- [Neovim Tree-sitter](https://github.com/nkrkv/nvim-treesitter-rescript)
-- [Atom](https://atom.io/packages/ide-rescript)
-- [IDEA](https://github.com/reasonml-editor/reasonml-idea-plugin)
-- [Emacs](https://github.com/reasonml-editor/reason-mode) (only legacy `v8.0.0` Reason/OCaml syntax support)
diff --git a/pages/docs/manual/v10.0.0/embed-raw-javascript.mdx b/pages/docs/manual/v10.0.0/embed-raw-javascript.mdx
deleted file mode 100644
index 4d99e9b5a..000000000
--- a/pages/docs/manual/v10.0.0/embed-raw-javascript.mdx
+++ /dev/null
@@ -1,110 +0,0 @@
----
-title: "Embed Raw JavaScript"
-description: "Utility syntax to for raw JS usage in ReScript"
-canonical: "/docs/manual/latest/embed-raw-javascript"
----
-
-# Embed Raw JavaScript
-
-## Paste Raw JS Code
-
-First thing first. If you're ever stuck learning ReScript, remember that you can always just paste raw JavaScript code into our source file:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-%%raw(`
-// look ma, regular JavaScript!
-var message = "hello";
-function greet(m) {
-  console.log(m)
-}
-`)
-```
-```js
-// look ma, regular JavaScript!
-var message = "hello";
-function greet(m) {
-  console.log(m)
-}
-```
-
-</CodeTab>
-
-The `%%raw` special ReScript call takes your code string and pastes it as-is into the output. **You've now technically written your first ReScript file!**
-
-(The back tick syntax is a multiline string, similar to JavaScript's. Except for us, no escaping is needed inside the string. More on string in a later section.)
-
-While `%%raw` lets you embed top-level raw JS code, `%raw` lets you embed expression-level JS code:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let add = %raw(`
-  function(a, b) {
-    console.log("hello from raw JavaScript!");
-    return a + b
-  }
-`)
-
-Js.log(add(1, 2))
-```
-```js
-var add = function(a, b) {
-  console.log("hello from raw JavaScript!");
-  return a + b
-};
-
-console.log(add(1, 2));
-```
-
-</CodeTab>
-
-The above code:
-- declared a ReScript variable `add`,
-- with the raw JavaScript value of a function declaration,
-- then called that function in ReScript.
-
-If your boss is ever worried that your teammates can't adopt ReScript, just let them keep writing JavaScript inside ReScript files =).
-
-## Debugger
-
-You can also drop a `%debugger` expression in a body:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let f = (x, y) => {
-  %debugger
-  x + y
-}
-```
-```js
-function f(x, y) {
-  debugger;
-  return x + y | 0;
-}
-```
-
-</CodeTab>
-
-Output:
-
-```js
-function f(x, y) {
-  debugger; // JavaScript developer tools will set an breakpoint and stop here
-  x + y;
-}
-```
-
-## Tips & Tricks
-
-Embedding raw JS snippets isn't the best way to experience ReScript, though it's also highly useful if you're just starting out. As a matter of fact, the first few ReScript projects were converted through:
-
-- pasting raw JS snippets inside a file
-- examining the JS output (identical to the old hand-written JS)
-- gradually extract a few values and functions and making sure the output still looks OK
-
-At the end, we get a fully safe, converted ReScript file whose JS output is clean enough that we can confidently assert that no new bug has been introduced during the conversion process.
-
-We have a small guide on this iteration [here](converting-from-js.md). Feel free to peruse it later.
diff --git a/pages/docs/manual/v10.0.0/exception.mdx b/pages/docs/manual/v10.0.0/exception.mdx
deleted file mode 100644
index 56a806e79..000000000
--- a/pages/docs/manual/v10.0.0/exception.mdx
+++ /dev/null
@@ -1,264 +0,0 @@
----
-title: "Exception"
-description: "Exceptions and exception handling in ReScript"
-canonical: "/docs/manual/latest/exception"
----
-
-# Exception
-
-Exceptions are just a special kind of variant, thrown in **exceptional** cases (don't abuse them!).
-
-## Usage
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let getItem = (item: int) =>
-  if (item === 3) {
-    // return the found item here
-    1
-  } else {
-    raise(Not_found)
-  }
-
-let result =
-  try {
-    getItem(2)
-  } catch {
-  | Not_found => 0 // Default value if getItem throws
-  }
-```
-```js
-var Caml_js_exceptions = require("./stdlib/caml_js_exceptions.js");
-
-function getItem(item) {
-  if (item === 3) {
-    return 1;
-  }
-  throw {
-    RE_EXN_ID: "Not_found",
-    Error: new Error()
-  };
-}
-
-var result;
-
-try {
-  result = getItem(2);
-}
-catch (raw_exn){
-  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-  if (exn.RE_EXN_ID === "Not_found") {
-    result = 0;
-  } else {
-    throw exn;
-  }
-}
-```
-
-</CodeTab>
-
-Note that the above is just for demonstration purposes; in reality, you'd return an `option<int>` directly from `getItem` and avoid the `try` altogether.
-
-You can directly match on exceptions _while_ getting another return value from a function:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-switch List.find(i => i === 4, list{1, 2, 3}) {
-| item => Js.log(item)
-| exception Not_found => Js.log("No such item found!")
-}
-```
-```js
-var List = require("./stdlib/list.js");
-var Caml_js_exceptions = require("./stdlib/caml_js_exceptions.js");
-
-var exit = 0;
-
-var item;
-
-try {
-  item = List.find((function (i) {
-          return i === 4;
-        }), {
-        hd: 1,
-        tl: {
-          hd: 2,
-          tl: {
-            hd: 3,
-            tl: /* [] */0
-          }
-        }
-      });
-  exit = 1;
-}
-catch (raw_exn){
-  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-  if (exn.RE_EXN_ID === "Not_found") {
-    console.log("No such item found!");
-  } else {
-    throw exn;
-  }
-}
-
-if (exit === 1) {
-  console.log(item);
-}
-```
-
-</CodeTab>
-
-You can also make your own exceptions like you'd make a variant (exceptions need to be capitalized too).
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-exception InputClosed(string)
-// later on
-raise(InputClosed("The stream has closed!"))
-```
-```js
-var Caml_exceptions = require("./stdlib/caml_exceptions.js");
-
-var InputClosed = Caml_exceptions.create("MyFile.InputClosed");
-
-throw {
-  RE_EXN_ID: InputClosed,
-  _1: "The stream has closed!",
-  Error: new Error()
-};
-```
-
-</CodeTab>
-
-## Catching JS Exceptions
-
-To distinguish between JavaScript exceptions and ReScript exceptions, ReScript namespaces JS exceptions under the `Js.Exn.Error(payload)` variant. To catch an exception thrown from the JS side:
-
-
-Throw an exception from JS:
-
-```js
-// Example.js
-
-exports.someJsFunctionThatThrows = () => {
-    throw new Error("A Glitch in the Matrix!");
-}
-```
-
-Then catch it from ReScript:
-
-```res
-// import the method in Example.js
-@module("./Example") 
-external someJsFunctionThatThrows: () => unit = "someJsFunctionThatThrows"
-
-try {
-  // call the external method
-  someJSFunctionThatThrows()
-} catch {
-| Js.Exn.Error(obj) =>
-  switch Js.Exn.message(obj) {
-  | Some(m) => Js.log("Caught a JS exception! Message: " ++ m)
-  | None => ()
-  }
-}
-```
-
-The `obj` here is of type `Js.Exn.t`, intentionally opaque to disallow illegal operations. To operate on `obj`, do like the code above by using the standard library's [`Js.Exn`](api/js/exn) module's helpers.
-
-## Raise a JS Exception
-
-`raise(MyException)` raises a ReScript exception. To raise a JavaScript exception (whatever your purpose is), use `Js.Exn.raiseError`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myTest = () => {
-  Js.Exn.raiseError("Hello!")
-}
-```
-```js
-var Js_exn = require("./stdlib/js_exn.js");
-
-function myTest() {
-  return Js_exn.raiseError("Hello!");
-}
-```
-
-</CodeTab>
-
-Then you can catch it from the JS side:
-
-```js
-// after importing `myTest`...
-try {
-  myTest()
-} catch (e) {
-  console.log(e.message) // "Hello!"
-}
-```
-
-## Catch ReScript Exceptions from JS
-
-The previous section is less useful than you think; to let your JS code work with your exception-throwing ReScript code, the latter doesn't actually need to throw a JS exception. ReScript exceptions can be used by JS code!
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-exception BadArgument({myMessage: string})
-
-let myTest = () => {
-  raise(BadArgument({myMessage: "Oops!"}))
-}
-```
-```js
-var Caml_exceptions = require("./stdlib/caml_exceptions.js");
-
-var BadArgument = Caml_exceptions.create("Playground.BadArgument");
-
-function myTest() {
-  throw {
-    RE_EXN_ID: BadArgument,
-    myMessage: "Oops!",
-    Error: new Error()
-  };
-}
-```
-
-</CodeTab>
-
-Then, in your JS:
-
-```js
-// after importing `myTest`...
-try {
-  myTest()
-} catch (e) {
-  console.log(e.myMessage) // "Oops!"
-  console.log(e.Error.stack) // the stack trace
-}
-```
-
-> Note: `RE_EXN_ID` is an internal field for bookkeeping purposes. Don't use it on the JS side. Use the other fields.
-
-The above `BadArgument` exception takes an inline record type. We special-case compile the exception as `{RE_EXN_ID, myMessage, Error}` for good ergonomics. If the exception instead took ordinary positional arguments, l like the standard library's `Invalid_argument("Oops!")`, which takes a single argument, the argument is compiled to JS as the field `_1` instead. A second positional argument would compile to `_2`, etc.
-
-## Tips & Tricks
-
-When you have ordinary variants, you often don't **need** exceptions. For example, instead of throwing when `item` can't be found in a collection, try to return an `option<item>` (`None` in this case) instead.
-
-### Catch Both ReScript and JS Exceptions in the Same `catch` Clause
-
-```res
-try {
-  someOtherJSFunctionThatThrows()
-} catch {
-| Not_found => ... // catch a ReScript exception
-| Invalid_argument(_) => ... // catch a second ReScript exception
-| Js.Exn.Error(obj) => ... // catch the JS exception
-}
-```
-
-This technically works, but hopefully you don't ever have to work with such code...
diff --git a/pages/docs/manual/v10.0.0/extensible-variant.mdx b/pages/docs/manual/v10.0.0/extensible-variant.mdx
deleted file mode 100644
index 0569bd6b0..000000000
--- a/pages/docs/manual/v10.0.0/extensible-variant.mdx
+++ /dev/null
@@ -1,75 +0,0 @@
----
-title: "Extensible Variant"
-description: "Extensible Variants in ReScript"
-canonical: "/docs/manual/latest/extensible-variant"
----
-
-# Extensible Variant
-
-Variant types are usually constrained to a fixed set of constructors. There may be very rare cases where you still want to be able to add constructors to a variant type even after its initial type declaration. For this, we offer extensible variant types.
-
-## Definition and Usage
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type t = ..
-
-type t += Other
-
-type t +=
-  | Point(float, float)
-  | Line(float, float, float, float)
-```
-```js
-var Caml_exceptions = require("./stdlib/caml_exceptions.js");
-
-var Other = Caml_exceptions.create("Playground.Other");
-
-var Point = Caml_exceptions.create("Playground.Point");
-
-var Line = Caml_exceptions.create("Playground.Line");
-```
-
-</CodeTab>
-
-The `..` in the type declaration above defines an extensible variant `type t`. The `+=` operator is then used to add constructors to the given type. 
-
-**Note:** Don't forget the leading `type` keyword when using the `+=` operator!
-
-## Pattern Matching Caveats
-
-Extensible variants are open-ended, so the compiler will not be able to exhaustively pattern match all available cases. You will always need to provide a default `_` case for every `switch` expression. 
-
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-
-```res
-let print = v =>
-  switch v {
-  | Point(x, y) => Js.log2("Point", (x, y))
-  | Line(ax, ay, bx, by) => Js.log2("Line", (ax, ay, bx, by))
-  | Other
-  | _ => Js.log("Other")
-  }
-```
-```js
-function print(v) {
-  if (v.RE_EXN_ID === Point) {
-    console.log("Point", [v._1, v._2]);
-  } else if (v.RE_EXN_ID === Line) {
-    console.log("Line", [v._1, v._2, v._3, v._4]);
-  } else {
-    console.log("Other");
-  } 
-}
-```
-
-</CodeTab>
-
-## Tips & Tricks
-
-**Fun fact:** In ReScript, [exceptions](./exception) are actually extensible variants under the hood, so `exception UserError(string)` is equivalent to `type exn += UserError(string)`. It's one of the very few use-case where extensible variants make sense.
-
-We usually recommend sticking with common [variants](./variant) as much as possible to reap the benefits of exhaustive pattern matching.
\ No newline at end of file
diff --git a/pages/docs/manual/v10.0.0/external.mdx b/pages/docs/manual/v10.0.0/external.mdx
deleted file mode 100644
index f0845d582..000000000
--- a/pages/docs/manual/v10.0.0/external.mdx
+++ /dev/null
@@ -1,91 +0,0 @@
----
-title: "External (Bind to Any JS Library)"
-description: "The external keyword"
-canonical: "/docs/manual/latest/external"
----
-
-# External (Bind to Any JS Library)
-
-`external` is the primary ReScript feature for bringing in and using JavaScript values.
-
-`external` is like a let binding, but:
-- The right side of `=` isn't a value; it's the name of the JS value you're referring to.
-- The type for the binding is mandatory, since we need to know what the type of that JS value is.
-- Can only exist at the top level of a file or module.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external setTimeout: (unit => unit, int) => float = "setTimeout"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-There are several kinds of `external`s, differentiated and/or augmented through the [attribute](attribute.md) they carry. This page deals with the general, shared mechanism behind most `external`s. The different are documented in their respective pages later. A few notable ones:
-
-- `@val`, `@scope`: [bind to global JS values](bind-to-global-js-values).
-- `@module`: [bind to JS imported/exported values](import-from-export-to-js).
-- `@send`: [bind to JS methods](bind-to-js-function).
-
-You can also use our [Syntax Lookup](/syntax-lookup) tool to find them.
-
-Related: see also our [list of external decorators](interop-cheatsheet#list-of-decorators).
-
-## Usage
-
-Once declared, you can use an `external` as a normal value, just like a let binding.
-
-## Tips & Tricks
-
-`external` + ReScript objects are a wonderful combination for quick prototyping. Check the JS output tab:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// The type of document is just some random type 'a
-// that we won't bother to specify
-@val external document: 'a = "document"
-
-// call a method
-document["addEventListener"](."mouseup", _event => {
-  Js.log("clicked!")
-})
-
-// get a property
-let loc = document["location"]
-
-// set a property
-document["location"]["href"] = "rescript-lang.org"
-```
-```js
-document.addEventListener("mouseup", function(_event) {
-  console.log("clicked!");
-});
-
-var loc = document.location;
-
-document.location.href = "rescript-lang.org";
-```
-
-</CodeTab>
-
-We've specified `document`'s type as `'a`, aka a placeholder type that's polymorphic. Any value can be passed there, so you're not getting much type safety (except the inferences at various call sites). However, this is excellent for quickly getting started using a JavaScript library in ReScript **without needing the equivalent of a repository of typed bindings** like TypeScript's `DefinitelyTyped` repo.
-
-However, if you want to more rigidly bind to the JavaScript library you want, keep reading the next few interop pages.
-
-## Performance & Output Readability
-
-`external`s declarations are inlined into their callers during compilation, **and completely disappear from the JS output**. This means any time you use one, you can be sure that you're not incurring extra JavaScript \<-> ReScript conversion cost.
-
-Additionally, no extra ReScript-specific runtime is better for output readability.
-
-> **Note:** do also use `external`s and the `@blabla` attributes in the interface files. Otherwise the inlining won't happen.
-
-## Design Decisions
-
-ReScript takes interoperating with existing code very seriously. Our type system has very strong guarantees. However, such strong feature also means that, without a great interop system, it'd be very hard to gradually convert a codebase over to ReScript. Fortunately, our interop are comprehensive and cooperate very well with most existing JavaScript code.
-
-The combination of a sound type system + great interop means that we get the benefits of a traditional gradual type system regarding incremental codebase coverage & conversion, without the downside of such gradual type system: complex features to support existing patterns, slow analysis, diminishing return in terms of type coverage, etc.
diff --git a/pages/docs/manual/v10.0.0/faq.mdx b/pages/docs/manual/v10.0.0/faq.mdx
deleted file mode 100644
index 18cb46b88..000000000
--- a/pages/docs/manual/v10.0.0/faq.mdx
+++ /dev/null
@@ -1,66 +0,0 @@
----
-title: "FAQ"
-description: "Frequently asked questions about ReScript and its ecosystem"
-canonical: "/docs/manual/latest/faq"
----
-
-# Frequently Asked Questions
-
-**What's the goal of this project?**
-
-We aim to provide the best typed language experience for the JavaScript platform.
-
-
-**What’s the relationship with BuckleScript?**
-
-BuckleScript is ReScript's old branding, with a sharper focus on proper JS support and familiarity which we previously couldn't achieve to the degree we wanted, due to us needing to cater to various different crowds.
-
-**What’s ReScript's relationship with OCaml?**
-
-We reuse and adjust the excellent type system and lots of other high quality components from OCaml for JS experience. 
-Additionally, ReScript provides its own syntax, build system, IDE, backend, JS interop, extra language features, etc. 
-
-The ReScript toolchain is developed using OCaml, however, the version of ReScript is decoupled against the version of OCaml, 
-ReScript compiler should build against any reasonable modern version of OCaml compiler.
-
-For the majority of ReScript users, they don't need to learn OCaml or use OCaml toolchain to be productive in ReScript.
-
-
-
-**What’s the relationship with Reason?**
-
-See [here](/blog/bucklescript-is-rebranding). Reason is a syntax layer for OCaml that BuckleScript also adopted. The current ReScript compiler also supports the old Reason syntax v3.6 for backward compatibility. We will support it for a long time to make sure existing users do not get breaking changes.
-
-**I come from Reason/OCaml. Will ReScript keep supporting X?**
-
-Please see our [blog post](/blog/a-note-on-bucklescripts-future-commitments) on this matter.
-
-**Where can I see the docs in old Reason/OCaml syntax?**
-
-Switch the doc version to `v8.0.0` in the sidebar on the left!
-
-**Will ReScript support native compilation eventually?**
-
-Our focus is a solid JS story right now. In the future, if there’s strong demand, we might consider it.
-
-**What’s the current state of ReScript?**
-
-Currently, we're actively working on the editor support.
-
-**When will we get the `async/await` keywords?**
-
-See our answer on the [Async & Promise](promise) page's intro.
-
-**Why create a new syntax?**
-
-The existing Reason syntax is owned by a different team with a different vision. Reason aims to be 100% compatible with OCaml syntax and to support all versions of OCaml. In the last few years, we've drawn the conclusion that it’s very hard to deliver such goal without sacrificing user experience. The other reason is that we feel it’s better to have the same vision as a team so that we can make more coherent decisions.
-
-**Who is behind the project?**
-
-The ReScript team (Hongbo, Cheng, Cristiano, Maxim, Patrick, Ricky).
-
-**We have a new forum; will we also have our own Discord?**
-
-Not now. We've found that too much important information get casually passed in Discord then lost within the noise. We prefer folks to communicate on the [forum](https://forum.rescript-lang.org). This is nicer to the less active members.
-
-The team doesn't use the old Discord anymore. We encourage you to move your questions to the forum instead.
diff --git a/pages/docs/manual/v10.0.0/function.mdx b/pages/docs/manual/v10.0.0/function.mdx
deleted file mode 100644
index 4b638ebd2..000000000
--- a/pages/docs/manual/v10.0.0/function.mdx
+++ /dev/null
@@ -1,626 +0,0 @@
----
-title: "Function"
-description: "Function syntax in ReScript"
-canonical: "/docs/manual/latest/function"
----
-
-# Function
-
-_Cheat sheet for the full function syntax at the end_.
-
-ReScript functions are declared with an arrow and return an expression, just like JS functions. They compile to clean JS functions too.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let greet = (name) => "Hello " ++ name
-```
-```js
-function greet(name) {
-  return "Hello " + name;
-}
-```
-
-</CodeTab>
-
-This declares a function and assigns to it the name `greet`, which you can call like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-greet("world!") // "Hello world!"
-```
-```js
-greet("world!");
-```
-
-</CodeTab>
-
-Multi-arguments functions have arguments separated by comma:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let add = (x, y, z) => x + y + z
-add(1, 2, 3) // 6
-```
-```js
-function add(x, y, z) {
-  return (x + y | 0) + z | 0;
-}
-```
-
-</CodeTab>
-
-For longer functions, you'd surround the body with a block:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let greetMore = (name) => {
-  let part1 = "Hello"
-  part1 ++ " " ++ name
-}
-```
-```js
-function greetMore(name) {
-  return "Hello " + name;
-}
-```
-
-</CodeTab>
-
-If your function has no argument, just write `let greetMore = () => {...}`.
-
-## Labeled Arguments
-
-Multi-arguments functions, especially those whose arguments are of the same type, can be confusing to call.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let addCoordinates = (x, y) => {
-  // use x and y here
-}
-// ...
-addCoordinates(5, 6) // which is x, which is y?
-```
-```js
-function addCoordinates(x, y) {
-  // use x and y here
-}
-
-addCoordinates(5, 6);
-```
-
-</CodeTab>
-
-You can attach labels to an argument by prefixing the name with the `~` symbol:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let addCoordinates = (~x, ~y) => {
-  // use x and y here
-}
-// ...
-addCoordinates(~x=5, ~y=6)
-```
-```js
-function addCoordinates(x, y) {
-  // use x and y here
-}
-
-addCoordinates(5, 6);
-```
-
-</CodeTab>
-
-You can provide the arguments in **any order**:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-addCoordinates(~y=6, ~x=5)
-```
-```js
-addCoordinates(5, 6);
-```
-
-</CodeTab>
-
-The `~x` part in the declaration means the function accepts an argument labeled `x` and can refer to it in the function body by the same name. You can also refer to the arguments inside the function body by a different name for conciseness:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let drawCircle = (~radius as r, ~color as c) => {
-  setColor(c)
-  startAt(r, r)
-  // ...
-}
-
-drawCircle(~radius=10, ~color="red")
-```
-```js
-function drawCircle(r, c) {
-  setColor(c);
-  return startAt(r, r);
-}
-
-drawCircle(10, "red");
-```
-
-</CodeTab>
-
-As a matter of fact, `(~radius)` is just a shorthand for `(~radius as radius)`.
-
-Here's the syntax for typing the arguments:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let drawCircle = (~radius as r: int, ~color as c: string) => {
-  // code here
-}
-```
-```js
-function drawCircle(r, c) {
-  // code here
-}
-```
-
-</CodeTab>
-
-## Optional Labeled Arguments
-
-Labeled function arguments can be made optional during declaration. You can then omit them when calling the function.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// radius can be omitted
-let drawCircle = (~color, ~radius=?, ()) => {
-  setColor(color)
-  switch radius {
-  | None => startAt(1, 1)
-  | Some(r_) => startAt(r_, r_)
-  }
-}
-```
-```js
-var Caml_option = require("./stdlib/caml_option.js");
-
-function drawCircle(color, radius, param) {
-  setColor(color);
-  if (radius === undefined) {
-    return startAt(1, 1);
-  }
-  var r_ = Caml_option.valFromOption(radius);
-  return startAt(r_, r_);
-}
-```
-
-</CodeTab>
-
-When given in this syntax, `radius` is **wrapped** in the standard library's `option` type, defaulting to `None`. If provided, it'll be wrapped with a `Some`. So `radius`'s type value is `None | Some(int)` here.
-
-More on `option` type [here](null-undefined-option.md).
-
-**Note** for the sake of the type system, whenever you have an optional argument, you need to ensure that there's also at least one positional argument (aka non-labeled, non-optional argument) after it. If there's none, provide a dummy `unit` (aka `()`) argument.
-
-### Signatures and Type Annotations
-
-Functions with optional labeled arguments can be confusing when it comes to signature and type annotations. Indeed, the type of an optional labeled argument looks different depending on whether you're calling the function, or working inside the function body. Outside the function, a raw value is either passed in (`int`, for example), or left off entirely. Inside the function, the parameter is always there, but its value is an option (`option<int>`). This means that the type signature is different, depending on whether you're writing out the function type, or the parameter type annotation. The first being a raw value, and the second being an option.
-
-If we get back to our previous example and both add a signature and type annotations to its argument, we get this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let drawCircle: (~color: color, ~radius: int=?, unit) => unit =
-  (~color: color, ~radius: option<int>=?, ()) => {
-    setColor(color)
-    switch radius {
-    | None => startAt(1, 1)
-    | Some(r_) => startAt(r_, r_)
-    }
-  }
-```
-```js
-function drawCircle(color, radius, param) {
-  setColor(color);
-  if (radius !== undefined) {
-    return startAt(radius, radius);
-  } else {
-    return startAt(1, 1);
-  }
-}
-```
-
-</CodeTab>
-
-The first line is the function's signature, we would define it like that in an interface file (see [Signatures](module.md#signatures)). The function's signature describes the types that the **outside world** interacts with, hence the type `int` for `radius` because it indeed expects an `int` when called.
-
-In the second line, we annotate the arguments to help us remember the types of the arguments when we use them **inside** the function's body, here indeed `radius` will be an `option<int>` inside the function.
-
-So if you happen to struggle when writing the signature of a function with optional labeled arguments, try to remember this!
-
-### Explicitly Passed Optional
-
-Sometimes, you might want to forward a value to a function without knowing whether the value is `None` or `Some(a)`. Naively, you'd do:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result =
-  switch payloadRadius {
-  | None => drawCircle(~color, ())
-  | Some(r) => drawCircle(~color, ~radius=r, ())
-  }
-```
-```js
-var r = payloadRadius;
-
-var result = r !== undefined
-  ? drawCircle(color, Caml_option.valFromOption(r), undefined)
-  : drawCircle(color, undefined);
-```
-
-</CodeTab>
-
-This quickly gets tedious. We provide a shortcut:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result = drawCircle(~color, ~radius=?payloadRadius, ())
-```
-```js
-var result = drawCircle(1, undefined, undefined);
-```
-
-</CodeTab>
-
-This means "I understand `radius` is optional, and that when I pass it a value it needs to be an `int`, but I don't know whether the value I'm passing is `None` or `Some(val)`, so I'll pass you the whole `option` wrapper".
-
-### Optional with Default Value
-
-Optional labeled arguments can also be provided a default value. In this case, they aren't wrapped in an `option` type.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let drawCircle = (~radius=1, ~color, ()) => {
-  setColor(color)
-  startAt(radius, radius)
-}
-```
-```js
-function drawCircle(radiusOpt, color, param) {
-  var radius = radiusOpt !== undefined ? radiusOpt : 1;
-  setColor(color);
-  return startAt(radius, radius);
-}
-```
-
-</CodeTab>
-
-## Recursive Functions
-
-ReScript chooses the sane default of preventing a function to be called recursively within itself. To make a function recursive, add the `rec` keyword after the `let`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let rec neverTerminate = () => neverTerminate()
-```
-```js
-function neverTerminate(_param) {
-  while(true) {
-    _param = undefined;
-    continue ;
-  };
-}
-```
-
-</CodeTab>
-
-A simple recursive function may look like this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// Recursively check every item on the list until one equals the `item`
-// argument. If a match is found, return `true`, otherwise return `false`
-let rec listHas = (list, item) =>
-  switch list {
-  | list{} => false
-  | list{a, ...rest} => a === item || listHas(rest, item)
-  }
-```
-```js
-function listHas(_list, item) {
-  while(true) {
-    var list = _list;
-    if (!list) {
-      return false;
-    }
-    if (list.hd === item) {
-      return true;
-    }
-    _list = list.tl;
-    continue ;
-  };
-}
-```
-
-</CodeTab>
-
-Recursively calling a function is bad for performance and the call stack. However, ReScript intelligently compiles [tail recursion](https://stackoverflow.com/questions/33923/what-is-tail-recursion) into a fast JavaScript loop. Try checking the JS output of the above code!
-
-### Mutually Recursive Functions
-
-Mutually recursive functions start like a single recursive function using the
-`rec` keyword, and then are chained together with `and`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let rec callSecond = () => callFirst()
-and callFirst = () => callSecond()
-```
-```js
-function callSecond(_param) {
-  while(true) {
-    _param = undefined;
-    continue ;
-  };
-}
-
-function callFirst(_param) {
-  while(true) {
-    _param = undefined;
-    continue ;
-  };
-}
-```
-
-</CodeTab>
-
-## Uncurried Function
-
-ReScript's functions are curried by default, which is one of the few performance penalties we pay in the compiled JS output. The compiler does a best-effort job at removing those currying whenever possible. However, in certain edge cases, you might want guaranteed uncurrying. In those cases, put a dot in the function's parameter list:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let add = (. x, y) => x + y
-
-add(. 1, 2)
-```
-```js
-function add(x, y) {
-  return x + y | 0;
-}
-
-add(1, 2);
-```
-
-</CodeTab>
-
-If you write down the uncurried function's type, you'll add a dot there as well.
-
-**Note**: both the declaration site and the call site need to have the uncurry annotation. That's part of the guarantee/requirement.
-
-**This feature seems trivial**, but is actually one of our most important features, as a primarily functional language. We encourage you to use it if you'd like to remove any mention of `Curry` runtime in the JS output.
-
-## Async/Await (from v10.1)
-
-Just as in JS, an async function can be declared by adding `async` before the definition, and `await` can be used in the body of such functions.
-The output looks like idiomatic JS:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let getUserName = async (userId) => userId
-
-let greetUser = async (userId) => {
-  let name = await getUserName(userId)  
-  "Hello " ++ name ++ "!"
-}
-```
-```js
-async function greetUser(userId) {
-  var name = await getUserName(userId);
-  return "Hello " + name + "!";
-}
-```
-</CodeTab>
-
-The return type of `getUser` is inferred to be `promise<string>`.
-Similarly, `await getUserName(userId)` returns a `string` when the function returns `promise<string>`.
-Using `await` outside of an `async` function (including in a non-async callback to an async function) is an error.
-
-### Ergonomic error handling
-
-Error handling is done by simply using `try`/`catch`, or a switch with an `exception` case, just as in functions that are not async.
-Both JS exceptions and exceptions defined in ReScript can be caught. The compiler takes care of packaging JS exceptions into the builtin `JsError` exception:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-exception SomeReScriptException
-
-let somethingThatMightThrow = async () => raise(SomeReScriptException)
-
-let someAsyncFn = async () => {
-  switch await somethingThatMightThrow() {
-  | data => Some(data)
-  | exception JsError(_) => None
-  | exception SomeReScriptException => None
-  }
-}
-```
-```js
-var SomeReScriptException = /* @__PURE__ */Caml_exceptions.create("Example.SomeReScriptException");
-
-async function someAsyncFn(param) {
-  var data;
-  try {
-    data = await somethingThatMightThrow(undefined);
-  }
-  catch (raw_exn){
-    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-    if (exn.RE_EXN_ID === "JsError") {
-      return ;
-    }
-    if (exn.RE_EXN_ID === SomeReScriptException) {
-      return ;
-    }
-    throw exn;
-  }
-  return data;
-}
-```
-</CodeTab>
-
-
-
-## The ignore() Function
-
-Occasionally you may want to ignore the return value of a function. ReScript provides an `ignore()` function that discards the value of its argument and returns `()`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-mySideEffect()->Promise.catch(handleError)->ignore
-
-Js.Global.setTimeout(myFunc, 1000)->ignore
-```
-
-```js
-$$Promise.$$catch(mySideEffect(), function (prim) {
-  return handleError(prim);
-});
-
-setTimeout(function (prim) {
-  myFunc();
-}, 1000);
-```
-
-</CodeTab>
-
-## Tips & Tricks
-
-Cheat sheet for the function syntaxes:
-
-### Declaration
-
-```res
-// anonymous function
-(x, y) => 1
-// bind to a name
-let add = (x, y) => 1
-
-// labeled
-let add = (~first as x, ~second as y) => x + y
-// with punning sugar
-let add = (~first, ~second) => first + second
-
-// labeled with default value
-let add = (~first as x=1, ~second as y=2) => x + y
-// with punning
-let add = (~first=1, ~second=2) => first + second
-
-// optional
-let add = (~first as x=?, ~second as y=?) => switch x {...}
-// with punning
-let add = (~first=?, ~second=?) => switch first {...}
-```
-
-#### With Type Annotation
-
-```res
-// anonymous function
-(x: int, y: int): int => 1
-// bind to a name
-let add = (x: int, y: int): int => 1
-
-// labeled
-let add = (~first as x: int, ~second as y: int) : int => x + y
-// with punning sugar
-let add = (~first: int, ~second: int) : int => first + second
-
-// labeled with default value
-let add = (~first as x: int=1, ~second as y: int=2) : int => x + y
-// with punning sugar
-let add = (~first: int=1, ~second: int=2) : int => first + second
-
-// optional
-let add = (~first as x: option<int>=?, ~second as y: option<int>=?) : int => switch x {...}
-// with punning sugar
-// note that the caller would pass an `int`, not `option<int>`
-// Inside the function, `first` and `second` are `option<int>`.
-let add = (~first: option<int>=?, ~second: option<int>=?) : int => switch first {...}
-```
-
-### Application
-
-```res
-add(x, y)
-
-// labeled
-add(~first=1, ~second=2)
-// with punning sugar
-add(~first, ~second)
-
-// application with default value. Same as normal application
-add(~first=1, ~second=2)
-
-// explicit optional application
-add(~first=?Some(1), ~second=?Some(2))
-// with punning
-add(~first?, ~second?)
-```
-
-#### With Type Annotation
-
-```res
-// labeled
-add(~first=1: int, ~second=2: int)
-// with punning sugar
-add(~first: int, ~second: int)
-
-// application with default value. Same as normal application
-add(~first=1: int, ~second=2: int)
-
-// explicit optional application
-add(~first=?Some(1): option<int>, ~second=?Some(2): option<int>)
-// no punning sugar when you want to type annotate
-```
-
-### Standalone Type Signature
-
-```res
-// first arg type, second arg type, return type
-type add = (int, int) => int
-
-// labeled
-type add = (~first: int, ~second: int) => int
-
-// labeled
-type add = (~first: int=?, ~second: int=?, unit) => int
-```
-
-#### In Interface Files
-
-To annotate a function from the implementation file (`.res`) in your interface file (`.resi`):
-
-```res sig
-let add: (int, int) => int
-```
-
-The type annotation part is the same as the previous section on With Type Annotation.
-
-**Don't** confuse `let add: myType` with `type add = myType`. When used in `.resi` interface files, the former exports the binding `add` while annotating it as type `myType`. The latter exports the type `add`, whose value is the type `myType`.
diff --git a/pages/docs/manual/v10.0.0/generate-converters-accessors.mdx b/pages/docs/manual/v10.0.0/generate-converters-accessors.mdx
deleted file mode 100644
index 0f1932789..000000000
--- a/pages/docs/manual/v10.0.0/generate-converters-accessors.mdx
+++ /dev/null
@@ -1,518 +0,0 @@
----
-title: "Generate Converters & Helpers"
-description: "All about the @deriving decorator, and how to generate code from types"
-canonical: "/docs/manual/latest/generate-converters-accessors"
----
-
-# Generate Converters & Helpers
-
-**Note**: if you're looking for:
-- `@deriving(jsConverter)` for records
-- `@deriving({jsConverter: newType})` for records
-- `@deriving(jsConverter)` for polymorphic variants
-
-These particular ones are no longer needed. Select a doc version lower than `9.0` in the sidebar to see their old docs.
-
-<!-- TODO: genType -->
-
-When using ReScript, you will sometimes come into situations where you want to
-
-- Automatically generate functions that convert between ReScript's internal and JS runtime values (e.g. variants).
-- Convert a record type into an abstract type with generated creation, accessor and method functions.
-- Generate some other helper functions, such as functions from record attribute names.
-
-You can use the `@deriving` decorator for different code generation scenarios. All different options and configurations will be discussed on this page.
-
-**Note:** Please be aware that extensive use of code generation might make it harder to understand your programs (since the code being generated is not visible in the source code, and you just need to know what kind of functions / values a decorator generates).
-
-## Generate Functions & Plain Values for Variants
-
-Use `@deriving(accessors)` on a variant type to create accessor functions for its constructors.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@deriving(accessors)
-type action =
-  | Click
-  | Submit(string)
-  | Cancel;
-```
-
-```js
-function submit(param_0) {
-  return /* Submit */[param_0];
-}
-
-var click = /* Click */0;
-
-var cancel = /* Cancel */1;
-
-exports.click  = click;
-exports.submit = submit;
-exports.cancel = cancel;
-```
-
-</CodeTab>
-
-Variants constructors with payloads generate functions, payload-less constructors generate plain integers (the internal representation of variants).
-
-**Note**:
-- The generated accessors are lower-cased.
-- You can now use these helpers on the JavaScript side! But don't rely on their actual values please.
-
-### Usage
-
-```res
-let s = submit("hello"); /* gives Submit("hello") */
-```
-
-This is useful:
-
-- When you're passing the accessor function as a higher-order function (which plain variant constructors aren't).
-- When you'd like the JS side to use these values & functions opaquely and pass you back a variant constructor (since JS has no such thing).
-
-Please note that in case you just want to _pipe a payload into a constructor_, you don't need to generate functions for that. Use the `->` syntax instead, e.g. `"test"->Submit`.
-
-## Generate Field Accessors for Records
-
-Use `@deriving(accessors)` on a record type to create accessors for its record field names.
-
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@deriving(accessors)
-type pet = {name: string}
-
-let pets = [{name: "bob"}, {name: "bob2"}]
-
-pets
- ->Belt.Array.map(name)
- ->Js.Array2.joinWith("&")
- ->Js.log
-```
-
-```js
-function name(param) {
-  return param.name;
-}
-
-var pets = [
-  {
-    name: "bob"
-  },
-  {
-    name: "bob2"
-  }
-];
-
-console.log(Belt_Array.map(pets, name).join("&"));
-```
-
-</CodeTab>
-
-## Generate Converters for JS Integer Enums and Variants
-
-Use `@deriving(jsConverter)` on a variant type to create converter functions that allow back and forth conversion between JS integer enum and ReScript variant values.
-
-```res
-@deriving(jsConverter)
-type fruit =
-  | Apple
-  | Orange
-  | Kiwi
-  | Watermelon;
-```
-
-This option causes `jsConverter` to, again, generate functions of the following types:
-
-```resi
-let fruitToJs: fruit => int;
-
-let fruitFromJs: int => option<fruit>;
-```
-
-For `fruitToJs`, each fruit variant constructor would map into an integer, starting at 0, in the order they're declared.
-
-For `fruitFromJs`, the return value is an `option`, because not every int maps to a constructor.
-
-You can also attach a `@as(1234)` to each constructor to customize their output.
-
-### Usage
-
-```res
-@deriving(jsConverter)
-type fruit =
-  | Apple
-  | @as(10) Orange
-  | @as(100) Kiwi
-  | Watermelon
-
-let zero = fruitToJs(Apple) /* 0 */
-
-switch fruitFromJs(100) {
-| Some(Kiwi) => Js.log("this is Kiwi")
-| _ => Js.log("received something wrong from the JS side")
-}
-```
-
-**Note**: by using `@as` here, all subsequent number encoding changes. `Apple` is still `0`, `Orange` is `10`, `Kiwi` is `100` and `Watermelon` is **`101`**!
-
-### More Safety
-
-Similar to the JS object \<-> record deriving, you can hide the fact that the JS enum are ints by using the same `newType` option with `@deriving(jsConverter)`:
-
-```res
-@deriving({jsConverter: newType})
-type fruit =
-  | Apple
-  | @as(100) Kiwi
-  | Watermelon;
-```
-
-This option causes `@deriving(jsConverter)` to generate functions of the following types:
-
-```resi
-let fruitToJs: fruit => abs_fruit;
-
-let fruitFromJs: abs_fruit => fruit;
-```
-
-For `fruitFromJs`, the return value, unlike the previous non-abstract type case, doesn't contain an `option`, because there's no way a bad value can be passed into it; the only creator of `abs_fruit` values is `fruitToJs`!
-
-#### Usage
-
-```res
-@deriving({jsConverter: newType})
-type fruit =
-  | Apple
-  | @as(100) Kiwi
-  | Watermelon
-
-let opaqueValue = fruitToJs(Apple)
-
-@module("myJSFruits") external jsKiwi: abs_fruit = "iSwearThisIsAKiwi"
-let kiwi = fruitFromJs(jsKiwi)
-
-let error = fruitFromJs(100) /* nope, can't take a random int */
-```
-
-## Convert Record Type to Abstract Record
-
-> **Note**: For ReScript >= v7, we recommend using [plain records to compile to JS objects](bind-to-js-object#bind-to-record-like-js-objects).
-> This feature might still be useful for certain scenarios, but the ergonomics might be worse
-
-Use `@deriving(abstract)` on a record type to expand the type into a creation, and a set of getter / setter functions for fields and methods.
-
-Usually you'd just use ReScript records to compile to JS objects of the same shape. There is still one particular use-case left where the `@deriving(abstract)` convertion is still useful: Whenever you need compile a record with an optional field where the JS object attribute shouldn't show up in the resulting JS when undefined (e.g. `{name: "Carl", age: undefined}` vs `{name: "Carl"}`). Check the [Optional Labels](#optional-labels) section for more infos on this particular scenario.
-
-### Usage Example
-
-```res
-@deriving(abstract)
-type person = {
-  name: string,
-  age: int,
-  job: string,
-};
-
-@val external john : person = "john";
-```
-
-**Note**: the `person` type is **not** a record! It's a record-looking type that uses the record's syntax and type-checking. The `@deriving(abstract)` decorator turns it into an "abstract type" (aka you don't know what the actual value's shape).
-
-### Creation
-
-You don't have to bind to an existing `person` object from the JS side. You can also create such `person` JS object from ReScript's side.
-
-Since `@deriving(abstract)` turns the above `person` record into an abstract type, you can't directly create a person record as you would usually. This doesn't work: `{name: "Joe", age: 20, job: "teacher"}`.
-
-Instead, you'd use the **creation function** of the same name as the record type, implicitly generated by the `@deriving(abstract)` annotation:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let joe = person(~name="Joe", ~age=20, ~job="teacher")
-```
-
-```js
-var joe = {
-  name: "Joe",
-  age: 20,
-  job: "teacher"
-};
-```
-
-</CodeTab>
-
-Note how in the example above there is no JS runtime overhead.
-
-#### Rename Fields
-
-Sometimes you might be binding to a JS object with field names that are invalid in ReScript. Two examples would be `{type: "foo"}` (reserved keyword in ReScript) and `{"aria-checked": true}`. Choose a valid field name then use `@as` to circumvent this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@deriving(abstract)
-type data = {
-  @as("type") type_: string,
-  @as("aria-label") ariaLabel: string,
-};
-
-let d = data(~type_="message", ~ariaLabel="hello");
-```
-
-```js
-var d = {
-  type: "message",
-  "aria-label": "hello"
-};
-```
-
-</CodeTab>
-
-#### Optional Labels
-
-You can omit fields during the creation of the object:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@deriving(abstract)
-type person = {
-  @optional name: string,
-  age: int,
-  job: string,
-};
-
-let joe = person(~age=20, ~job="teacher", ());
-```
-
-```js
-var joe = {
-  age: 20,
-  job: "teacher"
-};
-```
-
-</CodeTab>
-
-Optional values that are not defined, will not show up as an attribute in the resulting JS object. In the example above, you will see that `name` was omitted.
-
-**Note** that the `@optional` tag turned the `name` field optional. Merely typing `name` as `option<string>` wouldn't work.
-
-**Note**: now that your creation function contains optional fields, we mandate an unlabeled `()` at the end to indicate that [you've finished applying the function](function#optional-labeled-arguments).
-
-### Accessors
-
-Again, since `@deriving(abstract)` hides the actual record shape, you can't access a field using e.g. `joe.age`. We remediate this by generating getter and setters.
-
-#### Read
-
-One getter function is generated per `@deriving(abstract)` record type field. In the above example, you'd get 3 functions: `nameGet`, `ageGet`, `jobGet`. They take in a `person` value and return `string`, `int`, `string` respectively:
-
-```res
-let twenty = ageGet(joe)
-```
-
-Alternatively, you can use the [Pipe](pipe) operator (`->`) for a nicer-looking access syntax:
-
-```res
-let twenty = joe->ageGet
-```
-
-If you prefer shorter names for the getter functions, we also support a `light` setting:
-
-```res
-@deriving({abstract: light})
-type person = {
-  name: string,
-  age: int,
-}
-
-let joe = person(~name="Joe", ~age=20)
-let joeName = name(joe)
-```
-
-The getter functions will now have the same names as the object fields themselves.
-
-#### Write
-
-A `@deriving(abstract)` value is immutable by default. To mutate such value, you need to first mark one of the abstract record field as `mutable`, the same way you'd mark a normal record as mutable:
-
-```res
-@deriving(abstract)
-type person = {
-  name: string,
-  mutable age: int,
-  job: string,
-}
-```
-
-Then, a setter of the name `ageSet` will be generated. Use it like so:
-
-```res
-let joe = person(~name="Joe", ~age=20, ~job="teacher");
-ageSet(joe, 21);
-```
-
-Alternatively, with the Pipe First syntax:
-
-```res
-joe->ageSet(21)
-```
-
-### Methods
-
-You can attach arbitrary methods onto a type (_any_ type, as a matter of fact. Not just `@deriving(abstract)` record types). See [Object Method](bind-to-js-function#object-method) in the "Bind to JS Function" section for more infos.
-
-### Tips & Tricks
-
-You can leverage `@deriving(abstract)` for finer-grained access control.
-
-#### Mutability
-
-You can mark a field as mutable in the implementation (`.res`) file, while _hiding_ such mutability in the interface file:
-
-```res
-/* test.res */
-@deriving(abstract)
-type cord = {
-  @optional mutable x: int,
-  y: int,
-};
-```
-
-```resi
-/* test.resi */
-@deriving(abstract)
-type cord = {
-  @optional x: int,
-  y: int,
-};
-```
-
-Tada! Now you can mutate inside your own file as much as you want, and prevent others from doing so!
-
-#### Hide the Creation Function
-
-Mark the record as `private` to disable the creation function:
-
-```res
-@deriving(abstract)
-type cord = private {
-  @optional x: int,
-  y: int,
-}
-```
-
-The accessors are still there, but you can no longer create such data structure. Great for binding to a JS object while preventing others from creating more such object!
-
-#### Use submodules to prevent naming collisions and binding shadowing
-
-Oftentimes you will have multiple abstract types with similar attributes. Since
-ReScript will expand all abstract getter, setter and creation functions in the
-same scope where the type is defined, you will eventually run into value shadowing problems.
-
-**For example:**
-
-```res
-@deriving(abstract)
-type person = {name: string}
-
-@deriving(abstract)
-type cat = {
-  name: string,
-  isLazy: bool,
-};
-
-let person = person(~name="Alice")
-
-/* Error: This expression has type person but an expression was expected
-   of type cat */
-person->nameGet()
-```
-
-To get around this issue, you can use modules to group a type with its related
-functions and later use them via local open statements:
-
-```res
-module Person = {
-  @deriving(abstract)
-  type t = {name: string}
-}
-
-module Cat = {
-  @deriving(abstract)
-  type t = {
-    name: string,
-    isLazy: bool,
-  }
-}
-
-let person = Person.t(~name="Alice")
-let cat = Cat.t(~name="Snowball", ~isLazy=true)
-
-/* We can use each nameGet function separately now */
-let shoutPersonName = {
-  open Person
-  person->nameGet->Js.String.toUpperCase
-}
-
-/* Note how we use a local `open Cat` expression to
- get access to Cat's nameGet function */
-let whisperCatName = {
-  open Cat
-  cat->nameGet->Js.String.toLowerCase
-}
-```
-
-## Convert External into JS Object Creation Function
-
-Use `@obj` on an `external` binding to create a function that, when called, will evaluate to a JS object with fields corresponding to the function's parameter labels.
-
-This is very handy because you can make some of those labelled parameters optional and if you don't pass them in, the output object won't include the corresponding fields. Thus you can use it to dynamically create objects with the subset of fields you need at runtime.
-
-For example, suppose you need a JavaScript object like this:
-
-
-```js
-var homeRoute = {
-  type: "GET",
-  path: "/",
-  action: () => console.log("Home"),
-  // options: ...
-};
-```
-
-But only the first three fields are required; the options field is optional. You can declare the binding function like so:
-
-```res
-@obj
-external route: (
-  ~\"type": string,
-  ~path: string,
-  ~action: list<string> => unit,
-  ~options: {..}=?,
-  unit,
-) => _ = ""
-```
-
-**Note**: the ` = ""` part at the end is just a dummy placeholder, due to syntactic limitations. It serves no purpose currently.
-
-This function has four labelled parameters (the fourth one optional), one unlabelled parameter at the end (which we mandate for functions with [optional parameters](function#optional-labeled-arguments), and one parameter (`\"type"`) that required quoting to [avoid clashing](use-illegal-identifier-names) with the reserved `type` keyword.
-
-Also of interest is the return type: `_`, which tells ReScript to automatically infer the full type of the JS object, sparing you the hassle of writing down the type manually!
-
-The function is called like so:
-
-```res
-let homeRoute = route(
-  ~\"type"="GET",
-  ~path="/",
-  ~action=_ => Js.log("Home"),
-  (),
-)
-```
diff --git a/pages/docs/manual/v10.0.0/import-export.mdx b/pages/docs/manual/v10.0.0/import-export.mdx
deleted file mode 100644
index 137646038..000000000
--- a/pages/docs/manual/v10.0.0/import-export.mdx
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: "Import & Export"
-description: "Importing / exporting in ReScript modules"
-canonical: "/docs/manual/latest/import-export"
----
-
-# Import & Export
-
-## Import a Module/File
-
-Unlike JavaScript, ReScript doesn't have or need import statements:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Inside School.res
-let studentMessage = Student.message
-```
-```js
-var Student = require("./Student.bs");
-var studentMessage = Student.message
-```
-
-</CodeTab>
-
-The above code refers to the `message` binding in the file `Student.res`. Every ReScript file is also a module, so accessing another file's content is the same as accessing another module's content!
-
-A ReScript project's file names need to be unique.
-
-## Export Stuff
-
-By default, every file's type declaration, binding and module is exported, aka publicly usable by another file. **This also means those values, once compiled into JS, are immediately usable by your JS code**.
-
-To only export a few selected things, use a `.resi` [interface file](module.md#signatures).
-
-## Work with JavaScript Import & Export
-
-To see how to import JS modules and export stuff for JS consumption, see the JavaScript Interop section's [Import from/Export to JS](import-from-export-to-js.md).
diff --git a/pages/docs/manual/v10.0.0/import-from-export-to-js.mdx b/pages/docs/manual/v10.0.0/import-from-export-to-js.mdx
deleted file mode 100644
index edfa85920..000000000
--- a/pages/docs/manual/v10.0.0/import-from-export-to-js.mdx
+++ /dev/null
@@ -1,150 +0,0 @@
----
-title: "Import from / Export to JS"
-description: "Importing / exporting JS module content in ReScript"
-canonical: "/docs/manual/latest/import-from-export-to-js"
----
-
-# Import from/Export to JS
-
-You've seen how ReScript's idiomatic [Import & Export](import-export.md) works. This section describes how we work with importing stuff from JavaScript and exporting stuff for JavaScript consumption.
-
-**Note**: due to JS ecosystem's module compatibility issues, our advice of keeping your ReScript file's compiled JS output open in a tab applies here **more than ever**, as you don't want to subtly output the wrong JS module import/export code, on top of having to deal with Babel/Webpack/Jest/Node's CommonJS\<->ES6 compatibility shims.
-
-In short: **make sure your bindings below output what you'd have manually written in JS**.
-
-## Output Format
-
-We support 2 JavaScript import/export formats:
-
-- CommonJS: `require('myFile')` and `module.exports = ...`.
-- ES6 modules: `import * from 'MyReScriptFile'` and `export let ...`.
-
-The format is [configurable in via `bsconfig.json`](build-configuration.md#package-specs).
-
-## Import From JavaScript
-
-### Import a JavaScript Module's Named Export
-
-Use the `module` [external](external.md):
-
-<CodeTab labels={["ReScript", "JS Output (CommonJS)", "JS Output (ES6)"]}>
-
-```res example
-// Import nodejs' path.dirname
-@module("path") external dirname: string => string = "dirname"
-let root = dirname("/User/github") // returns "User"
-```
-```js
-var Path = require("path");
-var root = Path.dirname("/User/github");
-```
-```js
-import * as Path from "path";
-var root = Path.dirname("/User/github");
-```
-
-</CodeTab>
-
-Here's what the `external` does:
-
-- `@module("path")`: pass the name of the JS module; in this case, `"path"`. The string can be anything: `"./src/myJsFile"`, `"@myNpmNamespace/myLib"`, etc.
-- `external`: the general keyword for declaring a value that exists on the JS side.
-- `dirname`: the binding name you'll use on the ReScript side.
-- `string => string`: the type signature of `dirname`. Mandatory for `external`s.
-- `= "dirname"`: the name of the variable inside the `path` JS module. There's repetition in writing the first and second `dirname`, because sometime the binding name you want to use on the ReScript side is different than the variable name the JS module exported.
-
-### Import a JavaScript Module As a Single Value
-
-By omitting the string argument to `module`, you bind to the whole JS module:
-
-<CodeTab labels={["ReScript", "JS Output (CommonJS)", "JS Output (ES6)"]}>
-
-```res example
-@module external leftPad: string => int => string = "./leftPad"
-let paddedResult = leftPad("hi", 5)
-```
-```js
-var LeftPad = require("./leftPad");
-var paddedResult = LeftPad("hi", 5);
-```
-```js
-import * as LeftPad from "./leftPad";
-var paddedResult = LeftPad("hi", 5);
-```
-
-</CodeTab>
-
-Depending on whether you're compiling ReScript to CommonJS or ES6 module, **this feature will generate subtly different code**. Please check both output tabs to see the difference. The ES6 output here would be wrong!
-
-### Import an ES6 Default Export
-
-Use the value `"default"` on the right hand side:
-
-<CodeTab labels={["ReScript", "JS Output (ES6)"]}>
-
-```res example
-@module("./student") external studentName: string = "default"
-Js.log(studentName)
-```
-```js
-import Student from "./student";
-var studentName = Student;
-```
-
-</CodeTab>
-
-## Export To JavaScript
-
-### Export a Named Value
-
-As mentioned in ReScript's idiomatic [Import & Export](import-export.md), every let binding and module is exported by default to other ReScript modules (unless you use a `.resi` [interface file](module#signatures)). If you open up the compiled JS file, you'll see that these values can also directly be used by a _JavaScript_ file too.
-
-### Export an ES6 Default Value
-
-If your JS project uses ES6 modules, you're likely exporting & importing some default values:
-
-```js
-// student.js
-export default name = "Al";
-```
-
-```js
-// teacher.js
-import studentName from 'student.js';
-```
-
-A JavaScript default export is really just syntax sugar for a named export implicitly called `default` (now you know!). So to export a default value from ReScript, you can just do:
-
-<CodeTab labels={["ReScript", "JS Output (CommonJS)", "JS Output (ES6)"]}>
-
-```res example
-// ReScriptStudent.res
-let default = "Bob"
-```
-```js
-var $$default = "Bob";
-
-exports.$$default = $$default;
-exports.default = $$default;
-// informal transpiler-compatible marker of a default export compiled from ES6
-exports.__esModule = true;
-```
-```js
-var $$default = "Bob";
-
-export {
-  $$default,
-  $$default as default,
-}
-```
-
-</CodeTab>
-
-You can then import this default export as usual on the JS side:
-
-```js
-// teacher2.js
-import studentName from 'ReScriptStudent.js';
-```
-
-If your JavaScript's ES6 default import is transpiled by Babel/Webpack/Jest into CommonJS `require`s, we've taken care of that too! See the CommonJS output tab for `__esModule`.
diff --git a/pages/docs/manual/v10.0.0/inlining-constants.mdx b/pages/docs/manual/v10.0.0/inlining-constants.mdx
deleted file mode 100644
index 45609df20..000000000
--- a/pages/docs/manual/v10.0.0/inlining-constants.mdx
+++ /dev/null
@@ -1,78 +0,0 @@
----
-title: "Inlining Constants"
-description: "Inlining constants"
-canonical: "/docs/manual/latest/inlining-constants"
----
-
-# Inlining Constants
-
-Sometime, in the JavaScript output, you might want a certain value to be forcefully inlined. For example:
-
-```js
-if (process.env.mode === 'development') {
-  console.log("Dev-only code here!")
-}
-```
-
-The reason is that your JavaScript bundler (e.g. Webpack) might turn that into:
-
-```js
-if ('production' === 'development') {
-  console.log("Dev-only code here!")
-}
-```
-
-Then your subsequent Uglifyjs optimization would remove that entire `if` block. This is how projects like ReactJS provide a development mode code with plenty of dev warnings, while ensuring that the uglified (minified) production code is free of those expensive blocks.
-
-So, in ReScript, producing that example `if (process.env.mode === 'development')` output is important. This first try doesn't work:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external process: 'a = "process"
-
-let mode = "development"
-
-if (process["env"]["mode"] === mode) {
-  Js.log("Dev-only code here!")
-}
-```
-```js
-var mode = "development";
-
-if (process.env.mode === mode) {
-  console.log("Dev-only code here!");
-}
-```
-
-</CodeTab>
-
-The JS output shows `if (process.env.mode === mode)`, which isn't what we wanted. To inline `mode`'s value, use `@inline`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external process: 'a = "process"
-
-@inline
-let mode = "development"
-
-if (process["env"]["mode"] === mode) {
-  Js.log("Dev-only code here!")
-}
-```
-```js
-if (process.env.mode === "development") {
-  console.log("Dev-only code here!");
-}
-```
-
-</CodeTab>
-
-Now your resulting JS code can pass through Webpack and Uglifyjs like the rest of your JavaScript code, and that whole `console.log` can be removed.
-
-The inlining currently only works for **string, float and boolean**.
-
-## Tips & Tricks
-
-This is **not** an optimization. This is an edge-case feature for folks who absolutely need particular values inlined for a JavaScript post-processing step, like conditional compilation. Beside the difference in code that the conditional compilation might end up outputting, there's no performance difference between inlining and not inlining simple values in the eyes of a JavaScript engine.
diff --git a/pages/docs/manual/v10.0.0/installation.mdx b/pages/docs/manual/v10.0.0/installation.mdx
deleted file mode 100644
index da0a5ae9b..000000000
--- a/pages/docs/manual/v10.0.0/installation.mdx
+++ /dev/null
@@ -1,75 +0,0 @@
----
-title: "Installation"
-description: "ReScript installation and setup instructions"
-canonical: "/docs/manual/latest/installation"
----
-
-# Installation
-
-## Prerequisites
-
-- [Node.js](https://nodejs.org/) version >= 14
-- [npm](https://docs.npmjs.com/cli/) (which comes with Node.js) or [Yarn](https://yarnpkg.com/)
-
-## New Project
-
-```sh
-git clone https://github.com/rescript-lang/rescript-project-template
-cd rescript-project-template
-npm install
-npm run res:build
-node src/Demo.bs.js
-```
-
-That compiles your ReScript into JavaScript, then uses Node.js to run said JavaScript. **We recommend you use our unique workflow of keeping a tab open for the generated `.bs.js` file**, so that you can learn how ReScript transforms into JavaScript. Not many languages output clean JavaScript code you can inspect and learn from!
-
-During development, instead of running `npm run res:build` each time to compile, use `npm run res:dev` to start a watcher that recompiles automatically after file changes.
-
-## Integrate Into an Existing JS Project
-
-If you already have a JavaScript project into which you'd like to add ReScript:
-
-- Install ReScript locally:
-  ```sh
-  npm install rescript
-  ```
-- Create a ReScript build configuration at the root:
-  ```json
-  {
-    "name": "your-project-name",
-    "sources": [
-      {
-        "dir": "src", // update this to wherever you're putting ReScript files
-        "subdirs": true
-      }
-    ],
-    "package-specs": [
-      {
-        "module": "es6",
-        "in-source": true
-      }
-    ],
-    "suffix": ".bs.js",
-    "bs-dependencies": []
-  }
-  ```
-  See [Build Configuration](build-configuration) for more details on `bsconfig.json`.
-- Add convenience `npm` scripts to `package.json`:
-  ```json
-  "scripts": {
-    "res:build": "rescript",
-    "res:dev": "rescript build -w"
-  }
-  ```
-
-Since ReScript compiles to clean readable JS files, the rest of your existing toolchain (e.g. Babel and Webpack) should just work!
-
-Helpful guides:
-
-- [Converting from JS](converting-from-js).
-- [Shared Data Types](shared-data-types).
-- [Import from/Export to JS](import-from-export-to-js).
-
-### Integrate with a ReactJS Project
-
-To start a [rescript-react](/docs/react/latest/introduction) app, or to integrate ReScript into an existing ReactJS app, follow the instructions [here](/docs/react/latest/installation).
diff --git a/pages/docs/manual/v10.0.0/interop-cheatsheet.mdx b/pages/docs/manual/v10.0.0/interop-cheatsheet.mdx
deleted file mode 100644
index b6358a324..000000000
--- a/pages/docs/manual/v10.0.0/interop-cheatsheet.mdx
+++ /dev/null
@@ -1,249 +0,0 @@
----
-title: "Interop Cheatsheet"
-description: "Cheatsheet for various interop scenarios in ReScript"
-canonical: "/docs/manual/latest/interop-cheatsheet"
----
-
-# Interop Cheatsheet
-
-This is a glossary with examples. All the features are described by later pages.
-
-## List of Decorators
-
-> **Note:** In ReScript \<8.3, all our attributes started with the `bs.` prefix. This is no longer needed and our formatter automatically removes them in newer ReScript versions.
-
-<!-- Synced from https://github.com/rescript-lang/syntax/blob/123760c5a264da5288eeee5213ddd25eb86d62fe/src/res_printer.ml#L19-L51 -->
-
-### Attributes
-
-- `@as`: [here](attribute#usage), [here](bind-to-js-function#fixed-arguments), [here](bind-to-js-function#constrain-arguments-better) and [here](generate-converters-accessors#usage-3)
-- [`@deriving`](generate-converters-accessors#generate-functions--plain-values-for-variants)
-- [`@get`](bind-to-js-object#bind-using-special-bs-getters--setters)
-- [`@get_index`](bind-to-js-object#bind-using-special-bs-getters--setters)
-<!-- - `@ignore` -->
-- [`@inline`](inlining-constants)
-- [`@int`](bind-to-js-function#constrain-arguments-better)
-<!-- - `@meth` -->
-- [`@module`](import-from-export-to-js#import-a-javascript-modules-content)
-- [`@new`](bind-to-js-object#bind-to-a-js-object-thats-a-class)
-- [`@obj`](generate-converters-accessors#convert-external-into-js-object-creation-function)
-- [`@optional`](generate-converters-accessors#optional-labels)
-- [`@return`](bind-to-js-function#function-nullable-return-value-wrapping)
-- `@send`: [here](bind-to-js-function#object-method) and [here](pipe#js-method-chaining)
-- [`@scope`](bind-to-global-js-values#global-modules)
-- [`@set`](bind-to-js-object#bind-using-special-bs-getters--setters)
-- [`@set_index`](bind-to-js-object#bind-using-special-bs-getters--setters)
-- [`@variadic`](bind-to-js-function#variadic-function-arguments)
-- [`@string`](bind-to-js-function#constrain-arguments-better)
-- [`@this`](bind-to-js-function#modeling-this-based-callbacks)
-- [`@uncurry`](bind-to-js-function#extra-solution)
-- [`@unwrap`](bind-to-js-function#trick-2-polymorphic-variant--bsunwrap)
-- [`@val`](bind-to-global-js-values#global-modules)
-
-- [`@deprecated`](attribute#usage)
-- [`genType`](https://github.com/reason-association/genType)
-- [`@JSX`](jsx)
-- `@react.component`: [here](/docs/react/latest/introduction) and [here](https://github.com/reasonml/reason-react)
-- [`@warning`](attribute#usage)
-- [`@unboxed`](unboxed)
-
-### Extension Points
-
-- [`%debugger`](embed-raw-javascript#debugger)
-- [`%external`](bind-to-global-js-values#special-global-values)
-<!-- - `%node` -->
-<!-- - `%obj` -->
-- [`%raw`](embed-raw-javascript#paste-raw-js-code)
-- [`%re`](primitive-types#regular-expression)
-
-## Raw JS
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let add = %raw("(a, b) => a + b")
-%%raw("const a = 1")
-```
-```js
-var add = ((a, b) => a + b);
-const a = 1
-```
-
-</CodeTab>
-
-## Global Value
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external setTimeout: (unit => unit, int) => float = "setTimeout"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Global Module's Value
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val @scope("Math")
-external random: unit => float = "random"
-
-let someNumber = random()
-
-@val @scope(("window", "location", "ancestorOrigins"))
-external length: int = "length"
-```
-```js
-var someNumber = Math.random();
-```
-
-</CodeTab>
-
-## Nullable
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let a = Some(5) // compiles to 5
-let b = None // compiles to undefined
-```
-```js
-var a = 5;
-var b;
-```
-
-</CodeTab>
-
-Handling a value that can be `undefined` and `null`, by ditching the `option` type and using `Js.Nullable.t`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let jsNull = Js.Nullable.null
-let jsUndefined = Js.Nullable.undefined
-let result1: Js.Nullable.t<string> = Js.Nullable.return("hello")
-let result2: Js.Nullable.t<int> = Js.Nullable.fromOption(Some(10))
-let result3: option<int> = Js.Nullable.toOption(Js.Nullable.return(10))
-```
-```js
-var Caml_option = require("./stdlib/caml_option.js");
-var Js_null_undefined = require("./stdlib/js_null_undefined.js");
-
-var jsNull = null;
-var jsUndefined;
-var result1 = "hello";
-var result2 = Js_null_undefined.fromOption(10);
-var result3 = Caml_option.nullable_to_opt(10);
-```
-
-</CodeTab>
-
-## JS Object
-
-- [Bind to a JS object as a ReScript record](bind-to-js-object#bind-to-record-like-js-objects).
-- [Bind to a JS object that acts like a hash map](bind-to-js-object#bind-to-hash-map-like-js-object).
-- [Bind to a JS object that's a class](bind-to-js-object#bind-to-a-js-object-thats-a-class).
-
-## Function
-
-### Object Method & Chaining
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@send external map: (array<'a>, 'a => 'b) => array<'b> = "map"
-@send external filter: (array<'a>, 'a => 'b) => array<'b> = "filter"
-[1, 2, 3]
-  ->map(a => a + 1)
-  ->filter(a => mod(a, 2) == 0)
-  ->Js.log
-```
-```js
-console.log(
-  [1, 2, 3]
-    .map(function (a) {
-      return (a + 1) | 0;
-    })
-    .filter(function (a) {
-      return a % 2 === 0;
-    })
-);
-```
-
-</CodeTab>
-
-### Variadic Arguments
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("path") @variadic
-external join: array<string> => string = "join"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-### Polymorphic Function
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("Drawing") external drawCat: unit => unit = "draw"
-@module("Drawing") external drawDog: (~giveName: string) => unit = "draw"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val
-external padLeft: (
-  string,
-  @unwrap [
-    | #Str(string)
-    | #Int(int)
-  ])
-  => string = "padLeft"
-
-padLeft("Hello World", #Int(4))
-padLeft("Hello World", #Str("Message from ReScript: "))
-```
-```js
-padLeft("Hello World", 4);
-padLeft("Hello World", "Message from ReScript: ");
-```
-
-</CodeTab>
-
-## JS Module Interop
-
-[See here](import-from-export-to-js.md)
-
-## Dangerous Type Cast
-
-Final escape hatch converter. Do not abuse.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-external convertToFloat: int => float = "%identity"
-let age = 10
-let gpa = 2.1 +. convertToFloat(age)
-```
-```js
-var age = 10;
-var gpa = 2.1 + 10;
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v10.0.0/interop-with-js-build-systems.mdx b/pages/docs/manual/v10.0.0/interop-with-js-build-systems.mdx
deleted file mode 100644
index 00d36b028..000000000
--- a/pages/docs/manual/v10.0.0/interop-with-js-build-systems.mdx
+++ /dev/null
@@ -1,57 +0,0 @@
----
-title: "Interop with JS Build Systems"
-description: "Documentation on how to interact with existing JS build systems"
-canonical: "/docs/manual/latest/interop-with-js-build-systems"
----
-
-# Interop with JS Build Systems
-
-If you come from JS, chances are that you already have a build system in your existing project. Here's an overview of the role `rescript` would play in your build pipeline, if you want to introduce some ReScript code.
-
-> **Please** try not to wrap `rescript` into your own incremental build framework. ReScript's compilation is very hard to get right, and you'll inevitably run into stale or badly performing builds (therefore erasing much of our value proposition) if you create your own meta layer on top.
-
-## Popular JS Build Systems
-
-The JS ecosystem uses a few build systems: [browserify](http://browserify.org/), [rollup](https://github.com/rollup/rollup), [webpack](https://webpack.js.org/), etc. The latter's probably the most popular of the three (as of 2019 =P). These build systems do both the compilation and the linking (aka, bundling many files into one or few files).
-
-`rescript` only take care of the compilation step; it maps one `.res`/`.resi` file into one JS output file. As such, in theory, no build system integration is needed from our side. From e.g. the webpack watcher's perspective, the JS files ReScript generates are almost equivalent to your hand-written JS files. We also recommend **that you initially check in those ReScript-generated JS files**, as this workflow means:
-
-- You can introduce ReScript silently into your codebase without disturbing existing infra.
-- You have a **visual** diff of the performance & correctness of your JS file when you update the `.res` files and the JS artifacts change.
-- You can let teammates hot-patch the JS files in emergency situations, without needing to first start learning ReScript.
-- You can remove ReScript completely from your codebase and things will still work (in case your company decides to stop using us for whatever reason).
-
-For what it's worth, you can also turn `rescript` into an automated step in your build pipeline, e.g. into a Webpack loader; but such approach is error-prone and therefore discouraged.
-
-### Tips & Tricks
-
-You can make ReScript JS files look even more idiomatic through the in-source + bs suffix config in `bsconfig.json`:
-
-```json
-{
-  "package-specs": {
-    "module": "commonjs", // or whatever module system your project uses
-    "in-source": true
-  },
-  "suffix": ".bs.js"
-}
-```
-
-This will:
-
-- Generate the JS files alongside your ReScript source files.
-- Use the file extension `.bs.js`, so that you can require these files on the JS side through `require('./MyFile.bs')`, without needing a loader.
-
-## Use Loaders on ReScript Side
-
-"What if my build system uses a CSS/png/whatever loader and I'd like to use it in ReScript?"
-
-Loaders are indeed troublesome; in the meantime, please use e.g. `%raw("require('./myStyles.css')")` at the top of your file. This just uses [`raw`](embed-raw-javascript.md) to compile the snippet into an actual JS require.
-
-## Getting Project's Dependencies
-
-`rescript` generates one `MyFile.d` file per `MyFile` source file; you'll find them in `lib/bs`. These are human readable, machine-friendly list of the dependencies of said `MyFile`. You can read into them for your purpose (though mind the IO overhead). Use these files instead of creating your own dependency graph; we did the hard work of tracking the dependencies as best as possible (including inner modules, `open`s, module names overlap, etc).
-
-## Run Script Per File Built
-
-See [js-post-build](build-configuration#js-post-build). Though please use it sparingly; if you hook up a node.js script after each file built, you'll incur the node startup time per file!
diff --git a/pages/docs/manual/v10.0.0/introduction.mdx b/pages/docs/manual/v10.0.0/introduction.mdx
deleted file mode 100644
index 9fa73cdca..000000000
--- a/pages/docs/manual/v10.0.0/introduction.mdx
+++ /dev/null
@@ -1,80 +0,0 @@
----
-title: "Introduction"
-description: "The hows and whys of ReScript"
-canonical: "/docs/manual/latest/introduction"
----
-
-# ReScript
-
-Ever wanted a language like JavaScript, but without the warts, with a great type system, and with a lean build toolchain that doesn't waste your time?
-
-ReScript looks like JS, acts like JS, and compiles to the highest quality of clean, readable and performant JS, directly runnable in browsers and Node.
-
-**This means you can pick up ReScript and access the vast JavaScript ecosystem and tooling as if you've known ReScript for a long time!**
-
-**ReScript is the language for folks who don't necessarily love JavaScript, but who still acknowledge its importance**.
-
-## Difference vs TypeScript
-
-We respect TypeScript very much and think that it's a positive force in the JavaScript ecosystem. ReScript shares some of the same goals as TypeScript, but is different enough regarding some important nuances:
-
-- TypeScript's (admittedly noble) goal is to cover the entire JavaScript feature set and more. **ReScript covers only a curated subset of JavaScript**. For example, we emphasize plain data + functions over classes, clean [pattern matching](pattern-matching-destructuring.md) over fragile `if`s and virtual dispatches, [proper data modeling](variant.md) over string abuse, etc. JavaScript supersets will only grow larger over time; ReScript doesn't. \*
-
-- Consequently, TypeScript's type system is necessarily complex, pitfalls-ridden, potentially requires tweaking, sometimes slow, and requires quite a bit of noisy annotations that often feel like manual bookkeeping rather than clear documentation. In contrast, ReScript's type system:
-
-  - Is deliberately curated to be a simple subset most folks will have an easier time to use.
-  - Has **no** pitfalls, aka the type system is "sound" (the types will always be correct). E.g. If a type isn't marked as nullable, its value will never lie and let through some `undefined` value silently. **ReScript code has no null/undefined errors**.
-  - Is the same for everyone. No knobs, no bikeshedding opportunity.
-  - Runs extremely fast precisely thanks to its simplicity and curation. It's one of the fastest compiler & build system toolchains for JavaScript development.
-  - **Doesn't need type annotations**. Annotate as much or as little as you'd like. The types are inferred by the language (and, again, are guaranteed correct).
-
-- Migrating to TypeScript is done "breadth-first," whereas migrating to ReScript is done "depth-first." You can convert your codebase to TypeScript by "turning it on" for all files and annotate here and there; but how much type safety did you gain? How do you measure it? Type errors can still slip in and out of the converted pieces. For ReScript, our interop features draw clear boundaries: there's pure ReScript code, and there's JS interop code. Every piece of converted ReScript code is 100% clean. You'd convert file by file and each conversion increases your safety monotonically.
-
-\* When you absolutely need to write or interoperate with free-for-all JavaScript, we expose enough escape hatches for you.
-
-## Other Highlights
-
-Aside from the aforementioned simple, robust and fast type system, ReScript presents a few more advantages.
-
-### Faster than JavaScript
-
-JavaScript's been aggressively optimized by talented engineers over a long span. Unfortunately, even for seasoned JS devs, it can be hard to know how to properly leverage JS's performance. ReScript's type system and compiler naturally guides you toward writing code that's very often performant by default, with good leverage of various Just-In-Time optimizations (hidden classes, inline caching, avoiding deopts, etc).
-
-A widespread adage to write fast JavaScript code is to write as if there's a type system (in order to trigger JS engines' good optimization heuristics); ReScript gives you a real one and generates code that's friendly to optimizations by default.
-
-### High Quality Dead Code Elimination
-
-The JavaScript ecosystem is very reliant on dependencies. Shipping the final product inevitably drags in a huge amount of code, lots of which the project doesn't actually use. These regions of dead code impact loading, parsing and interpretation speed. ReScript provides powerful dead code elimination at all levels:
-
-- Function- and module-level code elimination is facilitated by the well-engineered type system and purity analysis.
-- At the global level, ReScript generates code that is naturally friendly to dead code elimination done by bundling tools such as [Rollup](https://github.com/rollup/rollup) and [Closure Compiler](https://developers.google.com/closure/compiler/), after its own sophisticated elimination pass.
-- The same applies for ReScript's own tiny runtime (which is written in ReScript itself).
-
-### Tiny JS Output
-
-A `Hello world` ReScript program generates **20 bytes** of JS code. Additionally, the standard library pieces you require in are only included when needed.
-
-### Fast Iteration Loop
-
-ReScript's build time is **one or two orders of magnitude** faster than alternatives. In its watcher mode, the build system usually finishes before you switch screen from the editor to the terminal tab (two digits of milliseconds). A fast iteration cycle reduces the need of keeping one's mental state around longer; this in turn allows one to stay in the flow longer and more often.
-
-### Readable Output & Great Interop
-
-Unreadable JavaScript code generated from other compiled-to-js languages makes it so that it could be, practically speaking:
-
-- Hard to debug (cryptic stack trace, mangled variable names)
-- Hard to learn from (non-straightforward mapping of concepts from one language to another)
-- Hard to profile for performance (unclear what runtime performance cost there is)
-- Hard to integrate with existing hand-written JS code
-
-ReScript's JS output is very readable. This is especially important while learning, where users might want to understand how the code's compiled, and to audit for bugs.
-
-This characteristic, combined with a fully-featured JS interop system, allows ReScript code to be inserted into an existing JavaScript codebase almost unnoticed.
-
-### Preservation of Code Structure
-
-ReScript maps one source file to one JavaScript output file. This eases the integration of existing tools such as bundlers and test runners. You can even start writing a single file without much change to your build setup. Each file's code structure is approximately preserved, too.
-
-## Conclusion
-
-We hope the above gave you enough of an idea of ReScript and its differentiators. Feel free to [try it online](/try) to get a feel!
diff --git a/pages/docs/manual/v10.0.0/json.mdx b/pages/docs/manual/v10.0.0/json.mdx
deleted file mode 100644
index b223cc228..000000000
--- a/pages/docs/manual/v10.0.0/json.mdx
+++ /dev/null
@@ -1,55 +0,0 @@
----
-title: "JSON"
-description: "Interacting with JSON in ReScript"
-canonical: "/docs/manual/latest/json"
----
-
-# JSON
-
-## Parse
-
-Bind to JavaScript's `JSON.parse` and type the return value as the type you're expecting:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// declare the shape of the json you're binding to
-type data = {names: array<string>}
-
-// bind to JS' JSON.parse
-@scope("JSON") @val
-external parseIntoMyData: string => data = "parse"
-
-let result = parseIntoMyData(`{"names": ["Luke", "Christine"]}`)
-let name1 = result.names[0]
-```
-```js
-var result = JSON.parse("{\"names\": [\"Luke\", \"Christine\"]}");
-var name1 = result.names[0];
-```
-
-</CodeTab>
-
-Where `data` can be any type you assume the JSON is. As you can see, this compiles to a straightforward `JSON.parse` call. As with regular JS, this is convenient, but has no guarantee that e.g. the data is correctly shaped, or even syntactically valid. Slightly dangerous.
-
-## Stringify
-
-Use `Js.Json.stringify`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-Js.log(Js.Json.stringifyAny(["Amy", "Joe"]))
-```
-```js
-console.log(JSON.stringify([
-  "Amy",
-  "Joe"
-]));
-```
-
-</CodeTab>
-
-## Advanced
-
-The [Js.Json](api/js/json) module provides slightly safer, low-level building blocks for power users who want to parse JSON on a per-field basis. See the examples in the API docs.
diff --git a/pages/docs/manual/v10.0.0/jsx.mdx b/pages/docs/manual/v10.0.0/jsx.mdx
deleted file mode 100644
index 178e950ab..000000000
--- a/pages/docs/manual/v10.0.0/jsx.mdx
+++ /dev/null
@@ -1,237 +0,0 @@
----
-title: "JSX"
-description: "JSX syntax in ReScript and React"
-canonical: "/docs/manual/latest/jsx"
----
-
-# JSX
-
-Would you like some HTML syntax in your ReScript? If not, quickly skip over this section and pretend you didn't see anything!
-
-ReScript supports the JSX syntax, with some slight differences compared to the one in [ReactJS](https://facebook.github.io/react/docs/introducing-jsx.html). ReScript JSX isn't tied to ReactJS; they translate to normal function calls:
-
-**Note** for [ReScriptReact](https://rescript-lang.org/docs/react/latest/introduction) readers: this isn't what ReScriptReact turns JSX into, in the end. See Usage section for more info.
-
-## Capitalized
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<MyComponent name={"ReScript"} />
-```
-```js
-React.createElement(MyComponent, {
-  name: "ReScript",
-});
-```
-
-</CodeTab>
-
-becomes
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-MyComponent.createElement(~name="ReScript", ~children=list{}, ())
-```
-```js
-React.createElement(MyComponent, {
-  name: "ReScript",
-});
-```
-
-</CodeTab>
-
-## Uncapitalized
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<div onClick={handler}> child1 child2 </div>
-```
-```js
-React.createElement("div", {
-  onClick: handler
-}, child1, child2);
-```
-
-</CodeTab>
-
-becomes
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-div(~onClick=handler, ~children=list{child1, child2}, ())
-```
-```js
-React.createElement("div", {
-  onClick: handler
-}, child1, child2);
-```
-
-</CodeTab>
-
-## Fragment
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<> child1 child2 </>
-```
-```js
-React.createElement(React.Fragment, undefined, child1, child2);
-```
-
-</CodeTab>
-
-becomes
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-list{child1, child2}
-```
-```js
-React.createElement(React.Fragment, undefined, child1, child2);
-```
-
-</CodeTab>
-
-### Children
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<MyComponent> child1 child2 </MyComponent>
-```
-```js
-React.createElement(MyComponent, { children: null }, child1, child2);
-```
-
-</CodeTab>
-
-This is the syntax for passing a list of two items, `child1` and `child2`, to the children position. It transforms to a list containing `child1` and `child2`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-MyComponent.createElement(~children=list{child1, child2}, ())
-```
-```js
-React.createElement(MyComponent.make, MyComponent.makeProps(null, undefined), child1, child2);
-```
-
-</CodeTab>
-
-**Note** again that this isn't the transform for ReScriptReact; ReScriptReact turns the final list into an array. But the idea still applies.
-
-So naturally, `<MyComponent> myChild </MyComponent>` is transformed to `MyComponent.createElement(~children=list{myChild}, ())`. I.e. whatever you do, the arguments passed to the children position will be wrapped in a list.
-
-## Usage
-
-See [ReScriptReact Elements & JSX](https://rescript-lang.org/docs/react/latest/elements-and-jsx) for an example application of JSX, which transforms the above calls into a ReScriptReact-specific call.
-
-Here's a JSX tag that shows most of the features.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<MyComponent
-  booleanAttribute={true}
-  stringAttribute="string"
-  intAttribute=1
-  forcedOptional=?{Some("hello")}
-  onClick={handleClick}>
-  <div> {React.string("hello")} </div>
-</MyComponent>
-```
-```js
-React.createElement(MyComponent, {
-  children: React.createElement("div", undefined, "hello"),
-  booleanAttribute: true,
-  stringAttribute: "string",
-  intAttribute: 1,
-  forcedOptional: "hello",
-  onClick: handleClick
-});
-```
-
-</CodeTab>
-
-## Departures From JS JSX
-
-- Attributes and children don't mandate `{}`, but we show them anyway for ease of learning. Once you format your file, some of them go away and some turn into parentheses.
-- Props spread is supported, but there are some restrictions (see below).
-- Punning!
-
-### Spread Props (from v10.1)
-
-JSX props spread is supported now, but in a stricter way than in JS.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<Comp {...props} a="a" />
-```
-```js
-React.createElement(Comp, {
-  a: "a",
-  b: "b"
-});
-```
-
-</CodeTab>
-
-Multiple spreads are not allowed:
-
-<CodeTab labels={["ReScript"]}>
-
-```res
-<NotAllowed {...props1} {...props2} />
-```
-
-</CodeTab>
-
-The spread must be at the first position, followed by other props:
-
-<CodeTab labels={["ReScript"]}>
-
-```res
-<NotAllowed a="a" {...props} />
-```
-
-</CodeTab>
-
-### Punning
-
-"Punning" refers to the syntax shorthand for when a label and a value are the same. For example, in JavaScript, instead of doing `return {name: name}`, you can do `return {name}`.
-
-JSX supports punning. `<input checked />` is just a shorthand for `<input checked=checked />`. The formatter will help you format to the punned syntax whenever possible. This is convenient in the cases where there are lots of props to pass down:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<MyComponent isLoading text onClick />
-```
-```js
-React.createElement(MyComponent, {
-  isLoading: true,
-  text: text,
-  onClick: onClick
-});
-```
-
-</CodeTab>
-
-Consequently, a JSX component can cram in a few more props before reaching for extra libraries solutions that avoids props passing.
-
-**Note** that this is a departure from ReactJS JSX, which does **not** have punning. ReactJS' `<input checked />` desugars to `<input checked=true />`, in order to conform to DOM's idioms and for backward compatibility.
-
-## Tip & Tricks
-
-For library authors wanting to take advantage of the JSX: the `@JSX` attribute is a hook for potential ppx macros to spot a function wanting to format as JSX. Once you spot the function, you can turn it into any other expression.
-
-This way, everyone gets to benefit the JSX syntax without needing to opt into a specific library using it, e.g. ReScriptReact.
-
-JSX calls supports the features of [labeled arguments](function.md#labeled-arguments): optional, explicitly passed optional and optional with default.
diff --git a/pages/docs/manual/v10.0.0/lazy-values.mdx b/pages/docs/manual/v10.0.0/lazy-values.mdx
deleted file mode 100644
index 7fde6bb26..000000000
--- a/pages/docs/manual/v10.0.0/lazy-values.mdx
+++ /dev/null
@@ -1,123 +0,0 @@
----
-title: "Lazy Value"
-description: "Data type for deferred computation in ReScript"
-canonical: "/docs/manual/latest/lazy-values"
----
-
-# Lazy Value
-
-If you have some expensive computations you'd like to **defer and cache** subsequently, you can wrap it with `lazy`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-// Read the directory, only once
-let expensiveFilesRead = lazy({
-  Js.log("Reading dir")
-  Node.Fs.readdirSync("./pages")
-})
-```
-```js
-var Fs = require("fs");
-
-var expensiveFilesRead = {
-  LAZY_DONE: false,
-  VAL: (function () {
-    console.log("Reading dir");
-    return Fs.readdirSync("./pages");
-  })
-};
-```
-
-</CodeTab>
-
-Check the JS Output tab: that `expensiveFilesRead`'s code isn't executed yet, even though you declared it! You can carry it around without fearing that it'll run the directory read.
-
-**Note**: a lazy value is **not** a [shared data type](shared-data-types.md). Don't rely on its runtime representation in your JavaScript code.
-
-## Execute The Lazy Computation
-
-To actually run the lazy value's computation, use `Lazy.force` from the globally available `Lazy` module:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// First call. The computation happens
-Js.log(Lazy.force(expensiveFilesRead)) // logs "Reading dir" and the directory content
-
-// Second call. Will just return the already calculated result
-Js.log(Lazy.force(expensiveFilesRead)) // logs the directory content
-```
-```js
-console.log(CamlinternalLazy.force(expensiveFilesRead));
-
-console.log(CamlinternalLazy.force(expensiveFilesRead));
-```
-
-</CodeTab>
-
-The first time `Lazy.force` is called, the expensive computation happens and the result is **cached**. The second time, the cached value is directly used.
-
-**You can't re-trigger the computation after the first `force` call**. Make sure you only use a lazy value with computations whose results don't change (e.g. an expensive server request whose response is always the same).
-
-Instead of using `Lazy.force`, you can also use [pattern matching](pattern-matching-destructuring.md) to trigger the computation:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch expensiveFilesRead {
-| lazy(result) => Js.log(result)
-}
-```
-```js
-var result = CamlinternalLazy.force(expensiveFilesRead);
-```
-
-</CodeTab>
-
-Since pattern matching also works on a `let` binding, you can also do:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let lazy(result) = expensiveFilesRead
-Js.log(result)
-```
-```js
-var result = CamlinternalLazy.force(expensiveFilesRead);
-console.log(result);
-```
-
-</CodeTab>
-
-## Exception Handling
-
-For completeness' sake, our files read example might raise an exception because of `readdirSync`. Here's how you'd handle it:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let result = try {
-  Lazy.force(expensiveFilesRead)
-} catch {
-| Not_found => [] // empty array of files
-}
-```
-```js
-var result;
-
-try {
-  result = CamlinternalLazy.force(expensiveFilesRead);
-} catch (raw_exn) {
-  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-  if (exn.RE_EXN_ID === "Not_found") {
-    result = [];
-  } else {
-    throw exn;
-  }
-}
-```
-
-</CodeTab>
-
-Though you should probably handle the exception inside the lazy computation itself.
diff --git a/pages/docs/manual/v10.0.0/let-binding.mdx b/pages/docs/manual/v10.0.0/let-binding.mdx
deleted file mode 100644
index fda3bfcd7..000000000
--- a/pages/docs/manual/v10.0.0/let-binding.mdx
+++ /dev/null
@@ -1,185 +0,0 @@
----
-title: "Let Binding"
-description: "Let binding syntax for binding to values in ReScript"
-canonical: "/docs/manual/latest/let-binding"
----
-
-# Let Binding
-
-A "let binding", in other languages, might be called a "variable declaration". `let` _binds_ values to names. They can be seen and referenced by code that comes _after_ them.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let greeting = "hello!"
-let score = 10
-let newScore = 10 + score
-```
-```js
-var greeting = "hello!";
-var score = 10;
-var newScore = 20;
-```
-
-</CodeTab>
-
-## Block Scope
-
-Bindings can be scoped through `{}`.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let message = {
-  let part1 = "hello"
-  let part2 = "world"
-  part1 ++ " " ++ part2
-}
-// `part1` and `part2` are not accessible here!
-```
-```js
-var message = "hello world";
-```
-
-</CodeTab>
-
-The value of the last line of a scope is implicitly returned.
-
-### Design Decisions
-
-ReScript's `if`, `while` and functions all use the same block scoping mechanism. The code below works **not** because of some special "if scope"; but simply because it's the same scope syntax and feature you just saw:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-if displayGreeting {
-  let message = "Enjoying the docs so far?"
-  Js.log(message)
-}
-// `message` not accessible here!
-```
-```js
-if (displayGreeting) {
-  console.log("Enjoying the docs so far?");
-}
-```
-
-</CodeTab>
-
-## Bindings Are Immutable
-
-Let bindings are "immutable", aka "cannot change". This helps our type system deduce and optimize much more than other languages (and in turn, help you more).
-
-## Binding Shadowing
-
-The above restriction might sound impractical at first. How would you change a value then? Usually, 2 ways:
-
-The first is to realize that many times, what you want isn't to mutate a variable's value. For example, this JavaScript pattern:
-
-```js
-var result = 0;
-result = calculate(result);
-result = calculateSomeMore(result);
-```
-
-...is really just to comment on intermediate steps. You didn't need to mutate `result` at all! You could have just written this JS:
-
-```js
-var result1 = 0;
-var result2 = calculate(result1);
-var result3 = calculateSomeMore(result2);
-```
-
-In ReScript, this obviously works too:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result1 = 0
-let result2 = calculate(result1)
-let result3 = calculateSomeMore(result2)
-```
-```js
-var result1 = 0;
-var result2 = calculate(0);
-var result3 = calculateSomeMore(result2);
-```
-
-</CodeTab>
-
-Additionally, reusing the same let binding name overshadows the previous bindings with the same name. So you can write this too:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result = 0
-let result = calculate(result)
-let result = calculateSomeMore(result)
-```
-```js
-var result = calculate(0);
-var result$1 = calculateSomeMore(result);
-```
-
-</CodeTab>
-
-(Though for the sake of clarity, we don't recommend this).
-
-As a matter of fact, even this is valid code:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let result = "hello"
-Js.log(result) // prints "hello"
-let result = 1
-Js.log(result) // prints 1
-```
-```js
-var result = 1;
-console.log("hello");
-console.log(1);
-```
-
-</CodeTab>
-
-The binding you refer to is whatever's the closest upward. No mutation here!
-If you need _real_ mutation, e.g. passing a value around, have it modified by many pieces of code, we provide a slightly heavier [mutation feature](mutation.md).
-
-## Private let bindings
-
-Private let bindings are introduced in the release [7.2](https://rescript-lang.org/blog/bucklescript-release-7-2).
-
-In the module system, everything is public by default,
-the only way to hide some values is by providing a separate signature to
-list public fields and their types:
-
-```res
-module A: {
-  let b: int
-} = {
-  let a = 3
-  let b = 4
-}
-```
-`%%private` gives you an option to mark private fields directly
-
-```res
-module A = {
-  %%private(let a = 3)
-  let b = 4
-}
-```
-
-`%%private` also applies to file level modules, so in some cases,
-users do not need to provide a separate interface file just to hide some particular values.
-
-Note interface files are still recommended as a general best practice since they give you better
-separate compilation units and also they're better for documentation.
-
-Still, `%%private` is useful in the following scenarios:
-
-- **Code generators.** Some code generators want to hide some values but it is sometimes very hard or time consuming for code generators to synthesize the types for public fields.
-
-- **Quick prototyping.** During prototyping, we still want to hide some values, but the interface file is not stable yet. `%%private` provides you such convenience.
-
diff --git a/pages/docs/manual/v10.0.0/libraries.mdx b/pages/docs/manual/v10.0.0/libraries.mdx
deleted file mode 100644
index 57876b799..000000000
--- a/pages/docs/manual/v10.0.0/libraries.mdx
+++ /dev/null
@@ -1,27 +0,0 @@
----
-title: "Libraries & Publishing"
-description: "Install & publish ReScript packages"
-canonical: "/docs/manual/latest/libraries"
----
-
-# Libraries & Publishing
-
-ReScript libraries are just like JavaScript libraries: published & hosted on [NPM](http://npmjs.com). You can reuse your `npm`, `yarn` and `package.json`-related tools to manage them!
-
-## Tips & Tricks
-
-### Publish
-
-We recommend you to check in your compiled JavaScript output, for its [various benefits](interop-with-js-build-systems.md#popular-js-build-systems). If not, then at least consider publishing the JavaScript output by un-ignoring them in your [npmignore](https://docs.npmjs.com/cli/v7/using-npm/developers#keeping-files-out-of-your-package). This way, your published ReScript package comes with plain JavaScript files that JS users can consume. If your project's good, JS users might not even realize that they've installed a library written in ReScript!
-
-In case your library is only consumed by JS users, you may want to check out our [external stdlib](./build-external-stdlib) configuration as well.
-
-### Find Libraries
-
-Search `rescript`-related packages on NPM, or use our [Package Index](/packages).
-
-If you can't find what you're looking for, remember that **you don't need a wrapper** to use a JS library:
-
-- Most JS data types, such as array and objects, [map over cleanly to ReScript and vice-versa](shared-data-types.md).
-- You also have access to the familiar [JS API](api/js).
-- You can use a JavaScript library without needing to install dedicated binding libraries. Check the [`external`](external) page.
diff --git a/pages/docs/manual/v10.0.0/migrate-from-bucklescript-reason.mdx b/pages/docs/manual/v10.0.0/migrate-from-bucklescript-reason.mdx
deleted file mode 100644
index ac3fce54f..000000000
--- a/pages/docs/manual/v10.0.0/migrate-from-bucklescript-reason.mdx
+++ /dev/null
@@ -1,64 +0,0 @@
----
-title: "Migrate to ReScript Syntax"
-description: "Instructions on upgrading from Reason to ReScript"
-canonical: "/docs/manual/latest/migrate-to-new-syntax"
----
-
-# Migrate from BuckleScript/Reason
-
-ReScript is a rebranding and cleanup of BuckleScript (since `v8.2.0`) & Reason (`v3.6`) that enables us to ship a tighter compile-to-JS stack with more coherent documentation & tools. If you're an existing user of BuckleScript & Reason, here's the gist:
-
-- ReScript is mostly just BuckleScript rebranded, with a new syntax that's like the Reason syntax, but catered more toward the JavaScript crowd.
-- All your existing code will keep working even if you don't upgrade.
-
-## Upgrade Your Codebase
-
-There are lots of exciting improvements in the new syntax (features, speed, error messages, etc.). The upgrade is trivial, backward-compatible and can be done on a per-file basis:
-
-```
-npm install rescript@9
-
-# Also works with .rei / .ml / .mli / etc
-npx rescript convert src/MyFile.re
-```
-
-Enjoy the improved experience!
-
-### Upgrade Individual Folders
-
-This is useful for per-directory conversions:
-
-```console
-# *.rei, *.ml, *.mli,....
-for f in your-folder/**/*.re; do; node_modules/.bin/rescript convert $f && rm $f; done;
-```
-
-### Upgrade an Entire Codebase
-
-In case you are confident in converting your codebase in one step, use the following:
-
-```
-npx rescript convert -all
-```
-
-
-## Difference With Old Reason
-
-- Complete removal of semicolon (you can still write them).
-- No need for parentheses around `if`, `switch` and `try`.
-- Type arguments: from `option(int)` to `option<int>`.
-- Old interpolated string: from `{j|hello ${name}|j}` to `` `hello ${name}` ``. Now with proper unicode support!
-- New interpolated string: `` `hello world` ``. Also supports multiline and unicode. `"hello world"` string is now singleline.
-- Polymorphic variants: from `` `red`` to `#red`.
-- Arrays: from `[|1,2,3|]` to `[1,2,3]`. In JS, arrays are the right default.
-- Lists: from `[1,2,3]` to `list[1,2,3]` (_8.1.1 update_: now it is `list{1, 2, 3}`). This ties with upcoming plans to access containers in a uniform way: `set[...]` and `map[...]`. Maybe temporary.
-- Exception: from `try (compute()) { | Not_found => Js.log("oops")}` to `try compute() catch { | Not_found => Js.log("oops")}`.
-- First class module: from `(module S: Student)` to `module(S: Student)`.
-- No custom infix operator for now (including `mod`).
-- Object access: from `settings##visible #= true` to `settings["visible"] = true`. Rejoice!
-- Object: from `Js.t({"age": int})` to just `{"age": int}`. The `Js.t` part is now unneeded.
-- Attribute: from `[@myAttribute "hello"]` to `@myAttribute("hello")`. From `[%re bla]` to `%re(bla)`.
-- Removed dereference syntax `result^`. Just use `result.contents`.
-- `fun` pattern matching syntax removed.
-- Type declaration is non-recursive by default, consistent with let bindings. To have recursive types, use `type rec myList<'a> = Nil | Cons('a, myList<'a>)`.
-- Use any words, including reserved keywords, as your identifier name: `let \"try" = true`.
diff --git a/pages/docs/manual/v10.0.0/module.mdx b/pages/docs/manual/v10.0.0/module.mdx
deleted file mode 100644
index ad9d4e5c4..000000000
--- a/pages/docs/manual/v10.0.0/module.mdx
+++ /dev/null
@@ -1,569 +0,0 @@
----
-title: "Module"
-description: "ReScript modules, module signatures and interface files"
-canonical: "/docs/manual/latest/module"
----
-
-# Module
-
-## Basics
-
-**Modules are like mini files**! They can contain type definitions, `let`
-bindings, nested modules, etc.
-
-### Creation
-
-To create a module, use the `module` keyword. The module name must start with a
-**capital letter**. Whatever you could place in a `.res` file, you may place
-inside a module definition's `{}` block.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module School = {
-  type profession = Teacher | Director
-
-  let person1 = Teacher
-  let getProfession = (person) =>
-    switch person {
-    | Teacher => "A teacher"
-    | Director => "A director"
-    }
-}
-```
-```js
-function getProfession(person) {
-  if (person) {
-    return "A director";
-  } else {
-    return "A teacher";
-  }
-}
-
-var School = {
-  person1: /* Teacher */0,
-  getProfession: getProfession
-};
-```
-
-</CodeTab>
-
-A module's contents (including types!) can be accessed much like a record's,
-using the `.` notation. This demonstrates modules' utility for namespacing.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let anotherPerson: School.profession = School.Teacher
-Js.log(School.getProfession(anotherPerson)) /* "A teacher" */
-```
-```js
-var anotherPerson = /* Teacher */0;
-console.log("A teacher");
-```
-
-</CodeTab>
-
-Nested modules work too.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module MyModule = {
-  module NestedModule = {
-    let message = "hello"
-  }
-}
-
-let message = MyModule.NestedModule.message
-```
-```js
-var NestedModule = {
-  message: message
-};
-
-var MyModule = {
-  NestedModule: NestedModule
-};
-
-var message = MyModule.NestedModule.message;
-```
-
-</CodeTab>
-
-### `open`ing a module
-
-Constantly referring to a value/type in a module can be tedious. Instead, we can "open" a module and refer to its contents without always prepending them with the
-module's name. Instead of writing:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let p = School.getProfession(School.person1)
-```
-```js
-var p = School.getProfession(School.person1);
-```
-
-</CodeTab>
-
-We can write:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-open School
-let p = getProfession(person1)
-```
-```js
-var p = School.getProfession(School.person1);
-```
-
-</CodeTab>
-
-The content of `School` module are made visible (**not** copied into the file, but simply made visible!) in scope. `profession`, `getProfession` and `person1` will thus correctly be found.
-
-**Use `open` this sparingly, it's convenient, but makes it hard to know where some values come from**. You should usually use `open` in a local scope:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let p = {
-  open School
-  getProfession(person1)
-}
-/* School's content isn't visible here anymore */
-```
-```js
-var p = School.getProfession(School.person1);
-```
-
-</CodeTab>
-
-### Use `open!` to ignore shadow warnings
-
-There are situations where `open` will cause a warning due to existing identifiers (bindings, types) being redefined. Use `open!` to explicitly tell the compiler that this is desired behavior.
-
-```res
-let map = (arr, value) => {
-  value
-}
-
-// opening Js.Array2 would shadow our previously defined `map`
-// `open!` will explicitly turn off the automatic warning
-open! Js.Array2
-let arr = map([1,2,3], (a) => { a + 1})
-```
-
-**Note:** Same as with `open`, don't overuse `open!` statements if not necessary. Use (sub)modules to prevent shadowing issues.
-
-### Destructuring modules
-
-**Since 9.0.2**
-
-As an alternative to `open`ing a module, you can also destructure a module's functions and values into separate let bindings (similarly on how we'd destructure an object in JavaScript).
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-module User = {
-  let user1 = "Anna"
-  let user2 = "Franz"
-}
-
-// Destructure by name
-let {user1, user2} = module(User)
-
-// Destructure with different alias
-let {user1: anna, user2: franz} = module(User)
-```
-
-```js
-var user1 = "Anna";
-
-var user2 = "Franz";
-
-var User = {
-  user1: user1,
-  user2: user2
-};
-```
-
-</CodeTab>
-
-**Note:** You can't extract types with module destructuring — use a type alias instead (`type user = User.myUserType`).
-
-### Extending modules
-
-Using `include` in a module statically "spreads" a module's content into a new one, thus often fulfill the role of "inheritance" or "mixin".
-
-**Note**: this is equivalent to a compiler-level copy paste. **We heavily discourage `include`**. Use it as last resort!
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module BaseComponent = {
-  let defaultGreeting = "Hello"
-  let getAudience = (~excited) => excited ? "world!" : "world"
-}
-
-module ActualComponent = {
-  /* the content is copied over */
-  include BaseComponent
-  /* overrides BaseComponent.defaultGreeting */
-  let defaultGreeting = "Hey"
-  let render = () => defaultGreeting ++ " " ++ getAudience(~excited=true)
-}
-```
-```js
-function getAudience(excited) {
-  if (excited) {
-    return "world!";
-  } else {
-    return "world";
-  }
-}
-
-var BaseComponent = {
-  defaultGreeting: "Hello",
-  getAudience: getAudience
-};
-
-var defaultGreeting = "Hey";
-
-function render(param) {
-  return "Hey world!";
-}
-
-var ActualComponent = {
-  getAudience: getAudience,
-  defaultGreeting: defaultGreeting,
-  render: render
-};
-```
-
-</CodeTab>
-
-**Note**: `open` and `include` are very different! The former brings a module's content into your current scope, so that you don't have to refer to a value by prefixing it with the module's name every time. The latter **copies over** the definition of a module statically, then also do an `open`.
-
-### Every `.res` file is a module
-
-Every ReScript file is itself compiled to a module of the same name as the file name, capitalized. The file `React.res` implicitly forms a module `React`, which can be seen by other source files.
-
-**Note**: ReScript file names should, by convention, be capitalized so that their casing matches their module name. Uncapitalized file names are not invalid, but will be implicitly transformed into a capitalized module name. I.e. `file.res` will be compiled into the module `File`. To simplify and minimize the disconnect here, the convention is therefore to capitalize file names.
-
-## Signatures
-
-A module's type is called a "signature", and can be written explicitly. If a
-module is like a `.res` (implementation) file, then a module's signature is like
-a `.resi` (interface) file.
-
-### Creation
-
-To create a signature, use the `module type` keyword. The signature name must start with a
-**capital letter**. Whatever you could place in a `.resi` file, you may place
-inside a signature definition's `{}` block.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-/* Picking up previous section's example */
-module type EstablishmentType = {
-  type profession
-  let getProfession: profession => string
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-A signature defines the list of requirements that a module must satisfy in order
-for that module to match the signature. Those requirements are of the form:
-
-- `let x: int` requires a `let` binding named `x`, of type `int`.
-- `type t = someType` requires a type field `t` to be equal to `someType`.
-- `type t` requires a type field `t`, but without imposing any requirements on the actual, concrete type of `t`. We'd use `t` in other entries in the signature to describe relationships, e.g. `let makePair: t => (t, t)` but we cannot, for example, assume that `t` is an `int`. This gives us great, enforced abstraction abilities.
-
-To illustrate the various kinds of type entries, consider the above signature
-`EstablishmentType` which requires that a module:
-
-- Declare a type named `profession`.
-- Must include a function that takes in a value of the type `profession` and returns a string.
-
-**Note**:
-
-Modules of the type `EstablishmentType` can contain more fields than the
-signature declares, just like the module `School` in the previous section (if we
-choose to assign it the type `EstablishmentType`. Otherwise, `School` exposes
-every field). This effectively makes the `person1` field an enforced
-implementation detail! Outsiders can't access it, since it's not present in the
-signature; the signature **constrained** what others can access.
-
-The type `EstablishmentType.profession` is **abstract**: it doesn't have a
-concrete type; it's saying "I don't care what the actual type is, but it's used
-as input to `getProfession`". This is useful to fit many modules under the same
-interface:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-module Company: EstablishmentType = {
-  type profession = CEO | Designer | Engineer | ...
-
-  let getProfession = (person) => ...
-  let person1 = ...
-  let person2 = ...
-}
-```
-```js
-function getProfession(person) {
-  ...
-}
-
-var person1 = ...
-
-var person2 = ...
-
-var Company = {
-  getProfession: getProfession,
-  person1: person1,
-  person2: person2
-};
-```
-
-</CodeTab>
-
-It's also useful to hide the underlying type as an implementation detail others
-can't rely on. If you ask what the type of `Company.profession` is, instead of
-exposing the variant, it'll only tell you "it's `Company.profession`".
-
-### Extending module signatures
-
-Like modules themselves, module signatures can also be extended by other module signatures using `include`. Again, **heavily discouraged**:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module type BaseComponent = {
-  let defaultGreeting: string
-  let getAudience: (~excited: bool) => string
-}
-
-module type ActualComponent = {
-  /* the BaseComponent signature is copied over */
-  include BaseComponent
-  let render: unit => string
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-**Note**: `BaseComponent` is a module **type**, not an actual module itself!
-
-If you do not have a defined module type, you can extract it from an actual module
-using `include (module type of ActualModuleName)`. For example, we can extend the
-`List` module from the standard library, which does not define a module
-type.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module type MyList = {
-  include (module type of List)
-  let myListFun: list<'a> => list<'a>
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-### Every `.resi` file is a signature
-
-Similar to how a `React.res` file implicitly defines a module `React`, a file
-`React.resi` implicitly defines a signature for `React`. If `React.resi` isn't
-provided, the signature of `React.res` defaults to exposing all the fields of the
-module. Because they don't contain implementation files, `.resi` files are used
-in the ecosystem to also document the public API of their corresponding modules.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-/* file React.res (implementation. Compiles to module React) */
-type state = int
-let render = (str) => str
-```
-```js
-function render(str) {
-  return str;
-}
-```
-
-</CodeTab>
-
-```res sig
-/* file React.resi (interface. Compiles to the signature of React.res) */
-type state = int
-let render: string => string
-```
-
-## Module Functions (functors)
-
-Modules can be passed to functions! It would be the equivalent of passing a file
-as a first-class item. However, modules are at a different "layer" of the
-language than other common concepts, so we can't pass them to *regular*
-functions. Instead, we pass them to special functions called "functors".
-
-The syntax for defining and using functors is very much like the syntax
-for defining and using regular functions. The primary differences are:
-
-- Functors use the `module` keyword instead of `let`.
-- Functors take modules as arguments and return a module.
-- Functors *require* annotating arguments.
-- Functors must start with a capital letter (just like modules/signatures).
-
-Here's an example `MakeSet` functor, that takes in a module of the type
-`Comparable` and returns a new set that can contain such comparable items.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-module type Comparable = {
-  type t
-  let equal: (t, t) => bool
-}
-
-module MakeSet = (Item: Comparable) => {
-  // let's use a list as our naive backing data structure
-  type backingType = list<Item.t>
-  let empty = list{}
-  let add = (currentSet: backingType, newItem: Item.t): backingType =>
-    // if item exists
-    if List.exists(x => Item.equal(x, newItem), currentSet) {
-      currentSet // return the same (immutable) set (a list really)
-    } else {
-      list{
-        newItem,
-        ...currentSet // prepend to the set and return it
-      }
-    }
-}
-```
-```js
-var List = require("./stdlib/list.js");
-
-function MakeSet(Item) {
-  var add = function(currentSet, newItem) {
-    if (
-      List.exists(function(x) {
-        return Item.equal(x, newItem);
-      }, currentSet)
-    ) {
-      return currentSet;
-    } else {
-      return {
-        hd: newItem,
-        tl: currentSet,
-      };
-    }
-  };
-  return {
-    empty: /* [] */ 0,
-    add: add,
-  };
-}
-```
-
-</CodeTab>
-
-Functors can be applied using function application syntax. In this case, we're
-creating a set, whose items are pairs of integers.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module IntPair = {
-  type t = (int, int)
-  let equal = ((x1: int, y1: int), (x2, y2)) => x1 == x2 && y1 == y2
-  let create = (x, y) => (x, y)
-}
-
-/* IntPair abides by the Comparable signature required by MakeSet */
-module SetOfIntPairs = MakeSet(IntPair)
-```
-```js
-function equal(param, param$1) {
-  if (param[0] === param$1[0]) {
-    return param[1] === param$1[1];
-  } else {
-    return false;
-  }
-}
-
-function create(x, y) {
-  return [x, y];
-}
-
-var IntPair = {
-  equal: equal,
-  create: create,
-};
-
-var SetOfIntPairs = {
-  empty: /* [] */ 0,
-  add: add,
-};
-```
-
-</CodeTab>
-
-### Module functions types
-
-Like with module types, functor types also act to constrain and hide what we may
-assume about functors. The syntax for functor types are consistent with those
-for function types, but with types capitalized to represent the signatures of
-modules the functor accepts as arguments and return values. In the
-previous example, we're exposing the backing type of a set; by giving `MakeSet`
-a functor signature, we can hide the underlying data structure!
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-module type Comparable = ...
-
-module type MakeSetType = (Item: Comparable) => {
-  type backingType
-  let empty: backingType
-  let add: (backingType, Item.t) => backingType
-}
-
-module MakeSet: MakeSetType = (Item: Comparable) => {
-  ...
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Exotic Module Filenames
-
-**Since 8.3**
-
-It is possible to use non-conventional characters in your filenames (which is sometimes needed for specific JS frameworks). Here are some examples:
-
-- `src/Button.ios.res`
-- `pages/[id].res`
-
-Please note that modules with an exotic filename will not be accessible from other ReScript modules.
-
-## Tips & Tricks
-
-Modules and functors are at a different "layer" of language than the rest (functions, let bindings, data structures, etc.). For example, you can't easily pass them into a tuple or record. Use them judiciously, if ever! Lots of times, just a record or a function is enough.
diff --git a/pages/docs/manual/v10.0.0/mutation.mdx b/pages/docs/manual/v10.0.0/mutation.mdx
deleted file mode 100644
index 750613a4a..000000000
--- a/pages/docs/manual/v10.0.0/mutation.mdx
+++ /dev/null
@@ -1,75 +0,0 @@
----
-title: "Mutation"
-description: "Imperative and mutative programming capabilities in ReScript"
-canonical: "/docs/manual/latest/mutation"
----
-
-# Mutation
-
-ReScript has great traditional imperative & mutative programming capabilities. You should use these features sparingly, but sometimes they allow your code to be more performant and written in a more familiar pattern.
-
-## Mutate Let-binding
-
-Let-bindings are immutable, but you can wrap it with a `ref`, exposed as a record with a single mutable field in the standard library:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let myValue = ref(5)
-```
-```js
-var myValue = {
-  contents: 5
-};
-```
-
-</CodeTab>
-
-## Usage
-
-You can get the actual value of a `ref` box through accessing its `contents` field:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let five = myValue.contents // 5
-```
-```js
-var five = myValue.contents;
-```
-
-</CodeTab>
-
-Assign a new value to `myValue` like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-myValue.contents = 6
-```
-```js
-myValue.contents = 6;
-```
-
-</CodeTab>
-
-We provide a syntax sugar for this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-myValue := 6
-```
-```js
-myValue.contents = 6;
-```
-
-</CodeTab>
-
-Note that the previous binding `five` stays `5`, since it got the underlying item on the `ref` box, not the `ref` itself.
-
-**Note**: you might see in the JS output tabs above that `ref` allocates an object. Worry not; local, non-exported `ref`s allocations are optimized away.
-
-## Tip & Tricks
-
-Before reaching for `ref`, know that you can achieve lightweight, local "mutations" through [overriding let bindings](let-binding.md#binding-shadowing).
diff --git a/pages/docs/manual/v10.0.0/newcomer-examples.mdx b/pages/docs/manual/v10.0.0/newcomer-examples.mdx
deleted file mode 100644
index 4f701411d..000000000
--- a/pages/docs/manual/v10.0.0/newcomer-examples.mdx
+++ /dev/null
@@ -1,134 +0,0 @@
----
-title: "Newcomer Examples"
-description: "Quick examples for users new to ReScript"
-canonical: "/docs/manual/latest/newcomer-examples"
----
-
-# Newcomer Examples
-
-<!-- TODO: this whole page needs a revamp -->
-
-An example is worth a thousand words.
-
-This section is dedicated to newcomers trying to figure out general idioms & conventions. If you're a beginner who's got a good idea for an example, please suggest an edit!
-
-## Use the [`option` type](null-undefined-option.md)
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let possiblyNullValue1 = None
-let possiblyNullValue2 = Some("Hello")
-
-switch possiblyNullValue2 {
-| None => Js.log("Nothing to see here.")
-| Some(message) => Js.log(message)
-}
-```
-```js
-var possiblyNullValue1;
-var possiblyNullValue2 = "Hello";
-
-if (possiblyNullValue2 !== undefined) {
-  console.log(possiblyNullValue2);
-} else {
-  console.log("Nothing to see here.");
-}
-
-```
-
-</CodeTab>
-
-## Create a Parametrized Type
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type universityStudent = {gpa: float}
-
-type response<'studentType> = {
-  status: int,
-  student: 'studentType,
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Creating a JS Object
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let student1 = {
-  "name": "John",
-  "age": 30,
-}
-```
-```js
-var student1 = {
-  name: "John",
-  age: 30,
-};
-```
-
-</CodeTab>
-
-Or using [record](record.md):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type payload = {
-  name: string,
-  age: int,
-}
-
-let student1 = {
-  name: "John",
-  age: 30,
-}
-```
-```js
-var student1 = {
-  name: "John",
-  age: 30,
-};
-```
-
-</CodeTab>
-
-## Modeling a JS Module with Default Export
-
-See [here](import-from-export-to-js.md#import-a-javascript-module-itself-es6-module-format).
-
-## Checking for JS nullable types using the `option` type
-
-For a function whose argument is passed a JavaScript value that's potentially `null` or `undefined`, it's idiomatic to convert it to an `option`. The conversion is done through the helper functions in ReScript's [`Js.Nullable`](api/js/nullable#t) module. In this case, `toOption`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let greetByName = (possiblyNullName) => {
-  let optionName = Js.Nullable.toOption(possiblyNullName)
-  switch optionName {
-  | None => "Hi"
-  | Some(name) => "Hello " ++ name
-  }
-}
-```
-```js
-function greetByName(possiblyNullName) {
-  if (possiblyNullName == null) {
-    return "Hi";
-  } else {
-    return "Hello " + possiblyNullName;
-  }
-}
-```
-
-</CodeTab>
-
-This check compiles to `possiblyNullName == null` in JS, so checks for the presence of `null` or `undefined`.
diff --git a/pages/docs/manual/v10.0.0/null-undefined-option.mdx b/pages/docs/manual/v10.0.0/null-undefined-option.mdx
deleted file mode 100644
index 422fa413c..000000000
--- a/pages/docs/manual/v10.0.0/null-undefined-option.mdx
+++ /dev/null
@@ -1,203 +0,0 @@
----
-title: "Null, Undefined and Option"
-description: "JS interop with nullable and optional values in ReScript"
-canonical: "/docs/manual/latest/null-undefined-option"
----
-
-# Null, Undefined and Option
-
-ReScript itself doesn't have the notion of `null` or `undefined`. This is a _great_ thing, as it wipes out an entire category of bugs. No more `undefined is not a function`, and `cannot access someAttribute of undefined`!
-
-However, the **concept** of a potentially nonexistent value is still useful, and safely exists in our language.
-
-We represent the existence and nonexistence of a value by wrapping it with the `option` type. Here's its definition from the standard library:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type option<'a> = None | Some('a)
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-It means "a value of type option is either None (representing nothing) or that actual value wrapped in a Some".
-
-**Note** how the `option` type is just a regular [variant](variant.md).
-
-## Example
-
-Here's a normal value:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let licenseNumber = 5
-```
-```js
-var licenseNumber = 5;
-```
-
-</CodeTab>
-
-To represent the concept of "maybe null", you'd turn this into an `option` type by wrapping it. For the sake of a more illustrative example, we'll put a condition around it:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let licenseNumber =
-  if personHasACar {
-    Some(5)
-  } else {
-    None
-  }
-```
-```js
-var licenseNumber = personHasACar ? 5 : undefined;
-```
-
-</CodeTab>
-
-Later on, when another piece of code receives such value, it'd be forced to handle both cases through [pattern matching](pattern-matching-destructuring.md):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-switch licenseNumber {
-| None =>
-  Js.log("The person doesn't have a car")
-| Some(number) =>
-  Js.log("The person's license number is " ++ Js.Int.toString(number))
-}
-```
-```js
-var number = licenseNumber;
-
-if (number !== undefined) {
-  console.log("The person's license number is " + number.toString());
-} else {
-  console.log("The person doesn't have a car");
-}
-```
-
-</CodeTab>
-
-By turning your ordinary number into an `option` type, and by forcing you to handle the `None` case, the language effectively removed the possibility for you to mishandle, or forget to handle, a conceptual `null` value! **A pure ReScript program doesn't have null errors**.
-
-## Interoperate with JavaScript `undefined` and `null`
-
-The `option` type is common enough that we special-case it when compiling to JavaScript:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let x = Some(5)
-```
-```js
-var x = 5;
-```
-
-</CodeTab>
-
-simply compiles down to `5`, and
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let x = None
-```
-```js
-var x;
-```
-
-</CodeTab>
-
-compiles to `undefined`! If you've got e.g. a string in JavaScript that you know might be `undefined`, type it as `option<string>` and you're done! Likewise, you can send a `Some(5)` or `None` to the JS side and expect it to be interpreted correctly =)
-
-### Caveat 1
-
-The option-to-undefined translation isn't perfect, because on our side, `option` values can be composed:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let x = Some(Some(Some(5)))
-```
-```js
-var x = 5;
-```
-
-</CodeTab>
-
-This still compiles to `5`, but this gets troublesome:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let x = Some(None)
-```
-```js
-var Caml_option = require("./stdlib/caml_option.js");
-
-var x = Caml_option.some(undefined);
-```
-
-(See output tab).
-
-</CodeTab>
-
-What's this `Caml_option.some` thing? Why can't this compile to `undefined`? Long story short, when dealing with a polymorphic `option` type (aka `option<'a>`, for any `'a`), many operations become tricky if we don't mark the value with some special annotation. If this doesn't make sense, don't worry; just remember the following rule:
-
-- **Never, EVER, pass a nested `option` value (e.g. `Some(Some(Some(5)))`) into the JS side.**
-- **Never, EVER, annotate a value coming from JS as `option<'a>`. Always give the concrete, non-polymorphic type.**
-
-### Caveat 2
-
-Unfortunately, lots of times, your JavaScript value might be _both_ `null` or `undefined`. In that case, you unfortunately can't type such value as e.g. `option<int>`, since our `option` type only checks for `undefined` and not `null` when dealing with a `None`.
-
-#### Solution: More Sophisticated `undefined` & `null` Interop
-
-To solve this, we provide access to more elaborate `null` and `undefined` helpers through the [`Js.Nullable`](api/js/nullable) module. This somewhat works like an `option` type, but is different from it.
-
-#### Examples
-
-To create a JS `null`, use the value `Js.Nullable.null`. To create a JS `undefined`, use `Js.Nullable.undefined` (you can naturally use `None` too, but that's not the point here; the `Js.Nullable.*` helpers wouldn't work with it).
-
-If you're receiving, for example, a JS string that can be `null` and `undefined`, type it as:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("MyConstant") external myId: Js.Nullable.t<string> = "myId"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-To create such a nullable string from our side (presumably to pass it to the JS side, for interop purpose), do:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("MyIdValidator") external validate: Js.Nullable.t<string> => bool = "validate"
-let personId: Js.Nullable.t<string> = Js.Nullable.return("abc123")
-
-let result = validate(personId)
-```
-```js
-var MyIdValidator = require("MyIdValidator");
-var personId = "abc123";
-var result = MyIdValidator.validate(personId);
-```
-
-</CodeTab>
-
-The `return` part "wraps" a string into a nullable string, to make the type system understand and track the fact that, as you pass this value around, it's not just a string, but a string that can be `null` or `undefined`.
-
-#### Convert to/from `option`
-
-`Js.Nullable.fromOption` converts from a `option` to `Js.Nullable.t`. `Js.Nullable.toOption` does the opposite.
diff --git a/pages/docs/manual/v10.0.0/object.mdx b/pages/docs/manual/v10.0.0/object.mdx
deleted file mode 100644
index 3972aecf5..000000000
--- a/pages/docs/manual/v10.0.0/object.mdx
+++ /dev/null
@@ -1,195 +0,0 @@
----
-title: "Object"
-description: "Interoping with JS objects in ReScript"
-canonical: "/docs/manual/latest/object"
----
-
-# Object
-
-ReScript objects are like [records](record.md), but:
-
-- No type declaration needed.
-- Structural and more polymorphic, [unlike records](record.md#record-types-are-found-by-field-name).
-- Doesn't support updates unless the object comes from the JS side.
-- Doesn't support [pattern matching](pattern-matching-destructuring).
-
-<!-- TODO: support update man -->
-
-Although ReScript records compile to clean JavaScript objects, ReScript objects are a better candidate for emulating/binding to JS objects, as you'll see.
-
-## Type Declaration
-
-**Optional**, unlike for records. The type of an object is inferred from the value, so you never really need to write down its type definition. Nevertheless, here's its type declaration syntax:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type person = {
-  "age": int,
-  "name": string
-};
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Visually similar to record type's syntax, with the field names quoted.
-
-<!-- TODO: document {.} and {..} -->
-
-## Creation
-
-To create a new object:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let me = {
-  "age": 5,
-  "name": "Big ReScript"
-}
-```
-```js
-var me = {
-  "age": 5,
-  "name": "Big ReScript"
-};
-```
-
-</CodeTab>
-
-**Note**: as said above, unlike for record, this `me` value does **not** try to find a conforming type declaration with the field `"age"` and `"name"`; rather, the type of `me` is inferred as `{"age": int, "name": string}`. This is convenient, but also means this code passes type checking without errors:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type person = {
-  "age": int
-};
-
-let me = {
-  "age": "hello!" // age is a string. No error.
-}
-```
-```js
-var me = {
-  "age": "hello!"
-};
-```
-
-</CodeTab>
-
-Since the type checker doesn't try to match `me` with the type `person`. If you ever want to force an object value to be of a predeclared object type, just annotate the value:
-
-```res
-let me: person = {
-  "age": "hello!"
-}
-```
-
-Now the type system will error properly.
-
-## Access
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let age = me["age"]
-```
-```js
-var age = me["age"];
-```
-
-</CodeTab>
-
-## Update
-
-Disallowed unless the object is a binding that comes from the JavaScript side. In that case, use `=`
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type student = {
-  @set "age": int,
-  @set "name": string,
-}
-@module("MyJSFile") external student1: student = "student1"
-
-student1["name"] = "Mary"
-```
-```js
-var MyJSFile = require("MyJSFile");
-MyJSFile.student1.name = "Mary";
-```
-
-</CodeTab>
-
-## Combine Types
-
-You can spread one object type definition into another using `...`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type point2d = {
-  "x": float,
-  "y": float,
-}
-type point3d = {
-  ...point2d,
-  "z": float,
-}
-
-let myPoint: point3d = {
-  "x": 1.0,
-  "y": 2.0,
-  "z": 3.0,
-}
-```
-```js
-var myPoint = {
-  x: 1.0,
-  y: 2.0,
-  z: 3.0
-};
-```
-
-</CodeTab>
-
-This only works with object types, not object values!
-
-## Tips & Tricks
-
-Since objects don't require type declarations, and since ReScript infers all the types for you, you get to very quickly and easily (and dangerously) bind to any JavaScript API. Check the JS output tab:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// The type of document is just some random type 'a
-// that we won't bother to specify
-@val external document: 'a = "document"
-
-// call a method
-document["addEventListener"](. "mouseup", _event => {
-  Js.log("clicked!")
-})
-
-// get a property
-let loc = document["location"]
-
-// set a property
-document["location"]["href"] = "rescript-lang.org"
-```
-```js
-document.addEventListener("mouseup", function(_event) {
-  console.log("clicked!");
-});
-var loc = document.location;
-document.location.href = "rescript-lang.org";
-```
-
-</CodeTab>
-
-The `external` feature and the usage of this trick are also documented in the [external](external#tips--tricks) section later. It's an excellent way to start writing some ReScript code without worrying about whether bindings to a particular library exists.
diff --git a/pages/docs/manual/v10.0.0/overview.mdx b/pages/docs/manual/v10.0.0/overview.mdx
deleted file mode 100644
index 48acbcf5d..000000000
--- a/pages/docs/manual/v10.0.0/overview.mdx
+++ /dev/null
@@ -1,246 +0,0 @@
----
-title: "Overview"
-metaTitle: "Language Features Overview"
-description: "A quick overview on ReScript's syntax"
-canonical: "/docs/manual/latest/overview"
----
-
-# Overview
-
-## Comparison to JS
-
-### Semicolon
-
-| JavaScript                           | ReScript             |
-| ------------------------------------ | -------------------- |
-| Rules enforced by linter/formatter   | No semicolon needed! |
-
-### Comments
-
-| JavaScript           | ReScript                         |
-| -------------------- | -------------------------------- |
-| `// Line comment`    | Same                             |
-| `/* Comment */`      | Same                             |
-| `/** Doc Comment */` | `/** Before Types/Values */`     |
-|                      | `/*** Standalone Doc Comment */` |
-
-### Variable
-
-| JavaScript              | ReScript                       |
-| ----------------------- | ------------------------------ |
-| `const x = 5;`          | `let x = 5`                    |
-| `var x = y;`            | No equivalent (thankfully)     |
-| `let x = 5; x = x + 1;` | `let x = ref(5); x := x.contents + 1` |
-
-### String & Character
-
-| JavaScript                | ReScript              |
-| --------------------------| --------------------- |
-| `"Hello world!"`          | Same                  |
-| `'Hello world!'`          | Strings must use `"`  |
-| `"hello " + "world"`      | `"hello " ++ "world"` |
-| `` `hello ${message}` ``  | Same                  |
-
-### Boolean
-
-| JavaScript                            | ReScript                                       |
-| ------------------------------------- | ---------------------------------------------- |
-| `true`, `false`                       | Same                                           |
-| `!true`                               | Same                                           |
-| `\|\|`, `&&`, `<=`, `>=`, `<`, `>`    | Same                                           |
-| `a === b`, `a !== b`                  | Same                                           |
-| No deep equality (recursive compare)  | `a == b`, `a != b`                             |
-| `a == b`                              | No equality with implicit casting (thankfully) |
-
-### Number
-
-| JavaScript  | ReScript     |
-| ----------- | ------------ |
-| `3`         | Same \*      |
-| `3.1415`    | Same         |
-| `3 + 4`     | Same         |
-| `3.0 + 4.5` | `3.0 +. 4.5` |
-| `5 % 3`     | `mod(5, 3)`  |
-
-\* JS has no distinction between integer and float.
-
-### Object/Record
-
-| JavaScript          | ReScript                                |
-| ------------------- | --------------------------------------- |
-| no types            | `type point = {x: int, mutable y: int}` |
-| `{x: 30, y: 20}`    | Same                                    |
-| `point.x`           | Same                                    |
-| `point.y = 30;`     | Same                                    |
-| `{...point, x: 30}` | Same                                    |
-
-### Array
-
-| JavaScript            | ReScript                           |
-| --------------------- | ---------------------------------- |
-| `[1, 2, 3]`           | Same                               |
-| `myArray[1] = 10`     | Same                               |
-| `[1, "Bob", true]`    | `(1, "Bob", true)` \*              |
-
-\* Heterogenous arrays in JS are disallowed for us. Use tuple instead.
-
-### Null
-
-| JavaScript          | ReScript  |
-| ------------------- | --------- |
-| `null`, `undefined` | `None` \* |
-
-\* Again, only a spiritual equivalent; we don't have nulls, nor null bugs! But we do have an `option` type for when you actually need nullability.
-
-### Function
-
-| JavaScript                      | ReScript                     |
-| ------------------------------- | ---------------------------- |
-| `arg => retVal`                 | Same                         |
-| `function named(arg) {...}`     | `let named = (arg) => {...}` |
-| `const f = function(arg) {...}` | `let f = (arg) => {...}`     |
-| `add(4, add(5, 6))`             | Same                         |
-
-### Async Function / Await
-
-| JavaScript                               | ReScript                           |
-| ---------------------------------------- | ---------------------------------- |
-| `async (arg) => {...}`                   | Same                               |
-| `async function named(arg) {...}`        | `let named = async (arg) => {...}` |
-| `await somePromise`                      | Same                               |
-| `async (arg): Promise<string> => {...}`  | `async (): string => {...}` (note the return type)|
-
-### Blocks
-
-<table>
-  <thead>
-    <tr>
-      <th>JavaScript</th>
-      <th>ReScript  </th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>
-  <pre><code>{`const myFun = (x, y) => {
-  const doubleX = x + x;
-  const doubleY = y + y;
-  return doubleX + doubleY;
-};`}</code></pre>
-      </td>
-      <td>
-  <pre><code>{`let myFun = (x, y) => {
-  let doubleX = x + x
-  let doubleY = y + y
-  doubleX + doubleY
-}`}</code></pre>
-      </td>
-    </tr>
-  </tbody>
-</table>
-
-### If-else
-
-| JavaScript            | ReScript                                                            |
-| --------------------- | ------------------------------------------------------------------- |
-| `if (a) {b} else {c}` | `if a {b} else {c}` \*                                              |
-| `a ? b : c`           | Same                                                                |
-| `switch`              | `switch` but [super-powered pattern matching!](pattern-matching-destructuring.md) |
-
-\* Our conditionals are always expressions! You can write `let result = if a {"hello"} else {"bye"}`
-
-### Destructuring
-
-| JavaScript                    | ReScript                                      |
-| ----------------------------- | --------------------------------------------- |
-| `const {a, b} = data`         | `let {a, b} = data`                           |
-| `const [a, b] = data`         | <code>let [a, b] = data</code> \*             |
-| `const {a: aa, b: bb} = data` | `let {a: aa, b: bb} = data`                   |
-
-\* Gives good compiler warning that `data` might not be of length 2.
-
-### Loop
-
-| JavaScript                            | ReScript                       |
-| ------------------------------------- | ------------------------------ |
-| `for (let i = 0; i <= 10; i++) {...}` | `for i in 0 to 10 {...}`       |
-| `for (let i = 10; i >= 0; i--) {...}` | `for i in 10 downto 0 {...}`   |
-| `while (true) {...}`                  | `while true {...}`             |
-
-### JSX
-
-| JavaScript                                | ReScript                   |
-| ----------------------------------------- | -------------------------- |
-| `<Comp message="hi" onClick={handler} />` | Same                       |
-| `<Comp message={message} />`              | `<Comp message />` \*      |
-| `<input checked />`                       | `<input checked=true />`   |
-| No children spread                        | `<Comp>...children</Comp>` |
-
-\* Argument punning!
-
-### Exception
-
-| JavaScript                                      | ReScript                                   |
-| ----------------------------------------------- | ------------------------------------------ |
-| `throw new SomeError(...)`                      | `raise(SomeError(...))`                    |
-| `try {a} catch (Err) {...} finally {...}`       | `try a catch { \| Err => ...}` \* |
-
-\* No finally.
-
-### Blocks
-
-The last expression of a block delimited by `{}` implicitly returns (including function body). In JavaScript, this can only be simulated via an immediately-invoked function expression (since function bodies have their own local scope).
-
-<table>
-  <thead>
-    <tr>
-      <th>JavaScript</th>
-      <th>ReScript</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>
-  <pre><code>{`let result = (function() {
-  const x = 23;
-  const y = 34;
-  return x + y;
-})();`}</code></pre>
-      </td>
-      <td>
-  <pre><code>{`let result = {
-  let x = 23
-  let y = 34
-  x + y
-}`}</code></pre>
-      </td>
-    </tr>
-  </tbody>
-</table>
-
-## Common Features' JS Output
-
-Feature                         | Example                              | JavaScript Output
---------------------------------|--------------------------------------|----------------------
-String                          | `"Hello"`                            | `"Hello"`
-String Interpolation            | `` `Hello ${message}` ``             | `"Hello " + message`
-Character (disrecommended)      | `'x'`                                | `120` (char code)
-Integer                         | `23`, `-23`                          | `23`, `-23`
-Float                           | `23.0`, `-23.0`                      | `23.0`, `-23.0`
-Integer Addition                | `23 + 1`                             | `23 + 1`
-Float Addition                  | `23.0 +. 1.0`                        | `23.0 + 1.0`
-Integer Division/Multiplication | `2 / 23 * 1`                         | `2 / 23 * 1`
-Float Division/Multiplication   | `2.0 /. 23.0 *. 1.0`                 | `2.0 / 23.0 * 1.0`
-Float Exponentiation            | `2.0 ** 3.0`                         | `Math.pow(2.0, 3.0)`
-String Concatenation            | `"Hello " ++ "World"`                | `"Hello " + "World"`
-Comparison                      | `>`, `<`, `>=`, `<=`                 | `>`, `<`, `>=`, `<=`
-Boolean operation               | `!`, `&&`, `\|\|`                    | `!`, `&&`, `\|\|`
-Shallow and deep Equality       | `===`, `==`                          | `===`, `==`
-List (disrecommended)           | `list{1, 2, 3}`                      | `{hd: 1, tl: {hd: 2, tl: {hd: 3, tl: 0}}}`
-List Prepend                    | `list{a1, a2, ...oldList}`           | `{hd: a1, tl: {hd: a2, tl: theRest}}`
-Array                           | `[1, 2, 3]`                          | `[1, 2, 3]`
-Record                          | `type t = {b: int}; let a = {b: 10}` | `var a = {b: 10}`
-Multiline Comment               | `/* Comment here */`                 | Not in output
-Single line Comment             | `// Comment here`                    | Not in output
-
-_Note that this is a cleaned-up comparison table; a few examples' JavaScript output are slightly different in reality._
diff --git a/pages/docs/manual/v10.0.0/pattern-matching-destructuring.mdx b/pages/docs/manual/v10.0.0/pattern-matching-destructuring.mdx
deleted file mode 100644
index 673b27d31..000000000
--- a/pages/docs/manual/v10.0.0/pattern-matching-destructuring.mdx
+++ /dev/null
@@ -1,876 +0,0 @@
----
-title: "Pattern Matching / Destructuring"
-description: "Pattern matching and destructuring complex data structures in ReScript"
-canonical: "/docs/manual/latest/pattern-matching-destructuring"
----
-
-# Pattern Matching / Destructuring
-
-One of ReScript's **best** feature is our pattern matching. Pattern matching combines 3 brilliant features into one:
-
-- Destructuring.
-- `switch` based on shape of data.
-- Exhaustiveness check.
-
-We'll dive into each aspect below.
-
-## Destructuring
-
-Even JavaScript has destructuring, which is "opening up" a data structure to extract the parts we want and assign variable names to them:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let coordinates = (10, 20, 30)
-let (x, _, _) = coordinates
-Js.log(x) // 10
-```
-```js
-var coordinates = [10, 20, 30];
-var x = 10;
-console.log(10);
-```
-
-</CodeTab>
-
-Destructuring works with most built-in data structures:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Record
-type student = {name: string, age: int}
-let student1 = {name: "John", age: 10}
-let {name} = student1 // "John" assigned to `name`
-
-// Variant
-type result =
-  | Success(string)
-let myResult = Success("You did it!")
-let Success(message) = myResult // "You did it!" assigned to `message`
-```
-```js
-var student1 = {
-  name: "John",
-  age: 10
-};
-var name = "John";
-
-var myResult = /* Success */{
-  _0: "You did it!"
-};
-var message = "You did it!"
-
-var myArray = [1, 2, 3];
-if (myArray.length !== 2) {
-  throw {
-    RE_EXN_ID: "Match_failure",
-    _1: [
-      "playground.res",
-      14,
-      4
-    ],
-    Error: new Error()
-  };
-}
-var item1 = myArray[0];
-var item2 = myArray[1];
-
-var myList = {
-  hd: 1,
-  tl: {
-    hd: 2,
-    tl: {
-      hd: 3,
-      tl: /* [] */0
-    }
-  }
-};
-// ...
-```
-
-</CodeTab>
-
-You can also use destructuring anywhere you'd usually put a binding:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type result =
-  | Success(string)
-let displayMessage = (Success(m)) => {
-  // we've directly extracted the success message
-  // string by destructuring the parameter
-  Js.log(m)
-}
-displayMessage(Success("You did it!"))
-```
-```js
-function displayMessage(m) {
-  console.log(m._0);
-}
-
-displayMessage(/* Success */{
-  _0: "You did it!"
-});
-```
-
-</CodeTab>
-
-For a record, you can rename the field while destructuring:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let {name: n} = student1 // "John" assigned to `n`
-```
-```js
-var n = "John";
-```
-
-</CodeTab>
-
-You _can_ in theory destructure array and list at the top level too:
-
-```res
-let myArray = [1, 2, 3]
-let [item1, item2, _] = myArray
-// 1 assigned to `item1`, 2 assigned to `item2`, 3rd item ignored
-
-let myList = list{1, 2, 3}
-let list{head, ...tail} = myList
-// 1 assigned to `head`, `list{2, 3}` assigned to tail
-```
-
-But the array example is **highly disrecommended** (use tuple instead) and the list example will error on you. They're only there for completeness' sake. As you'll see below, the proper way of using destructuring array and list is using `switch`.
-
-## `switch` Based on Shape of Data
-
-While the destructuring aspect of pattern matching is nice, it doesn't really change the way you think about structuring your code. One paradigm-changing way of thinking about your code is to execute some code based on the shape of the data.
-
-Consider a variant:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type payload =
-  | BadResult(int)
-  | GoodResult(string)
-  | NoResult
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-We'd like to handle each of the 3 cases differently. For example, print a success message if the value is `GoodResult(...)`, do something else when the value is `NoResult`, etc.
-
-In other languages, you'd end up with a series of if-elses that are hard to read and error-prone. In ReScript, you can instead use the supercharged `switch` pattern matching facility to destructure the value while calling the right code based on what you destructured:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let data = GoodResult("Product shipped!")
-switch data {
-| GoodResult(theMessage) =>
-  Js.log("Success! " ++ theMessage)
-| BadResult(errorCode) =>
-  Js.log("Something's wrong. The error code is: " ++ Js.Int.toString(errorCode))
-| NoResult =>
-  Js.log("Bah.")
-}
-```
-```js
-var data = {
-  TAG: /* GoodResult */1,
-  _0: "Product shipped!"
-};
-
-if (typeof data === "number") {
-  console.log("Bah.");
-} else if (data.TAG === /* BadResult */ 0) {
-  console.log("Something's wrong. The error code is: " + "Product shipped!".toString());
-} else {
-  console.log("Success! Product shipped!");
-}
-```
-
-</CodeTab>
-
-In this case, `message` will have the value `"Success! Product shipped!"`.
-
-Suddenly, your if-elses that messily checks some structure of the value got turned into a clean, compiler-verified, linear list of code to execute based on exactly the shape of the value.
-
-### Complex Examples
-
-Here's a real-world scenario that'd be a headache to code in other languages. Given this data structure:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type status = Vacations(int) | Sabbatical(int) | Sick | Present
-type reportCard = {passing: bool, gpa: float}
-type person =
-  | Teacher({
-    name: string,
-    age: int,
-  })
-  | Student({
-    name: string,
-    status: status,
-    reportCard: reportCard,
-  })
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Imagine this requirement:
-
-- Informally greet a person who's a teacher and if his name is Mary or Joe.
-- Greet other teachers formally.
-- If the person's a student, congratulate him/her score if they passed the semester.
-- If the student has a gpa of 0 and is on vacations or sabbatical, display a different message.
-- A catch-all message for a student.
-
-ReScript can do this easily!
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let person1 = Teacher({name: "Jane", age: 35})
-
-let message = switch person1 {
-| Teacher({name: "Mary" | "Joe"}) =>
-  `Hey, still going to the party on Saturday?`
-| Teacher({name}) =>
-  // this is matched only if `name` isn't "Mary" or "Joe"
-  `Hello ${name}.`
-| Student({name, reportCard: {passing: true, gpa}}) =>
-  `Congrats ${name}, nice GPA of ${Js.Float.toString(gpa)} you got there!`
-| Student({
-    reportCard: {gpa: 0.0},
-    status: Vacations(daysLeft) | Sabbatical(daysLeft)
-  }) =>
-  `Come back in ${Js.Int.toString(daysLeft)} days!`
-| Student({status: Sick}) =>
-  `How are you feeling?`
-| Student({name}) =>
-  `Good luck next semester ${name}!`
-}
-```
-```js
-var person1 = {
-  TAG: /* Teacher */0,
-  name: "Jane",
-  age: 35
-};
-
-var message;
-
-if (person1.TAG) {
-  var match$1 = person1.status;
-  var name = person1.name;
-  var match$2 = person1.reportCard;
-  message = match$2.passing
-    ? "Congrats " +
-      name +
-      ", nice GPA of " +
-      match$2.gpa.toString() +
-      " you got there!"
-    : typeof match$1 === "number"
-    ? match$1 !== 0
-      ? "Good luck next semester " + name + "!"
-      : "How are you feeling?"
-    : person1.reportCard.gpa !== 0.0
-    ? "Good luck next semester " + name + "!"
-    : "Come back in " + match$1._0.toString() + " days!";
-} else {
-  var name$1 = person1.name;
-  switch (name$1) {
-    case "Joe":
-    case "Mary":
-      message = "Hey, still going to the party on Saturday?";
-      break;
-    default:
-      message = "Hello " + name$1 + ".";
-  }
-}
-```
-
-</CodeTab>
-
-**Note** how we've:
-- drilled deep down into the value concisely
-- using a **nested pattern check** `"Mary" | "Joe"` and `Vacations | Sabbatical`
-- while extracting the `daysLeft` number from the latter case
-- and assigned the greeting to the binding `message`.
-
-Here's another example of pattern matching, this time on an inline tuple.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type animal = Dog | Cat | Bird
-let categoryId = switch (isBig, myAnimal) {
-| (true, Dog) => 1
-| (true, Cat) => 2
-| (true, Bird) => 3
-| (false, Dog | Cat) => 4
-| (false, Bird) => 5
-}
-```
-```js
-var categoryId = isBig ? (myAnimal + 1) | 0 : myAnimal >= 2 ? 5 : 4;
-```
-
-</CodeTab>
-
-**Note** how pattern matching on a tuple is equivalent to a 2D table:
-
-isBig \ myAnimal | Dog | Cat | Bird
------------------|-----|-----|------
-true             |  1  |  2  |  3
-false            |  4  |  4  |  5
-
-### Fall-Through Patterns
-
-The nested pattern check, demonstrated in the earlier `person` example, also works at the top level of a `switch`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let myStatus = Vacations(10)
-
-switch myStatus {
-| Vacations(days)
-| Sabbatical(days) => Js.log(`Come back in ${Js.Int.toString(days)} days!`)
-| Sick
-| Present => Js.log("Hey! How are you?")
-}
-```
-```js
-var myStatus = {
-  TAG: /* Vacations */0,
-  _0: 10
-};
-
-if (typeof myStatus === "number") {
-  console.log("Hey! How are you?");
-} else {
-  console.log("Come back in " + (10).toString() + " days!");
-}
-```
-
-</CodeTab>
-
-Having multiple cases fall into the same handling can clean up certain types of logic.
-
-### Ignore Part of a Value
-
-If you have a value like `Teacher(payload)` where you just want to pattern match on the `Teacher` part and ignore the `payload` completely, you can use the `_` wildcard like this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch person1 {
-| Teacher(_) => Js.log("Hi teacher")
-| Student(_) => Js.log("Hey student")
-}
-```
-```js
-if (person1.TAG) {
-  console.log("Hey student");
-} else {
-  console.log("Hi teacher");
-}
-```
-
-</CodeTab>
-
-`_` also works at the top level of the `switch`, serving as a catch-all condition:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch myStatus {
-| Vacations(_) => Js.log("Have fun!")
-| _ => Js.log("Ok.")
-}
-```
-```js
-if (typeof myStatus === "number" || myStatus.TAG) {
-  console.log("Ok.");
-} else {
-  console.log("Have fun!");
-}
-```
-
-</CodeTab>
-
-**Do not** abuse a top-level catch-all condition. Instead, prefer writing out all the cases:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch myStatus {
-| Vacations(_) => Js.log("Have fun!")
-| Sabbatical(_) | Sick | Present => Js.log("Ok.")
-}
-```
-```js
-if (typeof myStatus === "number" || myStatus.TAG) {
-  console.log("Ok.");
-} else {
-  console.log("Have fun!");
-}
-```
-
-</CodeTab>
-
-Slightly more verbose, but a one-time writing effort. This helps when you add a new variant case e.g. `Quarantined` to the `status` type and need to update the places that pattern match on it. A top-level wildcard here would have accidentally and silently continued working, potentially causing bugs.
-
-### If Clause
-
-Sometime, you want to check more than the shape of a value. You want to also run some arbitrary check on it. You might be tempted to write this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch person1 {
-| Teacher(_) => () // do nothing
-| Student({reportCard: {gpa}}) =>
-  if gpa < 0.5 {
-    Js.log("What's happening")
-  } else {
-    Js.log("Heyo")
-  }
-}
-```
-```js
-if (person1.TAG) {
-  if (person1.reportCard.gpa < 0.5) {
-    console.log("What's happening");
-  } else {
-    console.log("Heyo");
-  }
-}
-```
-
-</CodeTab>
-
-`switch` patterns support a shortcut for the arbitrary `if` check, to keep your pattern linear-looking:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch person1 {
-| Teacher(_) => () // do nothing
-| Student({reportCard: {gpa}}) if gpa < 0.5 =>
-  Js.log("What's happening")
-| Student(_) =>
-  // fall-through, catch-all case
-  Js.log("Heyo")
-}
-```
-```js
-if (person1.TAG) {
-  if (person1.reportCard.gpa < 0.5) {
-    console.log("What's happening");
-  } else {
-    console.log("Heyo");
-  }
-}
-```
-
-</CodeTab>
-
-**Note:** Rescript versions < 9.0 had a `when` clause, not an `if` clause.  Rescript 9.0 changed `when` to `if`.  (`when` may still work, but is deprecated.)
-
-### Match on Exceptions
-
-If the function throws an exception (covered later), you can also match on _that_, in addition to the function's normally returned values.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-switch List.find(i => i === theItem, myItems) {
-| item => Js.log(item)
-| exception Not_found => Js.log("No such item found!")
-}
-```
-```js
-var exit = 0;
-
-var item;
-
-try {
-  item = List.find(function(i) {
-    return i === theItem;
-  }, myItems);
-  exit = 1;
-}
-catch (raw_exn){
-  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-  if (exn.RE_EXN_ID === "Not_found") {
-    console.log("No such item found!");
-  } else {
-    throw exn;
-  }
-}
-
-if (exit === 1) {
-  console.log(item);
-}
-```
-
-</CodeTab>
-
-### Match on Array
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let students = ["Jane", "Harvey", "Patrick"]
-switch students {
-| [] => Js.log("There are no students")
-| [student1] =>
-  Js.log("There's a single student here: " ++ student1)
-| manyStudents =>
-  // display the array of names
-  Js.log2("The students are: ", manyStudents)
-}
-```
-```js
-var students = ["Jane", "Harvey", "Patrick"];
-
-var len = students.length;
-
-if (len !== 1) {
-  if (len !== 0) {
-    console.log("The students are: ", students);
-  } else {
-    console.log("There are no students");
-  }
-} else {
-  var student1 = students[0];
-  console.log("There's a single student here: " + student1);
-}
-```
-
-</CodeTab>
-
-### Match on List
-
-Pattern matching on list is similar to array, but with the extra feature of extracting the tail of a list (all elements except the first one):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let rec printStudents = (students) => {
-  switch students {
-  | list{} => () // done
-  | list{student} => Js.log("Last student: " ++ student)
-  | list{student1, ...otherStudents} =>
-    Js.log(student1)
-    printStudents(otherStudents)
-  }
-}
-printStudents(list{"Jane", "Harvey", "Patrick"})
-```
-```js
-function printStudents(_students) {
-  while(true) {
-    var students = _students;
-    if (!students) {
-      return;
-    }
-    var otherStudents = students.tl;
-    var student = students.hd;
-    if (otherStudents) {
-      console.log(student);
-      _students = otherStudents;
-      continue;
-    }
-    console.log("Last student: " + student);
-    return;
-  };
-}
-
-printStudents({
-  hd: "Jane",
-  tl: {
-    hd: "Harvey",
-    tl: {
-      hd: "Patrick",
-      tl: /* [] */0
-    }
-  }
-});
-```
-
-</CodeTab>
-
-
-### Small Pitfall
-
-**Note**: you can only pass literals (i.e. concrete values) as a pattern, not let-binding names or other things. The following doesn't work as expected:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let coordinates = (10, 20, 30)
-let centerY = 20
-switch coordinates {
-| (x, centerY, _) => Js.log(x)
-}
-```
-```js
-var coordinates = [10, 20, 30];
-var centerY = 20;
-
-console.log(10);
-```
-
-</CodeTab>
-
-A first time ReScript user might accidentally write that code, assuming that it's matching on `coordinates` when the second value is of the same value as `centerY`. In reality, this is interpreted as matching on coordinates and assigning the second value of the tuple to the name `centerY`, which isn't what's intended.
-
-## Exhaustiveness Check
-
-As if the above features aren't enough, ReScript also provides arguably the most important pattern matching feature: **compile-time check of missing patterns**.
-
-Let's revisit one of the above examples:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let message = switch person1 {
-| Teacher({name: "Mary" | "Joe"}) =>
-  `Hey, still going to the party on Saturday?`
-| Student({name, reportCard: {passing: true, gpa}}) =>
-  `Congrats ${name}, nice GPA of ${Js.Float.toString(gpa)} you got there!`
-| Student({
-    reportCard: {gpa: 0.0},
-    status: Vacations(daysLeft) | Sabbatical(daysLeft)
-  }) =>
-  `Come back in ${Js.Int.toString(daysLeft)} days!`
-| Student({status: Sick}) =>
-  `How are you feeling?`
-| Student({name}) =>
-  `Good luck next semester ${name}!`
-}
-```
-```js
-if (person1.TAG) {
-  var match$1 = person1.status;
-  var name = person1.name;
-  var match$2 = person1.reportCard;
-  if (match$2.passing) {
-    "Congrats " + name + ", nice GPA of " + match$2.gpa.toString() + " you got there!";
-  } else if (typeof match$1 === "number") {
-    if (match$1 !== 0) {
-      "Good luck next semester " + name + "!";
-    } else {
-      "How are you feeling?";
-    }
-  } else if (person1.reportCard.gpa !== 0.0) {
-    "Good luck next semester " + name + "!";
-  } else {
-    "Come back in " + match$1._0.toString() + " days!";
-  }
-} else {
-  switch (person1.name) {
-    case "Joe":
-    case "Mary":
-      break;
-    default:
-      throw {
-        RE_EXN_ID: "Match_failure",
-        _1: [
-          "playground.res",
-          13,
-          0
-        ],
-        Error: new Error()
-      };
-  }
-}
-```
-
-</CodeTab>
-
-Did you see what we removed? This time, we've omitted the handling of the case where `person1` is `Teacher({name})` when `name` isn't Mary or Joe.
-
-Failing to handle every scenario of a value likely constitutes the majority of program bugs out there. This happens very often when you refactor a piece of code someone else wrote. Fortunately for ReScript, the compiler will tell you so:
-
-```
-Warning 8: this pattern-matching is not exhaustive.
-Here is an example of a value that is not matched:
-Some({name: ""})
-```
-
-**BAM**! You've just erased an entire category of important bugs before you even ran the code. In fact, this is how most of nullable values is handled:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myNullableValue = Some(5)
-
-switch myNullableValue {
-| Some(v) => Js.log("value is present")
-| None => Js.log("value is absent")
-}
-```
-```js
-var myNullableValue = 5;
-
-if (myNullableValue !== undefined) {
-  console.log("value is present");
-} else {
-  console.log("value is absent");
-}
-```
-
-</CodeTab>
-
-If you don't handle the `None` case, the compiler warns. No more `undefined` bugs in your code!
-
-## Conclusion & Tips & Tricks
-
-Hopefully you can see how pattern matching is a game changer for writing correct code, through the concise destructuring syntax, the proper conditions handling of `switch`, and the static exhaustiveness check.
-
-Below is some advice:
-
-Avoid using the wildcard `_` unnecessarily.  Using the wildcard `_` will bypass the compiler's exhaustiveness check.  Consequently, the compiler will not be able to notify you of probable errors when you add a new case to a variant. Try only using `_` against infinite possibilities, e.g. string, int, etc.
-
-Use the `if` clause sparingly.
-
-**Flatten your pattern-match whenever you can**. This is a real bug remover. Here's a series of examples, from worst to best:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let optionBoolToBool = opt => {
-  if opt == None {
-    false
-  } else if opt === Some(true) {
-    true
-  } else {
-    false
-  }
-}
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt === undefined) {
-    return false;
-  } else {
-    return opt === true;
-  }
-}
-```
-
-</CodeTab>
-
-Now that's just silly =). Let's turn it into pattern-matching:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let optionBoolToBool = opt => {
-  switch opt {
-  | None => false
-  | Some(a) => a ? true : false
-  }
-}
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt !== undefined && opt) {
-    return true;
-  } else {
-    return false;
-  }
-}
-```
-
-</CodeTab>
-
-Slightly better, but still nested. Pattern-matching allows you to do this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let optionBoolToBool = opt => {
-  switch opt {
-  | None => false
-  | Some(true) => true
-  | Some(false) => false
-  }
-}
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt !== undefined && opt) {
-    return true;
-  } else {
-    return false;
-  }
-}
-```
-
-</CodeTab>
-
-Much more linear-looking! Now, you might be tempted to do this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let optionBoolToBool = opt => {
-  switch opt {
-  | Some(true) => true
-  | _ => false
-  }
-}
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt !== undefined && opt) {
-    return true;
-  } else {
-    return false;
-  }
-}
-```
-
-</CodeTab>
-
-Which is much more concise, but kills the exhaustiveness check mentioned above; refrain from using that. This is the best:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let optionBoolToBool = opt => {
-  switch opt {
-  | Some(trueOrFalse) => trueOrFalse
-  | None => false
-  }
-}
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt !== undefined) {
-    return opt;
-  } else {
-    return false;
-  }
-}
-```
-
-</CodeTab>
-
-Pretty darn hard to make a mistake in this code at this point! Whenever you'd like to use an if-else with many branches, prefer pattern matching instead. It's more concise and [performant](variant#design-decisions) too.
diff --git a/pages/docs/manual/v10.0.0/pipe.mdx b/pages/docs/manual/v10.0.0/pipe.mdx
deleted file mode 100644
index 776c268bb..000000000
--- a/pages/docs/manual/v10.0.0/pipe.mdx
+++ /dev/null
@@ -1,244 +0,0 @@
----
-title: "Pipe"
-description: "The Pipe operator (->)"
-canonical: "/docs/manual/latest/pipe"
----
-
-# Pipe
-
-ReScript provides a tiny but surprisingly useful operator `->`, called the "pipe", that allows you to "flip" your code inside-out. `a(b)` becomes `b->a`. It's a simple piece of syntax that doesn't have any runtime cost.
-
-Why would you use it? Imagine you have the following:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-validateAge(getAge(parseData(person)))
-```
-```js
-validateAge(getAge(parseData(person)));
-```
-
-</CodeTab>
-
-This is slightly hard to read, since you need to read the code from the innermost part, to the outer parts. Use pipe to streamline it:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-person
-  ->parseData
-  ->getAge
-  ->validateAge
-```
-```js
-validateAge(getAge(parseData(person)));
-```
-
-</CodeTab>
-
-Basically, `parseData(person)` is transformed into `person->parseData`, and `getAge(person->parseData)` is transformed into `person->parseData->getAge`, etc.
-
-**This works when the function takes more than one argument too**.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-a(one, two, three)
-```
-```js
-a(one, two, three);
-```
-
-</CodeTab>
-
-is the same as
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-one->a(two, three)
-```
-```js
-a(one, two, three);
-```
-
-</CodeTab>
-
-This also works with labeled arguments.
-
-Pipes are used to emulate object-oriented programming. For example, `myStudent.getName` in other languages like Java would be `myStudent->getName` in ReScript (equivalent to `getName(myStudent)`). This allows us to have the readability of OOP without the downside of dragging in a huge class system just to call a function on a piece of data.
-
-## Tips & Tricks
-
-Do **not** abuse pipes; they're a means to an end. Inexperienced engineers sometimes shape a library's API to take advantage of the pipe. This is backwards.
-
-## JS Method Chaining
-
-_This section requires understanding of [our binding API](bind-to-js-function.md#object-method)_.
-
-JavaScript's APIs are often attached to objects, and are often chainable, like so:
-
-```js
-const result = [1, 2, 3].map(a => a + 1).filter(a => a % 2 === 0);
-
-asyncRequest()
-  .setWaitDuration(4000)
-  .send();
-```
-
-Assuming we don't need the chaining behavior above, we'd bind to each case this using [`@send`](/syntax-lookup#send-decorator) from the aforementioned binding API page:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type request
-@val external asyncRequest: unit => request = "asyncRequest"
-@send external setWaitDuration: (request, int) => request = "setWaitDuration"
-@send external send: request => unit = "send"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-You'd use them like this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let result = Js.Array2.filter(
-  Js.Array2.map([1, 2, 3], a => a + 1),
-  a => mod(a, 2) == 0
-)
-
-send(setWaitDuration(asyncRequest(), 4000))
-```
-```js
-var result = [1, 2, 3].map(function(a) {
-  return a + 1 | 0;
-}).filter(function(a) {
-  return a % 2 === 0;
-});
-
-asyncRequest().setWaitDuration(4000).send();
-```
-
-</CodeTab>
-
-This looks much worse than the JS counterpart! Clean it up visually with pipe:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let result = [1, 2, 3]
-  ->Js.Array2.map(a => a + 1)
-  ->Js.Array2.filter(a => mod(a, 2) == 0)
-
-asyncRequest()->setWaitDuration(4000)->send
-```
-```js
-var result = [1, 2, 3].map(function(a) {
-  return a + 1 | 0;
-}).filter(function(a) {
-  return a % 2 === 0;
-});
-
-asyncRequest().setWaitDuration(4000).send();
-```
-
-</CodeTab>
-
-## Pipe Into Variants
-
-You can pipe into a variant's constructor as if it was a function:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result = name->preprocess->Some
-```
-```js
-var result = preprocess(name);
-```
-
-</CodeTab>
-
-We turn this into:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result = Some(preprocess(name))
-```
-```js
-var result = preprocess(name);
-```
-
-</CodeTab>
-
-**Note** that using a variant constructor as a function wouldn't work anywhere else beside here.
-
-## Pipe Placeholders
-
-A placeholder is written as an underscore and it tells ReScript that you want to fill in an argument of a function later. These two have equivalent meaning:
-
-```res
-let addTo7 = (x) => add3(3, x, 4)
-let addTo7 = add3(3, _, 4)
-```
-
-Sometimes you don't want to pipe the value you have into the first position. In these cases you can mark a placeholder value to show which argument you would like to pipe into.
-
-Let's say you have a function `namePerson`, which takes a `person` then a `name` argument. If you are transforming a person then pipe will work as-is:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-makePerson(~age=47, ())
-  ->namePerson("Jane")
-```
-```js
-namePerson(makePerson(47), "Jane");
-```
-
-</CodeTab>
-
-If you have a name that you want to apply to a person object, you can use a placeholder:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-getName(input)
-  ->namePerson(personDetails, _)
-```
-```js
-var __x = getName(input);
-namePerson(personDetails, __x);
-```
-
-</CodeTab>
-
-This allows you to pipe into any positional argument. It also works for named arguments:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-getName(input)
-  ->namePerson(~person=personDetails, ~name=_)
-```
-```js
-var __x = getName(input);
-namePerson(personDetails, __x);
-```
-
-</CodeTab>
-
-## Triangle Pipe (Deprecated)
-
-You might see usages of another pipe, `|>`, in some codebases. These are deprecated.
-
-Unlike `->` pipe, the `|>` pipe puts the subject as the last (not first) argument of the function. `a |> f(b)` turns into `f(b, a)`.
-
-For a more thorough discussion on the rationale and differences between the two operators, please refer to the [Data-first and Data-last comparison by Javier Chávarri](https://www.javierchavarri.com/data-first-and-data-last-a-comparison/)
diff --git a/pages/docs/manual/v10.0.0/polymorphic-variant.mdx b/pages/docs/manual/v10.0.0/polymorphic-variant.mdx
deleted file mode 100644
index 62630dfef..000000000
--- a/pages/docs/manual/v10.0.0/polymorphic-variant.mdx
+++ /dev/null
@@ -1,433 +0,0 @@
----
-title: "Polymorphic Variant"
-description: "The Polymorphic Variant data structure in ReScript"
-canonical: "/docs/manual/latest/polymorphic-variant"
----
-
-# Polymorphic Variant
-
-Polymorphic variants (or poly variant) are a cousin of [variant](variant). With these differences:
-
-- They start with a `#` and the constructor name doesn't need to be capitalized.
-- They don't require an explicit type definition. The type is inferred from usage.
-- Values of different poly variant types can share the constructors they have in common (aka, poly variants are "structurally" typed, as opposed to ["nominally" typed](variant#variant-types-are-found-by-field-name)).
-
-They're a convenient and useful alternative to regular variants, but should **not** be abused. See the drawbacks at the end of this page.
-
-## Creation
-
-We provide 3 syntaxes for a poly variant's constructor:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let myColor = #red
-let myLabel = #"aria-hidden"
-let myNumber = #7
-```
-
-```js
-var myColor = "red";
-var myLabel = "aria-hidden";
-var myNumber = 7;
-```
-
-</CodeTab>
-
-**Take a look at the output**. Poly variants are _great_ for JavaScript interop. For example, you can use it to model JavaScript string and number enums like TypeScript, but without confusing their accidental usage with regular strings and numbers.
-
-`myColor` uses the common syntax. The second and third syntaxes are to support expressing strings and numbers more conveniently. We allow the second one because otherwise it'd be invalid syntax since symbols like `-` and others are usually reserved.
-
-## Type Declaration
-
-Although **optional**, you can still pre-declare a poly variant type:
-
-```res
-// Note the surrounding square brackets, and # for constructors
-type color = [#red | #green | #blue]
-```
-
-These types can also be inlined, unlike for regular variant:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let render = (myColor: [#red | #green | #blue]) => {
-  switch myColor {
-  | #blue => Js.log("Hello blue!")
-  | #red
-  | #green => Js.log("Hello other colors")
-  }
-}
-```
-
-```js
-function render(myColor) {
-  if (myColor === "green" || myColor === "red") {
-    console.log("Hello other colors");
-  } else {
-    console.log("Hello blue!");
-  }
-}
-```
-
-</CodeTab>
-
-**Note**: because a poly variant value's type definition is **inferred** and not searched in the scope, the following snippet won't error:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type color = [#red | #green | #blue]
-
-let render = myColor => {
-  switch myColor {
-  | #blue => Js.log("Hello blue!")
-  | #green => Js.log("Hello green!")
-  // works!
-  | #yellow => Js.log("Hello yellow!")
-  }
-}
-```
-
-```js
-function render(myColor) {
-  if (myColor === "yellow") {
-    console.log("Hello yellow!");
-  } else if (myColor === "green") {
-    console.log("Hello green!");
-  } else {
-    console.log("Hello blue!");
-  }
-}
-```
-
-</CodeTab>
-
-That `myColor` parameter's type is inferred to be `#red`, `#green` or `#yellow`, and is unrelated to the `color` type. If you intended `myColor` to be of type `color`, annotate it as `myColor: color` in any of the places.
-
-## Constructor Arguments
-
-This is similar to a regular variant's [constructor arguments](variant#constructor-arguments):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type account = [
-  | #Anonymous
-  | #Instagram(string)
-  | #Facebook(string, int)
-]
-
-let me: account = #Instagram("Jenny")
-let him: account = #Facebook("Josh", 26)
-```
-
-```js
-var me = {
-  NAME: "Instagram",
-  VAL: "Jenny"
-};
-
-var him = {
-  NAME: "Facebook",
-  VAL: [
-    "Josh",
-    26
-  ]
-};
-```
-
-</CodeTab>
-
-### Combine Types and Pattern Match
-
-You can use poly variant types within other poly variant types to create a sum of all constructors:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type red = [#Ruby | #Redwood | #Rust]
-type blue = [#Sapphire | #Neon | #Navy]
-
-// Contains all constructors of red and blue.
-// Also adds #Papayawhip
-type color = [red | blue | #Papayawhip]
-
-let myColor: color = #Ruby
-```
-
-```js
-var myColor = "Ruby";
-```
-
-</CodeTab>
-
-There's also some special [pattern matching](./pattern-matching-destructuring) syntax to match on constructors defined in a specific poly variant type:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Continuing the previous example above...
-
-switch myColor {
-| #...blue => Js.log("This blue-ish")
-| #...red => Js.log("This red-ish")
-| other => Js.log2("Other color than red and blue: ", other)
-}
-```
-
-```js
-var other = myColor;
-
-if (other === "Neon" || other === "Navy" || other === "Sapphire") {
-  console.log("This is blue-ish");
-} else if (other === "Rust" || other === "Ruby" || other === "Redwood") {
-  console.log("This is red-ish");
-} else {
-  console.log("Other color than red and blue: ", other);
-}
-```
-
-</CodeTab>
-
-This is a shorter version of:
-
-```res
-switch myColor {
-| #Sapphire | #Neon | #Navy => Js.log("This is blue-ish")
-| #Ruby | #Redwood | #Rust => Js.log("This is red-ish")
-| other => Js.log2("Other color than red and blue: ", other)
-}
-```
-
-## Structural Sharing
-
-Since poly variants value don't have a source of truth for their type, you can write such code:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type preferredColors = [#white | #blue]
-
-let myColor: preferredColors = #blue
-
-let displayColor = v => {
-  switch v {
-  | #red => "Hello red"
-  | #green => "Hello green"
-  | #white => "Hey white!"
-  | #blue => "Hey blue!"
-  }
-}
-
-Js.log(displayColor(myColor))
-```
-
-```js
-var myColor = "blue";
-
-function displayColor(v) {
-  if (v === "white") {
-    return "Hey white!";
-  } else if (v === "red") {
-    return "Hello red";
-  } else if (v === "green") {
-    return "Hello green";
-  } else {
-    return "Hey blue!";
-  }
-}
-
-console.log(displayColor("blue"));
-```
-
-</CodeTab>
-
-With a regular variant, the line `displayColor(myColor)` would fail, since it'd complain that the type of `myColor` doesn't match the type of `v`. No problem with poly variant.
-
-## JavaScript Output
-
-Poly variants are great for JavaScript interop! You can share their values to JS code, or model incoming JS values as poly variants.
-
-- `#red` and `#"I am red 😃"` compile to JavaScipt `"red"` and `"I am red 😃"`.
-- `#1` compiles to JavaScript `1`.
-- Poly variant constructor with 1 argument, like `Instagram("Jenny")` compile to a straightforward `{NAME: "Instagram", VAL: "Jenny"}`. 2 or more arguments like `#Facebook("Josh", 26)` compile to a similar object, but with `VAL` being an array of the arguments.
-
-### Bind to Functions
-
-For example, let's assume we want to bind to `Intl.NumberFormat` and want to make sure that our users only pass valid locales, we could define an external binding like this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type t
-
-@scope("Intl") @val
-external makeNumberFormat: ([#"de-DE" | #"en-GB" | #"en-US"]) => t = "NumberFormat"
-
-let intl = makeNumberFormat(#"de-DE")
-```
-
-```js
-var intl = Intl.NumberFormat("de-DE");
-```
-
-</CodeTab>
-
-The JS output is identical to handwritten JS, but we also get to enjoy type errors if we accidentally write `makeNumberFormat(#"de-DR")`.
-
-More advanced usage examples for poly variant interop can be found in [Bind to JS Function](bind-to-js-function#constrain-arguments-better).
-
-### Bind to String Enums
-
-Let's assume we have a TypeScript module that expresses following enum export:
-
-```js
-// direction.js
-enum Direction {
-  Up = "UP",
-  Down = "DOWN",
-  Left = "LEFT",
-  Right = "RIGHT",
-}
-
-export const myDirection = Direction.Up
-```
-
-For this particular example, we can also inline poly variant type definitions to design the type for the imported `myDirection` value:
-
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type direction = [ #UP | #DOWN | #LEFT | #RIGHT ]
-@module("./direction.js") external myDirection: direction = "myDirection"
-```
-
-```js
-var DirectionJs = require("./direction.js");
-
-var myDirection = DirectionJs.myDirection;
-```
-
-</CodeTab>
-
-Again: since we were using poly variants, the JS Output is practically zero-cost and doesn't add any extra code!
-
-## Extra Constraints on Types
-
-The previous poly variant type annotations we've looked at are the regular "closed" kind. However, there's a way to express "I want at least these constructors" (lower bound) and "I want at most these constructors" (upper bound):
-
-```res
-// Only #Red allowed. Closed.
-let basic: [#Red] = #Red
-
-// May contain #Red, or any other value. Open
-// here, foreground will actually be inferred as [> #Red | #Green]
-let foreground: [> #Red] = #Green
-
-// The value must be, at most, one of #Red or #Blue
-// Only #Red and #Blue are valid values
-let background: [< #Red | #Blue] = #Red
-```
-
-**Note:** We added this info for educational purposes. In most cases you will not want to use any of this stuff, since it makes your APIs pretty unreadable / hard to use.
-
-### Closed `[`
-
-This is the simplest poly variant definition, and also the most practical one. Like a common variant type, this one defines an exact set of constructors.
-
-```res
-type rgb = [ #Red | #Green | #Blue ]
-
-let color: rgb = #Green
-```
-
-In the example above, `color` will only allow one of the three constructors that are defined in the `rgb` type. This is usually the way how poly variants should be defined.
-
-In case you want to define a type that is extensible, you'll need to use the lower / upper bound syntax.
-
-### Lower Bound `[>`
-
-A lower bound defines the minimum set of constructors a poly variant type is aware of. It is also considered an "open poly variant type", because it doesn't restrict any additional values.
-
-Here is an example on how to make a minimum set of `basicBlueTones` extensible for a new `color` type:
-
-```res
-type basicBlueTone<'a> = [> #Blue | #DeepBlue | #LightBlue ] as 'a
-type color = basicBlueTone<[#Blue | #DeepBlue | #LightBlue | #Purple]>
-
-let color: color = #Purple
-
-// This will fail due to missing minimum constructors:
-type notWorking = basicBlueTone<[#Purple]>
-```
-
-Here, the compiler will enforce the user to define `#Blue | #DeepBlue | #LightBlue` as the minimum set of constructors when trying to extend `basicBlueTone<'a>`.
-
-**Note:** Since we want to define an extensible poly variant, we need to provide a type placeholder `<'a>`, and also add `as 'a` after the poly variant declaration, which essentially means: "Given type `'a` is constraint to the minimum set of constructors (`#Blue | #DeepBlue | #LightBlue`) defined in `basicBlueTone`".
-
-### Upper Bound `[<`
-
-The upper bound works in the opposite way than a lower bound: the extending type may only use constructors that are stated in the upper bound constraint.
-
-Here another example, but with red colors:
-
-```res
-type validRed<'a> = [< #Fire | #Crimson | #Ash] as 'a
-type myReds = validRed<[#Ash]>
-
-// This will fail due to unlisted constructor not defined by the lower bound
-type notWorking = validRed<[#Purple]>
-```
-
-## Coercion
-
-You can convert a poly variant to a `string` or `int` at no cost:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type company = [#Apple | #Facebook]
-let theCompany: company = #Apple
-
-let message = "Hello " ++ (theCompany :> string)
-```
-
-```js
-var theCompany = "Apple";
-var message = "Hello " + theCompany;
-```
-
-</CodeTab>
-
-**Note**: for the coercion to work, the poly variant type needs to be closed; you'd need to annotate it, since otherwise, `theCompany` would be inferred as `[> #Apple]`.
-
-## Tips & Tricks
-
-### Variant vs Polymorphic Variant
-
-One might think that polymorphic variants are superior to regular [variants](./variant). As always, there are trade-offs:
-
-- Due to their "structural" nature, poly variant's type errors might be more confusing. If you accidentally write `#blur` instead of `#blue`, ReScript will still error but can't indicate the correct source as easily. Regular variants' source of truth is the type definition, so the error can't go wrong.
-- It's also harder to refactor poly variants. Consider this:
-  ```res
-  let myFruit = #Apple
-  let mySecondFruit = #Apple
-  let myCompany = #Apple
-  ```
-  Refactoring the first one to `#Orange` doesn't mean we should refactor the third one. Therefore, the editor plugin can't touch the second one either. Regular variant doesn't have such problem, as these 2 values presumably come from different variant type definitions.
-
-- You might lose some nice pattern match checks from the compiler:
-  ```res
-  let myColor = #red
-
-  switch myColor {
-  | #red => Js.log("Hello red!")
-  | #blue => Js.log("Hello blue!")
-  }
-  ```
-  Because there's no poly variant definition, it's hard to know whether the `#blue` case can be safely removed.
-
-In most scenarios, we'd recommend to use regular variants over polymorphic variants, especially when you are writing plain ReScript code. In case you want to write zero-cost interop bindings or generate clean JS output, poly variants are oftentimes a better option.
diff --git a/pages/docs/manual/v10.0.0/primitive-types.mdx b/pages/docs/manual/v10.0.0/primitive-types.mdx
deleted file mode 100644
index 74949b4f4..000000000
--- a/pages/docs/manual/v10.0.0/primitive-types.mdx
+++ /dev/null
@@ -1,187 +0,0 @@
----
-title: "Primitive Types"
-description: "Primitive Data Types in ReScript"
-canonical: "/docs/manual/latest/primitive-types"
----
-
-# Primitive Types
-
-ReScript comes with the familiar primitive types like `string`, `int`, `float`, etc.
-
-<!-- TODO: doc unit -->
-
-## String
-
-ReScript `string`s are delimited using **double** quotes (single quotes are reserved for the character type below).
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let greeting = "Hello world!"
-let multilineGreeting = "Hello
- world!"
-```
-```js
-var greeting = "Hello world!";
-var multilineGreeting = "Hello\n world!";
-```
-
-</CodeTab>
-
-To concatenate strings, use `++`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let greetings = "Hello " ++ "world!"
-```
-```js
-var greetings = "Hello world!";
-```
-
-</CodeTab>
-
-### String Interpolation
-
-There's a special syntax for string that allows
-
-- multiline string just like before
-- no special character escaping
-- Interpolation
-- Proper unicode handling
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let name = "Joe"
-
-let greeting = `Hello
-World
-👋
-${name}
-`
-```
-```js
-var name = "Joe";
-
-var greeting = "Hello\nWorld\n👋\n" + name + "\n";
-```
-
-</CodeTab>
-
-This is just like JavaScript's backtick string interpolation, except without needing to escape special characters.
-
-### Unsafe String Interpolation (Deprecated)
-
-> ReScript v10.1.4 deprecated unsafe string interpolation and will be removed in v11.
-
-For interpolation, you'll have to convert the binding (`name` in the example) into a string if it isn't one. If you want the interpolation to implicitly convert a binding into a string, prepend a `j`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let age = 10
-let message = j`Today I am $age years old.`
-```
-```js
-var message = "Today I am " + 10 + " years old.";
-```
-
-</CodeTab>
-
-### Usage
-
-See the familiar `Js.String` API in the [API docs](api/js/string). Since a ReScript string maps to a JavaScript string, you can mix & match the string operations in both standard libraries.
-
-### Tips & Tricks
-
-**You have a good type system now!** In an untyped language, you'd often overload the meaning of string by using it as:
-
-- a unique id: `var BLUE_COLOR = "blue"`
-- an identifier into a data structure: `var BLUE = "blue" var RED = "red" var colors = [BLUE, RED]`
-- the name of an object field: `person["age"] = 24`
-- an enum: `if (audio.canPlayType() === 'probably') {...}` [(ಠ_ಠ)](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/canPlayType#Return_value)
-- other crazy patterns you'll soon find horrible, after getting used to ReScript's alternatives.
-
-The more you overload the poor string type, the less the type system (or a teammate) can help you! ReScript provides concise, fast and maintainable types & data structures alternatives to the use-cases above (e.g. variants, in a later section).
-
-## Char
-
-ReScript has a type for a string with a single letter:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let firstLetterOfAlphabet = 'a'
-```
-```js
-var firstLetterOfAlphabet = /* "a" */97;
-```
-
-</CodeTab>
-
-**Note**: Char doesn't support Unicode or UTF-8 and is therefore not recommended.
-
-To convert a String to a Char, use `String.get("a", 0)`. To convert a Char to a String, use `String.make(1, 'a')`.
-
-## Regular Expression
-
-ReScript regular expressions compile cleanly to their JavaScript counterpart:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let r = %re("/b/g")
-```
-```js
-var r = /b/g;
-```
-
-</CodeTab>
-
-A regular expression like the above has the type `Js.Re.t`. The [Js.Re](api/js/re) module contains the regular expression helpers you have seen in JS.
-
-## Boolean
-
-A ReScript boolean has the type `bool` and can be either `true` or `false`. Common operations:
-
-- `&&`: logical and.
-- `||`: logical or.
-- `!`: logical not.
-- `<=`, `>=`, `<`, `>`
-- `==`: structural equal, compares data structures deeply. `(1, 2) == (1, 2)` is `true`. Convenient, but use with caution.
-- `===`: referential equal, compares shallowly. `(1, 2) === (1, 2)` is `false`. `let myTuple = (1, 2); myTuple === myTuple` is `true`.
-- `!=`: structural unequal.
-- `!==`: referential unequal.
-
-ReScript's `true/false` compiles into a JavaScript `true/false`.
-
-## Integers
-
-32-bits, truncated when necessary. We provide the usual operations on them: `+`, `-`, `*`, `/`, etc. See [Js.Int](api/js/int) for helper functions.
-
-**Be careful when you bind to JavaScript numbers!** Since ReScript integers have a much smaller range than JavaScript numbers, data might get lost when dealing with large numbers. In those cases, it’s much safer to bind the numbers as **floats**. Be extra mindful of this when binding to JavaScript Dates and their epoch time.
-
-To improve readability, you may place underscores in the middle of numeric literals such as `1_000_000`. Note that underscores can be placed anywhere within a number, not just every three digits.
-
-## Floats
-
-Float requires other operators: `+.`, `-.`, `*.`, `/.`, etc. Like `0.5 +. 0.6`. See [Js.Float](api/js/float) for helper functions.
-
-As with integers, you may use underscores within literals to improve readability.
-
-## Unit
-
-The `unit` type indicates the absence of a specific value. It has only a single value, `()`, which acts as a placeholder when no other value exists or is needed. It compiles to JavaScript's `undefined` and resembles the `void` type in languages such as C++. What's the point of such a type?
-
-Consider the `Math.random` function. Its type signature is `unit => float`, which means it receives a `unit` as input and calculates a random `float` as output. You use the function like this - `let x = Math.random()`. Notice `()` as the first and only function argument.
-
-Imagine a simplified `Console.log` function that prints a message. Its type signature is `string => unit` and you'd use it like this `Console.log("Hello!")`. It takes a string as input, prints it, and then returns nothing useful. When `unit` is the output of a function it means the function performs some kind of side-effect. 
-
-## Unknown
-
-The `unknown` type represents values with contents that are a mystery or are not 100% guaranteed to be what you think they are. It provides type-safety when interacting with data received from an untrusted source. For example, suppose an external function is supposed to return a `string`. It might. But if the documentation is not accurate or the code has bugs, the function could return `null`, an `array`, or something else you weren't expecting.
-
-The ReScript type system helps you avoid run-time crashes and unpredicatable behavior by preventing you from using `unknown` in places that expect a `string` or `int` or some other type. The ReScript core libraries also provide utility functions to help you inspect `unknown` values and access their contents. In some cases you may need a JSON parsing library to convert `unknown` values to types you can safely use.   
-
-Consider using `unknown` when receiving data from [external JavaScript functions](/docs/manual/latest/bind-to-js-function)
diff --git a/pages/docs/manual/v10.0.0/project-structure.mdx b/pages/docs/manual/v10.0.0/project-structure.mdx
deleted file mode 100644
index 93e77f0f0..000000000
--- a/pages/docs/manual/v10.0.0/project-structure.mdx
+++ /dev/null
@@ -1,57 +0,0 @@
----
-title: "Project Structure"
-description: "Notes on project structure and other rough ReScript guidelines"
-canonical: "/docs/manual/latest/project-structure"
----
-
-# Project Structure
-
-These are the existing, non-codified community practices that are currently propagated through informal agreement. We might remove some of them at one point, and enforce some others. Right now, they're just recommendations for ease of newcomers.
-
-## File Casing
-
-Capitalized file names (aka first letter upper-cased).
-
-**Justification**: Module names can only be capitalized. Newcomers often ask how a file maps to a module, and why `draw.res` maps to the module `Draw`, and sometimes try to refer to a module through uncapitalized identifiers. Using `Draw.res` makes this mapping more straightforward. It also helps certain file names that'd be awkward in uncapitalized form: `uRI.res`.
-
-## Ignore `.merlin` File
-
-This is generated by the build system and you should not have to manually edit it. Don't check it into the repo.
-
-**Justification**: `.merlin` is for editor tooling. The file contains absolute paths, which are also not cross-platform (e.g. Windows paths are different).
-
-## Folders
-
-Try not to have too many nested folders. Keep your project flat, and have fewer files (reminder: you can use nested modules).
-
-**Justification**: The file system is a _tree_, but your code's dependencies are a _graph_. Because of that, any file & folder organization is usually imperfect. While it's still valuable to group related files together in a folder, the time wasted debating & getting decision paralysis over these far outweight their benefits. We'll always recommend you to Get Work Done instead of debating about these issues.
-
-## Third-party Dependencies
-
-Keep them to a minimum.
-
-**Justification**: A compiled, statically typed language cannot model its dependencies easily by muddling along like in a dynamic language, especially when we're still piggy-backing on NPM/Yarn (to reduce learning overhead in the medium-term). Keeping dependencies simple & lean helps reduce possibility of conflicts (e.g. two diamond dependencies, or clashing interfaces).
-
-## Documentation
-
-Have them. Spend more effort making them great (examples, pitfalls) and professional rather than _just_ fancy-looking. Do use examples, and avoid using names such as `foo` and `bar`. There's always more concrete names (it's an example, no need to be abstract/generalized just yet. The API docs will do this plentily). For blog posts, don't repeat the docs themselves, describe the _transition_ from old to new, and why (e.g. "it was a component, now it's a function, because ...").
-
-**Justification**: It's hard for newcomers to distinguish between a simple/decent library and one that's fancy-looking. For the sake of the community, don't try too hard to one-up each other's libraries. Do spread the words, but use your judgement too.
-
-## PPX & Other Meta-tools
-
-Keep them to a minimum. PPX, unless used in renown cases (printer, accessors and serializer/deserializer generation), can cause big learning churn for newcomers; on top of the syntax, semantics, types, build tool & FFI that they already have to learn, learning per-library custom transformations of the code is an extra step. More invasive macros makes the code itself less semantically meaningful too, since the essence would be hiding somewhere else.
-
-## Paradigm
-
-Don't abuse overly fancy features. Do leave some breathing room for future APIs but don't over-architect things.
-
-**Justification**: Simple code helps newcomers understand and potentially contribute to your code. Contributing is the best way for them to learn. The extra help you receive might also surpass the gain of using a slightly more clever language trick. But do try new language tricks in some of more casual projects! You might discover new ways of architecting code.
-
-## Publishing
-
-If it's a wrapper for a JS library, don't publish the JS artifacts. If it's a legit library, publish the artifacts in lib/js if you think JS consumers might use it. This is especially the case when you gradually convert a JS lib to ReScript while not breaking existing JS consumers.
-
-Do put the keywords `"rescript"` in your package.json `keywords` field. This allows us to find the library much more easily for future purposes.
-
-**Justification**: Be nice to JS consumers of your library. They're your future ReScripters.
diff --git a/pages/docs/manual/v10.0.0/promise.mdx b/pages/docs/manual/v10.0.0/promise.mdx
deleted file mode 100644
index b73e249f2..000000000
--- a/pages/docs/manual/v10.0.0/promise.mdx
+++ /dev/null
@@ -1,180 +0,0 @@
----
-title: "Promises"
-description: "JS Promise handling in ReScript"
-canonical: "/docs/manual/latest/promise"
----
-
-# Promise
-
-> **Note:** Starting from ReScript 10.1 and above, we recommend using [async / await](./async-await) when interacting with Promises.
-
-## `promise` type
-
-**Since 10.1**
-
-In ReScript, every JS promise is represented with the globally available `promise<'a>` type. For ReScript versions < 10.1, use its original alias `Js.Promise.t<'a>` instead.
-
-Here's a usage example in a function signature:
-
-```resi
-// User.resi file
-
-type user = {name: string}
-
-let fetchUser: string => promise<user>
-```
-
-To work with promise values (instead of using `async` / `await`) you may want to use the built-in `Js.Promise2` module. 
-
-## Js.Promise2
-
-A builtin module to create, chain and manipulate promises.
-
-> **Note:** This is an intermediate replacement for the `Js.Promise` module. It is designed to work with the `->` operator and should be used in favour of it's legacy counterpart. We are aware that the `Belt`, `Js` and `Js.xxx2` situation is confusing; a proper solution will hopefully be part of our upcoming `v11` release.
-
-### Creating a promise
-
-```res
-let p1 = Js.Promise2.make((~resolve, ~reject) => {
-  // We use uncurried functions for resolve / reject
-  // for cleaner JS output without unintended curry calls
-  resolve(. "hello world")
-})
-
-let p2 = Js.Promise2.resolve("some value")
-
-// You can only reject `exn` values for streamlined catch handling
-exception MyOwnError(string)
-let p3 = Js.Promise2.reject(MyOwnError("some rejection"))
-```
-
-### Access the contents and transform a promise
-
-```res
-let logAsyncMessage = () => {
-  open Js.Promise2
-  Js.Promise2.resolve("hello world")
-  ->then(msg => {
-    // then callbacks require the result to be resolved explicitly
-    resolve("Message: " ++ msg)
-  })
-  ->then(msg => {
-    Js.log(msg)
-
-    // Even if there is no result, we need to use resolve() to return a promise
-    resolve()
-  })
-  ->ignore // Requires ignoring due to unhandled return value
-}
-```
-
-For comparison, the `async` / `await` version of the same code would look like this:
-
-```res
-let logAsyncMessage = async () => {
-  let msg = await Js.Promise2.resolve("hello world")
-  Js.log(`Message: ${msg}`)
-}
-```
-
-Needless to say, the async / await version offers better ergonomics and less opportunities to run into type issues.
-
-### Run multiple promises in parallel
-
-In case you want to launch multiple promises in parallel, use `Js.Promise2.all`:
-
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@val
-external fetchMessage: string => promise<string> = "global.fetchMessage"
-
-let logAsyncMessage = async () => {
-  let messages = await Js.Promise2.all([fetchMessage("message1"), fetchMessage("message2")])
-
-  Js.log(Js.Array2.joinWith(messages, ", "))
-}
-```
-
-```js
-async function logAsyncMessage(param) {
-  var messages = await Promise.all([
-        global.fetchMessage("message1"),
-        global.fetchMessage("message2")
-      ]);
-  console.log(messages.join(", "));
-}
-
-export {
-  logAsyncMessage ,
-}
-```
-
-</CodeTab>
-
-## Js.Promise module (legacy - do not use)
-
-> **Note:** The `Js.Promise` bindings are following the outdated data-last convention from a few years ago. We kept those APIs for backwards compatibility. Either use `Js.Promise2` or a third-party promise binding instead.
-
-ReScript has built-in support for [JavaScript promises](api/js/promise). The 3 functions you generally need are:
-
-- `Js.Promise.resolve: 'a => Js.Promise.t<'a>`
-- `Js.Promise.then_: ('a => Js.Promise.t<'b>, Js.Promise.t<'a>) => Js.Promise.t<'b>`
-- `Js.Promise.catch: (Js.Promise.error => Js.Promise.t<'a>, Js.Promise.t<'a>) => Js.Promise.t<'a>`
-
-Additionally, here's the type signature for creating a promise on the ReScript side:
-
-```res
-Js.Promise.make: (
-  (
-    ~resolve: (. 'a) => unit,
-    ~reject: (. exn) => unit
-  ) => unit
-) => Js.Promise.t<'a>
-```
-
-This type signature means that `make` takes a callback that takes 2 named arguments, `resolve` and `reject`. Both arguments are themselves [uncurried callbacks](
-function.md#uncurried-function) (with a dot). `make` returns the created promise.
-
-### Usage
-
-Using the [pipe operator](pipe.md):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myPromise = Js.Promise.make((~resolve, ~reject) => resolve(. 2))
-
-myPromise->Js.Promise.then_(value => {
-  Js.log(value)
-  Js.Promise.resolve(value + 2)
-}, _)->Js.Promise.then_(value => {
-  Js.log(value)
-  Js.Promise.resolve(value + 3)
-}, _)->Js.Promise.catch(err => {
-  Js.log2("Failure!!", err)
-  Js.Promise.resolve(-2)
-}, _)
-```
-```js
-var myPromise = new Promise(function (resolve, reject) {
-  return resolve(2);
-});
-
-myPromise
-  .then(function (value) {
-    console.log(value);
-    return Promise.resolve((value + 2) | 0);
-  })
-  .then(function (value) {
-    console.log(value);
-    return Promise.resolve((value + 3) | 0);
-  })
-  .catch(function (err) {
-    console.log("Failure!!", err);
-    return Promise.resolve(-2);
-  });
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v10.0.0/record.mdx b/pages/docs/manual/v10.0.0/record.mdx
deleted file mode 100644
index d6f859787..000000000
--- a/pages/docs/manual/v10.0.0/record.mdx
+++ /dev/null
@@ -1,440 +0,0 @@
----
-title: "Record"
-description: "Record types in ReScript"
-canonical: "/docs/manual/latest/record"
----
-
-# Record
-
-Records are like JavaScript objects but:
-
-- are immutable by default
-- have fixed fields (not extensible)
-
-## Type Declaration
-
-A record needs a mandatory type declaration:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type person = {
-  age: int,
-  name: string,
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Creation
-
-To create a `person` record (declared above):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let me = {
-  age: 5,
-  name: "Big ReScript"
-}
-```
-```js
-var me = {
-  age: 5,
-  name: "Big ReScript"
-};
-```
-
-</CodeTab>
-
-When you create a new record value, ReScript tries to find a record type declaration that conforms to the shape of the value. So the `me` value here is inferred as of type `person`.
-
-The type is found by looking above the `me` value. **Note**: if the type instead resides in another file or module, you need to explicitly indicate which file or module it is:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// School.res
-type person = {age: int, name: string}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Example.res
-
-let me: School.person = {age: 20, name: "Big ReScript"}
-/* or */
-let me2 = {School.age: 20, name: "Big ReScript"}
-```
-```js
-var me = {
-  age: 20,
-  name: "Big ReScript"
-};
-var me2 = {
-  age: 20,
-  name: "Big ReScript"
-};
-```
-
-</CodeTab>
-
-In both `me` and `me2` the record definition from `School` is found. The first one, `me` with the regular type annotation, is preferred.
-
-## Access
-
-Use the familiar dot notation:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let name = me.name
-```
-```js
-var name = "Big ReScript";
-```
-
-</CodeTab>
-
-## Immutable Update
-
-New records can be created from old records with the `...` spread operator. The original record isn't mutated.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let meNextYear = {...me, age: me.age + 1}
-```
-```js
-var meNextYear = {
-  age: 21,
-  name: "Big ReScript"
-};
-```
-
-</CodeTab>
-
-**Note**: spread cannot add new fields to the record value, as a record's shape is fixed by its type.
-
-## Mutable Update
-
-Record fields can optionally be mutable. This allows you to efficiently update those fields in-place with the `=` operator.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type person = {
-  name: string,
-  mutable age: int
-}
-
-let baby = {name: "Baby ReScript", age: 5}
-baby.age = baby.age + 1 // `baby.age` is now 6. Happy birthday!
-```
-```js
-var baby = {
-  name: "Baby ReScript",
-  age: 5
-};
-
-baby.age = baby.age + 1 | 0;
-```
-
-</CodeTab>
-
-Fields not marked with `mutable` in the type declaration cannot be mutated.
-
-## JavaScript Output
-
-ReScript records compile to straightforward JavaScript objects; see the various JS output tabs above.
-
-## Optional Record Fields
-ReScript [`v10`](/blog/release-10-0-0#experimental-optional-record-fields) introduced optional record fields. This means that you can define fields that can be omitted when creating the record. It looks like this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type person = {
-  age: int,
-  name?: string
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Notice how `name` has a suffixed `?`. That means that the field itself is _optional_.
-
-### Creation
-You can omit any optional fields when creating a record. Not setting an optional field will default the field's value to `None`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type person = {
-  age: int,
-  name?: string
-}
-
-let me = {
-  age: 5,
-  name: "Big ReScript"
-}
-
-let friend = {
-  age: 7
-}
-```
-```js
-var me = {
-  age: 5,
-  name: "Big ReScript"
-};
-
-var friend = {
-  age: 7
-};
-```
-
-</CodeTab>
-
-This has consequences for pattern matching, which we'll expand a bit on soon.
-
-## Immutable Update
-Updating an optional field via an immutable update above lets you set that field value without needing to care whether it's optional or not.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type person = {
-  age: int,
-  name?: string
-}
-
-let me = {
-  age: 123,
-  name: "Hello"
-}
-
-let withoutName = {
-  ...me,
-  name: "New Name"
-}
-```
-```js
-import * as Caml_obj from "./stdlib/caml_obj.js";
-
-var me = {
-  age: 123,
-  name: "Hello"
-};
-
-var newrecord = Caml_obj.obj_dup(me);
-
-newrecord.name = "New Name";
-
-var withoutName = newrecord;
-```
-
-</CodeTab>
-
-
-However, if you want to set the field to an optional value, you prefix that value with `?`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type person = {
-  age: int,
-  name?: string
-}
-
-let me = {
-  age: 123,
-  name: "Hello"
-}
-
-let maybeName = Some("My Name")
-
-let withoutName = {
-  ...me,
-  name: ?maybeName
-}
-```
-```js
-import * as Caml_obj from "./stdlib/caml_obj.js";
-
-var me = {
-  age: 123,
-  name: "Hello"
-};
-
-var maybeName = "My Name";
-
-var newrecord = Caml_obj.obj_dup(me);
-
-newrecord.name = maybeName;
-
-var withoutName = newrecord;
-```
-
-</CodeTab>
-
-You can unset an optional field's value via that same mechanism by setting it to `?None`.
-
-### Pattern Matching on Optional Fields
-[Pattern matching](pattern-matching-destructuring), one of ReScript's most important features, has two caveats when you deal with optional fields.
-
-When matching on the value directly, it's an `option`. Example:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type person = {
-  age: int,
-  name?: string,
-}
-
-let me = {
-  age: 123,
-  name: "Hello",
-}
-
-let isRescript = switch me.name {
-| Some("ReScript") => true
-| Some(_) | None => false
-}
-```
-```js
-var isRescript;
-
-isRescript = "Hello" === "ReScript" ? true : false;
-
-var me = {
-  age: 123,
-  name: "Hello"
-};
-```
-
-</CodeTab>
-
-But, when matching on the field as part of the general record structure, it's treated as the underlying, non-optional value:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type person = {
-  age: int,
-  name?: string,
-}
-
-let me = {
-  age: 123,
-  name: "Hello",
-}
-
-let isRescript = switch me {
-| {name: "ReScript"} => true
-| _ => false
-}
-
-```
-```js
-var isRescript;
-
-isRescript = "Hello" === "ReScript" ? true : false;
-
-var me = {
-  age: 123,
-  name: "Hello"
-};
-```
-
-</CodeTab>
-
-Sometimes you _do_ want to know whether the field was set or not. You can tell the pattern matching engine about that by prefixing your option match with `?`, like this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type person = {
-  age: int,
-  name?: string,
-}
-
-let me = {
-  age: 123,
-  name: "Hello",
-}
-
-let nameWasSet = switch me {
-| {name: ?None} => false
-| {name: ?Some(_)} => true
-}
-```
-```js
-var nameWasSet = true;
-
-var me = {
-  age: 123,
-  name: "Hello"
-};
-```
-
-</CodeTab>
-
-## Tips & Tricks
-
-### Record Types Are Found By Field Name
-With records, you **cannot** say "I'd like this function to take any record type, as long as they have the field `age`". The following **won't work as intended**:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type person = {age: int, name: string}
-type monster = {age: int, hasTentacles: bool}
-
-let getAge = (entity) => entity.age
-```
-```js
-function getAge(entity) {
-  return entity.age;
-}
-```
-
-</CodeTab>
-
-Instead, `getAge` will infer that the parameter `entity` must be of type `monster`, the closest record type with the field `age`. The following code's last line fails:
-
-```res
-let kraken = {age: 9999, hasTentacles: true}
-let me = {age: 5, name: "Baby ReScript"}
-
-getAge(kraken)
-getAge(me) // type error!
-```
-
-The type system will complain that `me` is a `person`, and that `getAge` only works on `monster`. If you need such capability, use ReScript objects, described [here](object.md).
-
-### Optional Fields in Records Can Be Useful for Bindings
-Many JavaScript APIs tend to have large configuration objects that can be a bit annoying to model as records, since you previously always needed to specify all record fields when creating a record. 
-
-Optional record fields, introduced in [`v10`](/blog/release-10-0-0#experimental-optional-record-fields), is intended to help with this. Optional fields will let you avoid having to specify all fields, and let you just specify the one's you care about. A significant improvement in ergonomics for bindings and other APIs with for example large configuration objects.
-
-## Design Decisions
-
-After reading the constraints in the previous sections, and if you're coming from a dynamic language background, you might be wondering why one would bother with record in the first place instead of straight using object, since the former needs explicit typing and doesn't allow different records with the same field name to be passed to the same function, etc.
-
-1. The truth is that most of the times in your app, your data's shape is actually fixed, and if it's not, it can potentially be better represented as a combination of variant (introduced next) + record instead.
-2. Since a record type is resolved through finding that single explicit type declaration (we call this "nominal typing"), the type error messages end up better than the counterpart ("structural typing", like for tuples). This makes refactoring easier; changing a record type's fields naturally allows the compiler to know that it's still the same record, just misused in some places. Otherwise, under structural typing, it might get hard to tell whether the definition site or the usage site is wrong.
diff --git a/pages/docs/manual/v10.0.0/reserved-keywords.mdx b/pages/docs/manual/v10.0.0/reserved-keywords.mdx
deleted file mode 100644
index e087f21b5..000000000
--- a/pages/docs/manual/v10.0.0/reserved-keywords.mdx
+++ /dev/null
@@ -1,92 +0,0 @@
----
-title: "Reserved Keyword"
-description: "All reserved keywords in ReScript"
-canonical: "/docs/manual/latest/reserved-keywords"
----
-
-# Reserved Keywords
-
-> **Note**: Some of these words are reserved purely for backward compatibility.
->
-> If you _need_ to use one of these names as binding and/or field name, see [Use Illegal Identifier Names](use-illegal-identifier-names.md).
-
-- `and`
-- `as`
-- `assert`
-
-
-<!-- - `begin` -->
-
-
-<!-- - `class` -->
-- `constraint`
-
-
-<!-- - `do` -->
-<!-- - `done` -->
-
-
-- `else`
-<!-- - `end` -->
-<!-- - `esfun` -->
-- `exception`
-- `external`
-
-
-- `false`
-- `for`
-<!-- - `fun` -->
-<!-- - `function` -->
-<!-- - `functor` -->
-
-
-- `if`
-- `in`
-- `include`
-<!-- - `inherit` -->
-<!-- - `initializer` -->
-
-
-- `lazy`
-- `let`
-
-
-- `module`
-- `mutable`
-
-
-<!-- - `new` -->
-<!-- - `nonrec` -->
-
-
-<!-- - `object` -->
-- `of`
-- `open`
-<!-- - `or` -->
-
-
-<!-- - `pri` -->
-<!-- - `pub` -->
-
-
-- `rec`
-
-
-<!-- - `sig` -->
-<!-- - `struct` -->
-- `switch`
-
-
-<!-- - `then` -->
-- `true`
-- `try`
-- `type`
-
-
-<!-- - `val` -->
-<!-- - `virtual` -->
-
-
-- `when`
-- `while`
-- `with`
diff --git a/pages/docs/manual/v10.0.0/scoped-polymorphic-types.mdx b/pages/docs/manual/v10.0.0/scoped-polymorphic-types.mdx
deleted file mode 100644
index a693fff74..000000000
--- a/pages/docs/manual/v10.0.0/scoped-polymorphic-types.mdx
+++ /dev/null
@@ -1,100 +0,0 @@
----
-title: "Scoped Polymorphic Types"
-description: "Scoped Polymorphic Types in ReScript"
-canonical: "/docs/manual/latest/scoped-polymorphic-types"
----
-
-# Scoped Polymorphic Types
-
-Scoped Polymorphic Types in ReScript are functions with the capability to handle arguments of any type within a specific scope. This feature is particularly valuable when working with JavaScript APIs, as it allows your functions to accommodate diverse data types while preserving ReScript's strong type checking.
-
-## Definition and Usage
-
-Scoped polymorphic types in ReScript offer a flexible and type-safe way to handle diverse data types within specific scopes. This documentation provides an example to illustrate their usage in a JavaScript context.
-
-### Example: Logging API
-
-Consider a logging example within a JavaScript context that processes various data types:
-
-```js
-const logger = {
-  log: (data) => {
-    if (typeof data === "string") {
-      /* handle string */
-    } else if (typeof data === "number") {
-      /* handle number */
-    } else {
-      /* handle other types */
-    }
-  },
-};
-```
-
-In ReScript, we can bind to this function as a record with a scoped polymorphic function type:
-
-```res prelude
-type logger = { log: 'a. 'a => unit }
-
-@module("jsAPI") external getLogger: unit => logger = "getLogger"
-```
-
-The `logger` type represents a record with a single field `log`, which is a scoped polymorphic function type `'a. 'a => unit`. The `'a` indicates a type variable that can be any type within the scope of the `log` function.
-
-Now, we can utilize the function obtained from `getLogger`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myLogger = getLogger()
-
-myLogger.log("Hello, ReScript!")
-myLogger.log(42)
-```
-
-```js
-var myLogger = JsAPI.getLogger();
-
-myLogger.log("Hello, ReScript!");
-myLogger.log(42);
-```
-
-</CodeTab>
-
-In this example, we create an instance of the logger by calling `getLogger()`, and then we can use the `log` function on the `myLogger` object to handle different data types.
-
-## Limitations of Normal Polymorphic Types
-
-Let's consider the same logging example in ReScript, but this time using normal polymorphic types:
-
-```res
-type logger<'a> = { log: 'a => unit}
-
-@module("jsAPI") external getLogger: unit => logger<'a> = "getLogger"
-```
-
-In this case, the `logger` type is a simple polymorphic function type `'a => unit`. However, when we attempt to use this type in the same way as before, we encounter an issue:
-
-```res
-let myLogger = getLogger()
-
-myLogger.log("Hello, ReScript!")
-myLogger.log(42) // Type error!
-```
-
-The problem arises because the type inference in ReScript assigns a concrete type to the `logger` function based on the first usage. In this example, after the first call to `myLogger`, the compiler infers the type `logger<string>` for `myLogger`. Consequently, when we attempt to pass an argument of type `number` in the next line, a type error occurs because it conflicts with the inferred type `logger<string>`.
-
-In contrast, scoped polymorphic types, such as `'a. 'a => unit`, overcome this limitation by allowing type variables within the scope of the function. They ensure that the type of the argument is preserved consistently within that scope, regardless of the specific value used in the first invocation.
-
-## Limitations of Scoped Polymorphic Types
-
-Scoped polymorphic types work only when they are directly applied to let-bindings or record fields (as demonstrated in the logger example above). They can neither be applied to function bodies, nor to separate type definitions:
-
-```res
-exception Abort
-
-let testExn: 'a. unit => 'a = () => raise(Abort) // Works!
-
-let testExn2 = (): 'a. 'a = raise(Abort) // Syntax error!
-type fn = 'a. 'a => unit // Syntax error!
-```
-
diff --git a/pages/docs/manual/v10.0.0/shared-data-types.mdx b/pages/docs/manual/v10.0.0/shared-data-types.mdx
deleted file mode 100644
index 57f4cb687..000000000
--- a/pages/docs/manual/v10.0.0/shared-data-types.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
----
-title: "Shared Data Types"
-description: "Data types that share runtime presentation between JS and ReScript"
-canonical: "/docs/manual/latest/shared-data-types"
----
-
-# Shared Data Types
-
-ReScript's built-in values of type `string`, `float`, `array` and a few others have a rather interesting property: they compile to the exact same value in JavaScript!
-
-This means that if you're passing e.g. a ReScript string to the JavaScript side, the JS side can directly use it as a native JS string. It also means that you can import a JS string and pretend it's a native ReScript string.
-
-Unlike most compiled-to-js languages, in ReScript, **you don't need to write data converters back and forth for most of our values**!
-
-**Shared, bidirectionally usable types**:
-- String. ReScript strings are JavaScript strings, vice-versa. (Caveat: only our backtick string `` `hello 👋 ${personName}` `` supports unicode and interpolation).
-- Float. ReScript floats are JS numbers, vice-versa.
-- Array. In addition to the [JS Array API](api/js/array), we provide our own [Belt.Array](api/belt/array#set) API too.
-- Tuple. Compiles to a JS array. You can treat a fixed-sized, heterogenous JS array as ReScript tuple too.
-- Boolean.
-- Record. Record compiles to JS object. Therefore you can also treat JS objects as records. If they're too dynamic, consider modeling them on the ReScript side as a hashmap/dictionary [`Js.Dict`](api/js/dict) or a ReScript object.
-- Object. ReScript objects are JavaScript objects, vice-versa.
-- Function. They compile to clean JS functions.
-- Module. ReScript files are considered top-level modules, and are compiled to JS files 1 to 1. Nested modules are compiled to JavaScript objects.
-- Polymorphic variants.
-- Unit. The `unit` type, which has a single value `()`, compiles to `undefined` too. Likewise, you can treat an incoming JS `undefined` as `()` if that's the only value it'll ever be.
-
-**Types that are slightly different than JS, but that you can still use from JS**:
-- Int. **Ints are 32-bits**! Be careful, you can potentially treat them as JS numbers and vice-versa, but if the number's large, then you better treat JS numbers as floats. For example, we bind to Js.Date using `float`s.
-- Option. The `option` type's `None` value compiles into JS `undefined`. The `Some` value, e.g. `Some(5)`, compiles to `5`. Likewise, you can treat an incoming JS `undefined` as `None`. **JS `null` isn't handled here**. If your JS value can be `null`, use [Js.Nullable](api/js/nullable) helpers.
-- Exception.
-- Variant. Check the compiled JavaScript output of variant to see its shape. We don't recommend exporting a ReScript variant for pure JS usage, since they're harder to read as plain JS code, but you can do it.
-- List, which is just a regular variant.
-
-**Non-shared types (aka internal types)**:
-
-- Character.
-- Int64.
-- Lazy values.
-- Everything else.
-
-Many of these are stable, which means that you can still serialize/deserialize them as-is without manual conversions. But we discourage actively peeking into their structure otherwise.
-
-These types require manual conversions if you want to export them for JS consumption. For a seamless JS/TypeScript/Flow integration experience, you might want to use [genType](https://github.com/cristianoc/gentype) instead of doing conversions by hand.
diff --git a/pages/docs/manual/v10.0.0/try.mdx b/pages/docs/manual/v10.0.0/try.mdx
deleted file mode 100644
index 6e250decc..000000000
--- a/pages/docs/manual/v10.0.0/try.mdx
+++ /dev/null
@@ -1,9 +0,0 @@
----
-title: "Try"
-description: "Try ReScript via Command Line"
-canonical: "/docs/manual/latest/try"
----
-
-## Try Online
-
-Our [Playground](/try) lets you try ReScript online, and comes with [ReScript-React](/docs/react/latest/introduction) preinstalled.
diff --git a/pages/docs/manual/v10.0.0/tuple.mdx b/pages/docs/manual/v10.0.0/tuple.mdx
deleted file mode 100644
index 2790ee67b..000000000
--- a/pages/docs/manual/v10.0.0/tuple.mdx
+++ /dev/null
@@ -1,104 +0,0 @@
----
-title: "Tuple"
-description: "Tuple types and values in ReScript"
-canonical: "/docs/manual/latest/tuple"
----
-
-# Tuple
-
-Tuples are a ReScript-specific data structure that doesn't exist in JavaScript. They are:
-
-- immutable
-- ordered
-- fix-sized at creation time
-- heterogeneous (can contain different types of values)
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let ageAndName = (24, "Lil' ReScript")
-let my3dCoordinates = (20.0, 30.5, 100.0)
-```
-```js
-var ageAndName = [24, "Lil' ReScript"];
-var my3dCoordinates = [20.0, 30.5, 100.0];
-```
-
-</CodeTab>
-
-Tuples' types can be used in type annotations as well. Tuple types visually resemble tuples values.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let ageAndName: (int, string) = (24, "Lil' ReScript")
-// a tuple type alias
-type coord3d = (float, float, float)
-let my3dCoordinates: coord3d = (20.0, 30.5, 100.0)
-```
-```js
-var ageAndName = [24, "Lil' ReScript"];
-var my3dCoordinates = [20.0, 30.5, 100.0];
-```
-</CodeTab>
-
-**Note**: there's no tuple of size 1. You'd just use the value itself.
-
-## Usage
-
-To get a specific member of a tuple, destructure it:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let (_, y, _) = my3dCoordinates // now you've retrieved y
-```
-```js
-var y = 30.5;
-```
-
-</CodeTab>
-
-The `_` means you're ignoring the indicated members of the tuple.
-
-Tuples aren't meant to be updated mutatively. You'd create new ones by destructuring the old ones:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let coordinates1 = (10, 20, 30)
-let (c1x, _, _) = coordinates1
-let coordinates2 = (c1x + 50, 20, 30)
-```
-```js
-var coordinates1 = [10, 20, 30];
-var c1x = 10;
-var coordinates2 = [60, 20, 30];
-```
-
-</CodeTab>
-
-## Tips & Tricks
-
-You'd use tuples in handy situations that pass around multiple values without too much ceremony. For example, to return many values:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let getCenterCoordinates = () => {
-  let x = doSomeOperationsHere()
-  let y = doSomeMoreOperationsHere()
-  (x, y)
-}
-```
-```js
-function getCenterCoordinates(param) {
-  var x = doSomeOperationsHere(undefined);
-  var y = doSomeMoreOperationsHere(undefined);
-  return [x, y];
-}
-```
-
-</CodeTab>
-
-Try to keep the usage of tuple **local**. For data structures that are long-living and passed around often, prefer a **record**, which has named fields.
diff --git a/pages/docs/manual/v10.0.0/type.mdx b/pages/docs/manual/v10.0.0/type.mdx
deleted file mode 100644
index dbace0817..000000000
--- a/pages/docs/manual/v10.0.0/type.mdx
+++ /dev/null
@@ -1,278 +0,0 @@
----
-title: "Type"
-description: "Types and type definitions in ReScript"
-canonical: "/docs/manual/latest/type"
----
-
-# Type
-
-Types are the highlight of ReScript! They are:
-- **Strong**. A type can't change into another type. In JavaScript, your variable's type might change when the code runs (aka at runtime). E.g. a `number` variable might change into a `string` sometimes. This is an anti-feature; it makes the code much harder to understand when reading or debugging.
-- **Static**. ReScript types are erased after compilation and don't exist at runtime. Never worry about your types dragging down performance. You don't need type info during runtime; we report all the information (especially all the type errors) during compile time. Catch the bugs earlier!
-- **Sound**. This is our biggest differentiator versus many other typed languages that compile to JavaScript. Our type system is guaranteed to **never** be wrong. Most type systems make a guess at the type of a value and show you a type in your editor that's sometimes incorrect. We don't do that. We believe that a type system that is sometimes incorrect can end up dangerous due to expectation mismatches.
-- **Fast**. Many developers underestimate how much of their project's build time goes into type checking. Our type checker is one of the fastest around.
-- **Inferred**. You don't have to write down the types! ReScript can deduce them from their values. Yes, it might seem magical that we can deduce all of your program's types, without incorrectness, without your manual annotation, and do so quickly. Welcome to ReScript =).
-
-The following sections explore more of our type system.
-
-## Inference
-
-This let-binding doesn't contain any written type:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let score = 10
-let add = (a, b) => a + b
-```
-```js
-var score = 10;
-function add(a, b) {
-  return a + b | 0;
-}
-```
-
-</CodeTab>
-
-ReScript knows that `score` is an `int`, judging by the value `10`. This is called **inference**. Likewise, it also knows that the `add` function takes 2 `int`s and returns an `int`, judging from the `+` operator, which works on ints.
-
-## Type Annotation
-
-But you can also optionally write down the type, aka annotate your value:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let score: int = 10
-```
-```js
-var score = 10;
-```
-
-</CodeTab>
-
-If the type annotation for `score` doesn't correspond to our inferred type for it, we'll show you an error during compilation time. We **won't** silently assume your type annotation is correct, unlike many other languages.
-
-You can also wrap any expression in parentheses and annotate it:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let myInt = 5
-let myInt: int = 5
-let myInt = (5: int) + (4: int)
-let add = (x: int, y: int) : int => x + y
-let drawCircle = (~radius as r: int): circleType => /* code here */
-```
-```js
-var myInt = 9;
-function add(x, y) {
-  return x + y | 0;
-}
-function drawCircle(r) {
-  /* code here */
-}
-```
-
-</CodeTab>
-
-Note: in the last line, `(~radius as r: int)` is a labeled argument. More on this in the [function](function.md) page.
-
-## Type Alias
-
-You can refer to a type by a different name. They'll be equivalent:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type scoreType = int
-let x: scoreType = 10
-```
-```js
-var x = 10;
-```
-
-</CodeTab>
-
-## Type Parameter (Aka Generic)
-
-Types can accept parameters, akin to generics in other languages. The parameters' names **need** to start with `'`.
-
-The use-case of a parameterized type is to kill duplications. Before:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// this is a tuple of 3 items, explained next
-type intCoordinates = (int, int, int)
-type floatCoordinates = (float, float, float)
-
-let a: intCoordinates = (10, 20, 20)
-let b: floatCoordinates = (10.5, 20.5, 20.5)
-```
-```js
-var a = [10, 20, 20];
-var b = [10.5, 20.5, 20.5];
-```
-
-</CodeTab>
-
-After:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type coordinates<'a> = ('a, 'a, 'a)
-
-let a: coordinates<int> = (10, 20, 20)
-let b: coordinates<float> = (10.5, 20.5, 20.5)
-```
-```js
-var a = [10, 20, 20];
-var b = [10.5, 20.5, 20.5];
-```
-
-</CodeTab>
-
-Note that the above codes are just contrived examples for illustration purposes. Since the types are inferred, you could have just written:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let buddy = (10, 20, 20)
-```
-```js
-var buddy = [10, 20, 20];
-```
-
-</CodeTab>
-
-The type system infers that it's a `(int, int, int)`. Nothing else needed to be written down.
-
-Type arguments appear in many places. Our `array<'a>` type is such a type that requires a type parameter.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// inferred as `array<string>`
-let greetings = ["hello", "world", "how are you"]
-```
-```js
-// inferred as `array<string>`
-var greetings = ["hello", "world", "how are you"];
-```
-
-</CodeTab>
-
-If types didn't accept parameters, the standard library would need to define the types `arrayOfString`, `arrayOfInt`, `arrayOfTuplesOfInt`, etc. That'd be tedious.
-
-Types can receive many arguments, and be composable.
-
-<!-- TODO: too early for this example -->
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type result<'a, 'b> =
-  | Ok('a)
-  | Error('b)
-
-type myPayload = {data: string}
-
-type myPayloadResults<'errorType> = array<result<myPayload, 'errorType>>
-
-let payloadResults: myPayloadResults<string> = [
-  Ok({data: "hi"}),
-  Ok({data: "bye"}),
-  Error("Something wrong happened!")
-]
-```
-```js
-var payloadResults = [
-  {
-    TAG: /* Ok */0,
-    _0: {data: "hi"}
-  },
-  {
-    TAG: /* Ok */0,
-    _0: {data: "bye"}
-  },
-  {
-    TAG: /* Error */1,
-    _0: "Something wrong happened!"
-  }
-];
-```
-
-</CodeTab>
-
-## Recursive Types
-
-Just like a function, a type can reference itself within itself using `rec`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type rec person = {
-  name: string,
-  friends: array<person>
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Mutually Recursive Types
-
-Types can also be _mutually_ recursive through `and`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type rec student = {taughtBy: teacher}
-and teacher = {students: array<student>}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Type Escape Hatch
-
-ReScript's type system is robust and does not allow dangerous, unsafe stuff like implicit type casting, randomly guessing a value's type, etc. However, out of pragmatism, we expose a single escape hatch for you to "lie" to the type system:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-external myShadyConversion: myType1 => myType2 = "%identity"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-This declaration converts a `myType1` of your choice to `myType2` of your choice. You can use it like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-external convertToFloat : int => float = "%identity"
-let age = 10
-let gpa = 2.1 +. convertToFloat(age)
-```
-```js
-var age = 10;
-var gpa = 2.1 + 10;
-```
-
-</CodeTab>
-
-Obviously, do **not** abuse this feature. Use it tastefully when you're working with existing, overly dynamic JS code, for example.
-
-More on externals [here](external.md).
-
-**Note**: this particular `external` is the only one that isn't preceded by a `@` [attribute](attribute.md).
diff --git a/pages/docs/manual/v10.0.0/unboxed.mdx b/pages/docs/manual/v10.0.0/unboxed.mdx
deleted file mode 100644
index 6ebe3c4b3..000000000
--- a/pages/docs/manual/v10.0.0/unboxed.mdx
+++ /dev/null
@@ -1,157 +0,0 @@
----
-title: "Unboxed"
-description: "Unbox a wrapper"
-canonical: "/docs/manual/latest/unboxed"
----
-
-# Unboxed
-
-Consider a ReScript variant with a single payload, and a record with a single field:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type name = Name(string)
-let studentName = Name("Joe")
-
-type greeting = {message: string}
-let hi = {message: "hello!"}
-```
-```js
-var studentName = /* Name */{
-  _0: "Joe"
-};
-
-var hi = {
-  message: "hello!"
-};
-```
-
-</CodeTab>
-
-If you check the JavaScript output, you'll see the `studentName` and `hi` JS object, as expected (see the [variant JS output](variant#javascript-output) and [record JS output](record#javascript-output) sections for details).
-
-For performance and certain JavaScript interop situations, ReScript offers a way to unwrap (aka unbox) the JS object wrappers from the output for records with a single field and variants with a single constructor and single payload. Annotate their type declaration with the attribute `@unboxed`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@unboxed
-type name = Name(string)
-let studentName = Name("Joe")
-
-@unboxed
-type greeting = {message: string}
-let hi = {message: "hello!"}
-```
-```js
-var studentName = "Joe";
-
-var hi = "hello!";
-```
-
-</CodeTab>
-
-Check the new output! Clean.
-
-## Usage
-
-Why would you ever want a variant or a record with a single payload? Why not just... pass the payload? Here's one use-case for variant.
-
-Suppose you have a game with a local/global coordinate system:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type coordinates = {x: float, y: float}
-
-let renderDot = (coordinates) => {
-  Js.log3("Pretend to draw at:", coordinates.x, coordinates.y)
-}
-
-let toWorldCoordinates = (localCoordinates) => {
-  {
-    x: localCoordinates.x +. 10.,
-    y: localCoordinates.x +. 20.,
-  }
-}
-
-let playerLocalCoordinates = {x: 20.5, y: 30.5}
-
-renderDot(playerLocalCoordinates)
-```
-```js
-function renderDot(coordinates) {
-  console.log("Pretend to draw at:", coordinates.x, coordinates.y);
-}
-
-function toWorldCoordinates(localCoordinates) {
-  return {
-    x: localCoordinates.x + 10,
-    y: localCoordinates.x + 20
-  };
-}
-
-var playerLocalCoordinates = {
-  x: 20.5,
-  y: 30.5
-};
-
-renderDot(playerLocalCoordinates);
-```
-
-</CodeTab>
-
-Oops, that's wrong! `renderDot` should have taken global coordinates, not local ones... Let's prevent passing the wrong kind of coordinates:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type coordinates = {x: float, y: float}
-@unboxed type localCoordinates = Local(coordinates)
-@unboxed type worldCoordinates = World(coordinates)
-
-let renderDot = (World(coordinates)) => {
-  Js.log3("Pretend to draw at:", coordinates.x, coordinates.y)
-}
-
-let toWorldCoordinates = (Local(coordinates)) => {
-  World({
-    x: coordinates.x +. 10.,
-    y: coordinates.x +. 20.,
-  })
-}
-
-let playerLocalCoordinates = Local({x: 20.5, y: 30.5})
-
-// This now errors!
-// renderDot(playerLocalCoordinates)
-// We're forced to do this instead:
-renderDot(playerLocalCoordinates->toWorldCoordinates)
-```
-```js
-function renderDot(coordinates) {
-  console.log("Pretend to draw at:", coordinates.x, coordinates.y);
-}
-
-function toWorldCoordinates(coordinates) {
-  return {
-    x: coordinates.x + 10,
-    y: coordinates.x + 20
-  };
-}
-
-var playerLocalCoordinates = {
-  x: 20.5,
-  y: 30.5
-};
-
-renderDot(toWorldCoordinates(playerLocalCoordinates));
-```
-
-</CodeTab>
-
-Now `renderDot` only takes `worldCoordinates`. Through a nice combination of using distinct variant types + argument destructuring, we've achieved better safety **without compromising on performance**: the `unboxed` attribute compiled to clean, variant-wrapper-less JS code! Check the output.
-
-As for a record with a single field, the use-cases are a bit more edgy. We won't mention them here.
-
diff --git a/pages/docs/manual/v10.0.0/use-illegal-identifier-names.mdx b/pages/docs/manual/v10.0.0/use-illegal-identifier-names.mdx
deleted file mode 100644
index a1e2eaf58..000000000
--- a/pages/docs/manual/v10.0.0/use-illegal-identifier-names.mdx
+++ /dev/null
@@ -1,51 +0,0 @@
----
-title: "Use Illegal Identifier Names"
-description: "Handling (JS) naming collisions in ReScript"
-canonical: "/docs/manual/latest/use-illegal-identifier-names"
----
-
-# Use Illegal Identifier Names
-
-Sometime, for e.g. a let binding or a record field, you might want to use:
-- A capitalized name.
-- A name that contains illegal characters (e.g. emojis, hyphen, space).
-- A name that's one of ReScript's reserved keywords.
-
-We provide an escape hatch syntax for these cases:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let \"my-🍎" = 10
-
-type element = {
-  \"aria-label": string
-}
-
-let myElement = {
-  \"aria-label": "close"
-}
-
-let label = myElement.\"aria-label"
-
-let calculate = (~\"Props") => {
-  \"Props" + 1
-}
-```
-```js
-var my$$unknown$unknown$unknown$unknown = 10;
-
-var myElement = {
-  "aria-label": "close"
-};
-
-var label = myElement["aria-label"];
-
-function calculate(Props) {
-  return Props + 1 | 0;
-}
-```
-
-</CodeTab>
-
-See the output. **Use them only when necessary**, for interop with JavaScript. This is a last-resort feature. If you abuse this, many of the compiler guarantees will go away.
diff --git a/pages/docs/manual/v10.0.0/variant.mdx b/pages/docs/manual/v10.0.0/variant.mdx
deleted file mode 100644
index 9e8624fa2..000000000
--- a/pages/docs/manual/v10.0.0/variant.mdx
+++ /dev/null
@@ -1,358 +0,0 @@
----
-title: "Variant"
-description: "Variant data structures in ReScript"
-canonical: "/docs/manual/latest/variant"
----
-
-# Variant
-
-So far, most of ReScript's data structures might look familiar to you. This section introduces an extremely important, and perhaps unfamiliar, data structure: variant.
-
-Most data structures in most languages are about "this **and** that". A variant allows us to express "this **or** that".
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type myResponse =
-  | Yes
-  | No
-  | PrettyMuch
-
-let areYouCrushingIt = Yes
-```
-```js
-var areYouCrushingIt = /* Yes */0;
-```
-
-</CodeTab>
-
-`myResponse` is a variant type with the cases `Yes`, `No` and `PrettyMuch`, which are called "variant constructors" (or "variant tag"). The `|` bar separates each constructor.
-
-**Note**: a variant's constructors need to be capitalized.
-
-## Variant Needs an Explicit Definition
-
-If the variant you're using is in a different file, bring it into scope like you'd do [for a record](record.md#record-needs-an-explicit-definition):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// Zoo.res
-type animal = Dog | Cat | Bird
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Example.res
-let pet: Zoo.animal = Dog // preferred
-// or
-let pet2 = Zoo.Dog
-```
-```js
-var pet = /* Dog */0;
-var pet2 = /* Dog */0;
-```
-
-</CodeTab>
-
-## Constructor Arguments
-
-A variant's constructors can hold extra data separated by comma.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type account =
-  | None
-  | Instagram(string)
-  | Facebook(string, int)
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Here, `Instagram` holds a `string`, and `Facebook` holds a `string` and an `int`. Usage:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myAccount = Facebook("Josh", 26)
-let friendAccount = Instagram("Jenny")
-```
-```js
-var myAccount = {
-  TAG: /* Facebook */1,
-  _0: "Josh",
-  _1: 26
-};
-var friendAccount = {
-  TAG: /* Instagram */0,
-  _0: "Jenny"
-};
-```
-
-</CodeTab>
-
-### Labeled Variant Payloads (Inline Record)
-
-If a variant payload has multiple fields, you can use a record-like syntax to label them for better readability:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type user =
-  | Number(int)
-  | Id({name: string, password: string})
-
-let me = Id({name: "Joe", password: "123"})
-```
-```js
-var me = {
-  TAG: /* Id */1,
-  name: "Joe",
-  password: "123"
-};
-```
-
-</CodeTab>
-
-This is technically called an "inline record", and only allowed within a variant constructor. You cannot inline a record type declaration anywhere else in ReScript.
-
-Of course, you can just put a regular record type in a variant too:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type u = {name: string, password: string}
-type user =
-  | Number(int)
-  | Id(u)
-
-let me = Id({name: "Joe", password: "123"})
-```
-```js
-var me = {
-  TAG: /* Id */1,
-  _0: {
-    name: "Joe",
-    password: "123"
-  }
-};
-```
-
-</CodeTab>
-
-The output is slightly uglier and less performant than the former.
-
-### Pattern Matching On Variant
-
-See the [Pattern Matching/Destructuring](pattern-matching-destructuring) section later.
-
-## JavaScript Output
-
-A variant value compiles to 3 possible JavaScript outputs depending on its type declaration:
-
-- If the variant value is a constructor with no payload, it compiles to a number.
-- If it's a constructor with a payload, it compiles to an object with the field `TAG` and the field `_0` for the first payload, `_1` for the second payload, etc.
-- An exception to the above is a variant whose type declaration contains only a single constructor with payload. In that case, the constructor compiles to an object without the `TAG` field.
-- Labeled variant payloads (the inline record trick earlier) compile to an object with the label names instead of `_0`, `_1`, etc. The object might or might not have the `TAG` field as per previous rule.
-
-Check the output in these examples:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type greeting = Hello | Goodbye
-let g1 = Hello
-let g2 = Goodbye
-
-type outcome = Good | Error(string)
-let o1 = Good
-let o2 = Error("oops!")
-
-type family = Child | Mom(int, string) | Dad (int)
-let f1 = Child
-let f2 = Mom(30, "Jane")
-let f3 = Dad(32)
-
-type person = Teacher | Student({gpa: float})
-let p1 = Teacher
-let p2 = Student({gpa: 99.5})
-
-type s = {score: float}
-type adventurer = Warrior(s) | Wizard(string)
-let a1 = Warrior({score: 10.5})
-let a2 = Wizard("Joe")
-```
-```js
-var g1 = /* Hello */0;
-var g2 = /* Goodbye */1;
-
-var o1 = /* Good */0;
-var o2 = /* Error */{
-  _0: "oops!"
-};
-
-var f1 = /* Child */0;
-var f2 = {
-  TAG: /* Mom */0,
-  _0: 30,
-  _1: "Jane"
-};
-var f3 = {
-  TAG: /* Dad */1,
-  _0: 32
-};
-
-var p1 = /* Teacher */0;
-var p2 = /* Student */{
-  gpa: 99.5
-};
-
-var a1 = {
-  TAG: /* Warrior */0,
-  _0: {
-    score: 10.5
-  }
-};
-var a2 = {
-  TAG: /* Wizard */1,
-  _0: "Joe"
-};
-```
-
-</CodeTab>
-
-## Tips & Tricks
-
-**Be careful** not to confuse a constructor carrying 2 arguments with a constructor carrying a single tuple argument:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type account =
-  | Facebook(string, int) // 2 arguments
-type account2 =
-  | Instagram((string, int)) // 1 argument - happens to be a 2-tuple
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-### Variants Must Have Constructors
-
-If you come from an untyped language, you might be tempted to try `type myType = int | string`. This isn't possible in ReScript; you'd have to give each branch a constructor: `type myType = Int(int) | String(string)`. The former looks nice, but causes lots of trouble down the line.
-
-### Interop with JavaScript
-
-_This section assumes knowledge about our JavaScript interop. Skip this if you haven't felt the itch to use variants for wrapping JS functions yet_.
-
-Quite a few JS libraries use functions that can accept many types of arguments. In these cases, it's very tempting to model them as variants. For example, suppose there's a `myLibrary.draw` JS function that takes in either a `number` or a `string`. You might be tempted to bind it like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// reserved for internal usage
-@module("myLibrary") external draw : 'a => unit = "draw"
-
-type animal =
-  | MyFloat(float)
-  | MyString(string)
-
-let betterDraw = (animal) =>
-  switch animal {
-  | MyFloat(f) => draw(f)
-  | MyString(s) => draw(s)
-  }
-
-betterDraw(MyFloat(1.5))
-```
-```js
-var MyLibrary = require("myLibrary");
-
-function betterDraw(animal) {
-  MyLibrary.draw(animal._0);
-}
-
-betterDraw({
-  TAG: /* MyFloat */0,
-  _0: 1.5
-});
-```
-
-</CodeTab>
-
-**Try not to do that**, as this generates extra noisy output. Alternatively, define two `external`s that both compile to the same JS call:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("myLibrary") external drawFloat: float => unit = "draw"
-@module("myLibrary") external drawString: string => unit = "draw"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-ReScript also provides [a few other ways](bind-to-js-function.md#modeling-polymorphic-function) to do this.
-
-### Variant Types Are Found By Field Name
-
-Please refer to this [record section](record#tips--tricks). Variants are the same: a function can't accept an arbitrary constructor shared by two different variants. Again, such feature exists; it's called a polymorphic variant. We'll talk about this in the future =).
-
-## Design Decisions
-
-Variants, in their many forms (polymorphic variant, open variant, GADT, etc.), are likely _the_ feature of a type system such as ReScript's. The aforementioned `option` variant, for example, obliterates the need for nullable types, a major source of bugs in other languages. Philosophically speaking, a problem is composed of many possible branches/conditions. Mishandling these conditions is the majority of what we call bugs. **A type system doesn't magically eliminate bugs; it points out the unhandled conditions and asks you to cover them**\*. The ability to model "this or that" correctly is crucial.
-
-For example, some folks wonder how the type system can safely eliminate badly formatted JSON data from propagating into their program. They don't, not by themselves! But if the parser returns the `option` type `None | Some(actualData)`, then you'd have to handle the `None` case explicitly in later call sites. That's all there is.
-
-Performance-wise, a variant can potentially tremendously speed up your program's logic. Here's a piece of JavaScript:
-
-```js
-let data = 'dog'
-if (data === 'dog') {
-  ...
-} else if (data === 'cat') {
-  ...
-} else if (data === 'bird') {
-  ...
-}
-```
-
-There's a linear amount of branch checking here (`O(n)`). Compare this to using a ReScript variant:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type animal = Dog | Cat | Bird
-let data = Dog
-switch data {
-| Dog => Js.log("Wof")
-| Cat => Js.log("Meow")
-| Bird => Js.log("Kashiiin")
-}
-```
-```js
-console.log("Wof");
-
-var data = /* Dog */0;
-```
-
-</CodeTab>
-
-The compiler sees the variant, then
-
-1. conceptually turns them into `type animal = 0 | 1 | 2`
-2. compiles `switch` to a constant-time jump table (`O(1)`).
diff --git a/pages/docs/manual/v10.0.0/warning-numbers.mdx b/pages/docs/manual/v10.0.0/warning-numbers.mdx
deleted file mode 100644
index 80800170d..000000000
--- a/pages/docs/manual/v10.0.0/warning-numbers.mdx
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: "Warning Numbers"
-description: "Available compiler warning numbers in ReScript"
-canonical: "/docs/manual/latest/warning-numbers"
----
-
-import { make as WarningTable } from "src/components/WarningTable.mjs";
-
-# Warning Numbers
-
-You can configure which warnings the ReScript compiler generates
-[in the build configuration](/docs/manual/latest/build-configuration#warnings) or
-using the [`@warning()`](/syntax-lookup#expression-warning-decorator) or the [`@@warning()`](/syntax-lookup#module-warning-decorator) decorator.
-
-<WarningTable />
diff --git a/pages/docs/manual/v11.0.0/api.mdx b/pages/docs/manual/v11.0.0/api.mdx
deleted file mode 100644
index 79f9fdbd1..000000000
--- a/pages/docs/manual/v11.0.0/api.mdx
+++ /dev/null
@@ -1,18 +0,0 @@
-# Introduction
-
-## ReScript Core
-
-[Core](api/core) is ReScript's new standard library. It replaces the complete `Js` module as well as some of the more frequently used modules from `Belt` and is recommended to use with uncurried mode.
-
-In ReScript 11, it is shipped as a separate npm package `@rescript/core` that is added to your project as per the [installation instructions](/docs/manual/latest/installation). In future ReScript versions, it will be included with the `rescript` npm package itself.
-
-## Additional Libraries
-
-ReScript ships with these two additional modules in its standard library:
-
-- [Belt](api/belt): immutable collections and extra helpers not available in JavaScript / [Core](api/core).
-- [Dom](api/dom): Dom related types and modules. Contains our standardized types used by various userland DOM bindings.
-
-## Legacy Modules
-
-The [Js](api/js) module is superseded by [Core](api/core).
diff --git a/pages/docs/manual/v11.0.0/api/[...slug].js b/pages/docs/manual/v11.0.0/api/[...slug].js
deleted file mode 100644
index 16be65f8b..000000000
--- a/pages/docs/manual/v11.0.0/api/[...slug].js
+++ /dev/null
@@ -1,18 +0,0 @@
-import {
-  getStaticPathsByVersion,
-  getStaticPropsByVersion,
-} from "src/ApiDocs.mjs";
-
-import APIDocs from "src/ApiDocs.mjs";
-
-export async function getStaticProps(ctx) {
-  return await getStaticPropsByVersion({ ...ctx, version: "v11.0.0" });
-}
-
-export async function getStaticPaths(ctx) {
-  return await getStaticPathsByVersion("v11.0.0");
-}
-
-export default function Comp(props) {
-  return <APIDocs {...props} />;
-}
diff --git a/pages/docs/manual/v11.0.0/array-and-list.mdx b/pages/docs/manual/v11.0.0/array-and-list.mdx
deleted file mode 100644
index ddc553633..000000000
--- a/pages/docs/manual/v11.0.0/array-and-list.mdx
+++ /dev/null
@@ -1,219 +0,0 @@
----
-title: "Array & List"
-description: "Arrays and List data structures"
-canonical: "/docs/manual/v11.0.0/array-and-list"
----
-
-# Array and List
-
-## Array
-
-Arrays are our main ordered data structure. They work the same way as JavaScript arrays: they can be randomly accessed, dynamically resized, updated, etc.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myArray = ["hello", "world", "how are you"]
-```
-```js
-var myArray = ["hello", "world", "how are you"];
-```
-
-</CodeTab>
-
-ReScript arrays' items must have the same type, i.e. homogeneous.
-
-### Usage
-#### Access
-Accessing items in an array will return an `option` and can be done like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myArray = ["hello", "world", "how are you"]
-
-let firstItem = myArray[0] // Some("hello")
-
-let tenthItem = myArray->Array.get(10) // None
-```
-```js
-var myArray = ["hello", "world", "how are you"];
-
-var firstItem = myArray[0];
-
-var tenthItem = myArray[10];
-```
-
-</CodeTab>
-
-The behavior of returning an `option` is new to V11 when you have [Core](api/core) open. 
-It provides a safer way to access array items, which is especially useful when you're not sure if the index is out of bounds.
-If you would like to not use an `option`, you can use [`Array.getUnsafe`](api/core/array#value-getUnsafe).
-
-#### Update
-Items in an array can be updated by assigning a value to an index or using a function:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myArray = ["hello", "world", "how are you"]
-
-myArray[0] = "hey" // now ["hey", "world", "how are you"]
-
-myArray->Array.push("?") //  ["hey", "world", "how are you", "?"]
-
-myArray->Array.set(0, "bye") //  ["bye", "world", "how are you", "?"]
-```
-```js
-var myArray = ["hello", "world", "how are you"];
-
-myArray[0] = "hey";
-
-myArray.push("?");
-
-myArray[0] = "bye";
-```
-
-</CodeTab>
-
-### Array spreads
-
-**Since 11.1**
-
-
-You can spread arrays of the the same type into new arrays, just like in JavaScript:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let y = [1, 2]
-let x = [4, 5, ...y]
-let x2 = [4, 5, ...y, 7, ...y]
-let x3 = [...y]
-```
-
-```javascript
-var Belt_Array = require("rescript/lib/js/belt_Array.js");
-
-var y = [
-  1,
-  2
-];
-
-var x = Belt_Array.concatMany([
-      [
-        4,
-        5
-      ],
-      y
-    ]);
-
-var x2 = Belt_Array.concatMany([
-      [
-        4,
-        5
-      ],
-      y,
-      [7],
-      y
-    ]);
-
-var x3 = Belt_Array.concatMany([y]);
-```
-</CodeTab>
-
-> Note that array spreads compiles to `Belt.Array.concatMany` right now. This is likely to change to native array spreads in the future.
-
-## List
-
-ReScript provides a singly linked list too. Lists are:
-
-- immutable
-- fast at prepending items
-- fast at getting the head
-- slow at everything else
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myList = list{1, 2, 3}
-```
-```js
-var myList = {
-  hd: 1,
-  tl: {
-    hd: 2,
-    tl: {
-      hd: 3,
-      tl: 0
-    }
-  }
-};
-```
-
-</CodeTab>
-
-Like arrays, lists' items need to be of the same type.
-
-### Usage
-
-You'd use list for its resizability, its fast prepend (adding at the head), and its fast split, all of which are immutable and relatively efficient.
-
-Do **not** use list if you need to randomly access an item or insert at non-head position. Your code would end up obtuse and/or slow.
-
-The standard lib provides a [List module](api/core/list).
-
-#### Immutable Prepend
-
-Use the spread syntax:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let myList = list{1, 2, 3}
-let anotherList = list{0, ...myList}
-```
-```js
-var myList = {
-  hd: 1,
-  tl: {
-    hd: 2,
-    tl: {
-      hd: 3,
-      tl: 0
-    }
-  }
-};
-
-var anotherList = {
-  hd: 0,
-  tl: myList
-};
-```
-
-</CodeTab>
-
-`myList` didn't mutate. `anotherList` is now `list{0, 1, 2, 3}`. This is efficient (constant time, not linear). `anotherList`'s last 3 elements are shared with `myList`!
-
-**Note that `list{a, ...b, ...c}` was a syntax error** before compiler v10.1. In general, the pattern should be used with care as its performance and allocation overhead are linear (`O(n)`).
-
-#### Access
-
-`switch` (described in the [pattern matching section](pattern-matching-destructuring.md)) is usually used to access list items:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let message =
-  switch myList {
-  | list{} => "This list is empty"
-  | list{a, ...rest} => "The head of the list is the string " ++ Int.toString(a)
-  }
-```
-```js
-var message = myList
-  ? "The head of the list is the string " + (1).toString()
-  : "This list is empty";
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v11.0.0/async-await.mdx b/pages/docs/manual/v11.0.0/async-await.mdx
deleted file mode 100644
index 76d07dcac..000000000
--- a/pages/docs/manual/v11.0.0/async-await.mdx
+++ /dev/null
@@ -1,326 +0,0 @@
----
-title: "Async / Await"
-description: "Async / await for asynchronous operations"
-canonical: "/docs/manual/v11.0.0/async-await"
----
-
-<!-- This prelude is used in many different followup examples, so we use it to shorten the noise of the example code. -->
-<div className="hidden">
-
-```res prelude
-@val external fetchUserMail: string => promise<string> = "GlobalAPI.fetchUserMail"
-@val external sendAnalytics: string => promise<unit> = "GlobalAPI.sendAnalytics"
-```
-
-</div>
-
-<!-- See https://github.com/cristianoc/rescript-compiler-experiments/pull/1#issuecomment-1131182023 for all async/await use-case examples -->
-
-# Async / Await
-
-ReScript comes with `async` / `await` support to make asynchronous, `Promise` based code easier to read and write. This feature is very similar to its JS equivalent, so if you are already familiar with JS' `async` / `await`, you will feel right at home.
-
-## How it looks 
-
-Let's start with a quick example to show-case the syntax:
-
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Some fictive functionality that offers asynchronous network actions
-@val external fetchUserMail: string => promise<string> = "GlobalAPI.fetchUserMail"
-@val external sendAnalytics: string => promise<unit> = "GlobalAPI.sendAnalytics"
-
-// We use the `async` keyword to allow the use of `await` in the function body
-let logUserDetails = async (userId: string) => {
-  // We use `await` to fetch the user email from our fictive user endpoint
-  let email = await fetchUserMail(userId)
-
-  await sendAnalytics(`User details have been logged for ${userId}`)
-
-  Console.log(`Email address for user ${userId}: ${email}`)
-}
-```
-
-```js
-async function logUserDetails(userId) {
-  var email = await GlobalAPI.fetchUserMail(userId);
-  await GlobalAPI.sendAnalytics("User details have been logged for " + userId + "");
-  console.log("Email address for user " + userId + ": " + email + "");
-}
-```
-
-</CodeTab>
-
-As we can see above, an `async` function is defined via the `async` keyword right before the function's parameter list. In the function body, we are now able to use the `await` keyword to explicitly wait for a `Promise` value and assign its content to a let binding `email`.
-
-You will probably notice that this looks very similar to `async` / `await` in JS, but there are still a few details that are specific to ReScript. The next few sections will go through all the details that are specific to the ReScript type system.
-
-## Basics
-
-- You may only use `await` in `async` function bodies
-- `await` may only be called on a `promise` value
-- `await` calls are expressions, therefore they can be used in pattern matching (`switch`)
-- A function returning a `promise<'a>` is equivalent to an `async` function returning a value `'a` (important for writing signature files and bindings)
-- `promise` values and types returned from an `async` function don't auto-collapse into a "flat promise" like in JS (more on this later)
-
-
-## Types and `async` functions
-
-### `async` function type signatures
-
-Function type signatures (i.e defined in signature files) don't require any special keywords for `async` usage. Whenever you want to type an `async` function, use a `promise` return type.
-
-```resi
-// Demo.resi
-
-let fetchUserMail: string => promise<string>
-```
-
-The same logic applies to type definitions in `.res` files:
-
-```res example
-// function type
-type someAsyncFn = int => promise<int>
-
-// Function type annotation
-let fetchData: string => promise<string> = async (userId) => {
-  await fetchUserMail(userId)
-}
-```
-
-**BUT:** When typing `async` functions in your implementation files, you need to omit the `promise<'a>` type:
-
-```res
-// This function is compiled into a `string => promise<string>` type.
-// The promise<...> part is implicitly added by the compiler.
-let fetchData = async (userId: string): string => {
-  await fetchUserMail("test")
-}
-```
-
-For completeness reasons, let's expand the full signature and inline type definitions in one code snippet:
-
-```res
-// Note how the inline return type uses `string`, while the type definition uses `promise<string>`
-let fetchData: string => promise<string> = async (userId: string): string {
-  await fetchUserMail(userId)
-}
-```
-
-**Note:** In a practical scenario you'd either use a type signature, or inline types, not both at the same time. In case you are interested in the design decisions, check out [this discussion](https://github.com/rescript-lang/rescript/pull/5913#issuecomment-1359003870).
-
-### Promises don't auto-collapse in async functions
-
-In JS, nested promises (i.e. `promise<promise<'a>>`) will automatically collapse into a flat promise (`promise<'a>`). This is not the case in ReScript. Use the `await` function to manually unwrap any nested promises within an `async` function instead.
-
-```res
-let fetchData = async (userId: string): string => {
-  // We can't just return the result of `fetchUserMail`, otherwise we'd get a
-  // type error due to our function return type of type `string`
-  await fetchUserMail(userId)
-}
-```
-
-## Error handling
-
-You may use `try / catch` or `switch` to handle exceptions during async execution.
-
-```res
-// For simulation purposes
-let authenticate = async () => {
-  raise(Exn.raiseRangeError("Authentication failed."))
-}
-
-let checkAuth = async () => {
-  try {
-    await authenticate()
-  } catch {
-  | Exn.Error(e) =>
-    switch Exn.message(e) {
-    | Some(msg) => Console.log("JS error thrown: " ++ msg)
-    | None => Console.log("Some other exception has been thrown")
-    }
-  }
-}
-```
-
-Note how we are essentially catching JS errors the same way as described in our [Exception](exception#catch-rescript-exceptions-from-js) section.
-
-You may unify error and value handling in a single switch as well:
-
-```res
-let authenticate = async () => {
-  raise(Exn.raiseRangeError("Authentication failed."))
-}
-
-let checkAuth = async () => {
-  switch await authenticate() {
-  | _ => Console.log("ok")
-  | exception Exn.Error(e) => 
-    switch Exn.message(e) {
-    | Some(msg) => Console.log("JS error thrown: " ++ msg)
-    | None => Console.log("Some other exception has been thrown")
-    }
-  }
-}
-```
-
-**Important:** When using `await` with a `switch`, always make sure to put the actual await call in the `switch` expression, otherwise your `await` error will not be caught.
-
-## Piping `await` calls
-
-You may want to pipe the result of an `await` call right into another function.
-This can be done by wrapping your `await` calls in a new `{}` closure.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external fetchUserMail: string => promise<string> = "GlobalAPI.fetchUserMail"
-
-let fetchData = async () => {
-  let mail = {await fetchUserMail("1234")}->String.toUpperCase
-  Console.log(`All upper-cased mail: ${mail}`)
-}
-```
-
-```js
-async function fetchData(param) {
-  var mail = (await GlobalAPI.fetchUserMail("1234")).toUpperCase();
-  console.log("All upper-cased mail: " + mail + "");
-}
-```
-
-</CodeTab>
-
-Note how the original closure was removed in the final JS output. No extra allocations!
-
-## Pattern matching on `await` calls
-
-`await` calls are just another kind of expression, so you can use `switch` pattern matching for more complex logic.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external fetchUserMail: string => promise<string> = "GlobalAPI.fetchUserMail"
-
-let fetchData = async () => {
-  switch (await fetchUserMail("user1"), await fetchUserMail("user2")) {
-  | (user1Mail, user2Mail) => {
-      Console.log("user 1 mail: " ++ user1Mail)
-      Console.log("user 2 mail: " ++ user2Mail)
-    }
-
-  | exception JsError(err) => Console.log2("Some error occurred", err)
-  }
-}
-```
-
-```js
-async function fetchData(param) {
-  var val;
-  var val$1;
-  try {
-    val = await GlobalAPI.fetchUserMail("user1");
-    val$1 = await GlobalAPI.fetchUserMail("user2");
-  }
-  catch (raw_err){
-    var err = Caml_js_exceptions.internalToOCamlException(raw_err);
-    if (err.RE_EXN_ID === "JsError") {
-      console.log("Some error occurred", err._1);
-      return ;
-    }
-    throw err;
-  }
-  console.log("user 1 mail: " + val);
-  console.log("user 2 mail: " + val$1);
-}
-```
-
-</CodeTab>
-
-## `await` multiple promises
-
-We can utilize the `Promise` module to handle multiple promises. E.g. let's use `Promise.all` to wait for multiple promises before continuing the program:
-
-```res
-let pauseReturn = (value, timeout) => {
-  Promise.make((resolve, _reject) => {
-    setTimeout(() => {
-      resolve(value)
-    }, timeout)->ignore
-  })
-}
-
-let logMultipleValues = async () => {
-  let promise1 = pauseReturn("value1", 2000)
-  let promise2 = pauseReturn("value2", 1200)
-  let promise3 = pauseReturn("value3", 500)
-
-  let all = await Promise.all([promise1, promise2, promise3])
-
-  switch all {
-  | [v1, v2, v3] => Console.log(`All values: ${v1}, ${v2}, ${v3}`)
-  | _ => Console.log("this should never happen")
-  }
-}
-```
-
-## JS Interop with `async` functions
-
-`async` / `await` practically works with any function that returns a `promise<'a>` value. Map your `promise` returning function via an `external`, and use it in an `async` function as usual.
-
-Here's a full example of using the MDN `fetch` API, using `async` / `await` to simulate a login:
-
-```res
-// A generic Response type for typing our fetch requests
-module Response = {
-  type t<'data>
-  @send external json: t<'data> => promise<'data> = "json"
-}
-
-// A binding to our globally available `fetch` function. `fetch` is a
-// standardized function to retrieve data from the network that is available in
-// all modern browsers.
-@val @scope("globalThis")
-external fetch: (
-  string,
-  'params,
-) => promise<Response.t<{"token": Nullable.t<string>, "error": Nullable.t<string>}>> =
-  "fetch"
-
-// We now use our asynchronous `fetch` function to simulate a login.
-// Note how we use `await` with regular functions returning a `promise`.
-let login = async (email: string, password: string) => {
-  let body = {
-    "email": email,
-    "password": password,
-  }
-
-  let params = {
-    "method": "POST",
-    "headers": {
-      "Content-Type": "application/json",
-    },
-    "body": Json.stringifyAny(body),
-  }
-
-  try {
-    let response = await fetch("https://reqres.in/api/login", params)
-    let data = await response->Response.json
-
-    switch Nullable.toOption(data["error"]) {
-    | Some(msg) => Error(msg)
-    | None =>
-      switch Nullable.toOption(data["token"]) {
-      | Some(token) => Ok(token)
-      | None => Error("Didn't return a token")
-      }
-    }
-  } catch {
-  | _ => Error("Unexpected network error occurred")
-  }
-}
-```
-
diff --git a/pages/docs/manual/v11.0.0/attribute.mdx b/pages/docs/manual/v11.0.0/attribute.mdx
deleted file mode 100644
index 32e9fad09..000000000
--- a/pages/docs/manual/v11.0.0/attribute.mdx
+++ /dev/null
@@ -1,90 +0,0 @@
----
-title: "Attribute (Decorator)"
-description: "Annotations in ReScript"
-canonical: "/docs/manual/v11.0.0/attribute"
----
-
-# Attribute (Decorator)
-
-Like many other languages, ReScript allows annotating a piece of code to express extra functionality. Here's an example:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@inline
-let mode = "dev"
-
-let mode2 = mode
-```
-```js
-var mode2 = "dev";
-```
-
-</CodeTab>
-
-The `@inline` annotation tells `mode`'s value to be inlined into its usage sites (see output). We call such annotation "attribute" (or "decorator" in JavaScript).
-
-An attribute starts with `@` and goes before the item it annotates. In the above example, it's hooked onto the let binding.
-
-## Usage
-
-> **Note:** In previous versions (< 8.3) all our interop related attributes started with a `bs.` prefix (`bs.module`, `bs.val`). Our formatter will automatically drop them in newer ReScript versions.
-
-You can put an attribute almost anywhere. You can even add extra data to them by using them visually like a function call. Here are a few famous attributes (explained in other sections):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@@warning("-27")
-
-
-@unboxed
-type a = Name(string)
-
-@val external message: string = "message"
-
-type student = {
-  age: int,
-  @as("aria-label") ariaLabel: string,
-}
-
-@deprecated
-let customDouble = foo => foo * 2
-
-@deprecated("Use SomeOther.customTriple instead")
-let customTriple = foo => foo * 3 
-```
-```js
-```
-
-</CodeTab>
-
-1. `@@warning("-27")` is a standalone attribute that annotates the entire file. Those attributes start with `@@`. Here, it carries the data `"-27"`. You can find a full list of all available warnings [here](./warning-numbers).
-2. `@unboxed` annotates the type definition.
-3. `@val` annotates the `external` statement.
-4. `@as("aria-label")` annotates the `ariaLabel` record field.
-5. `@deprecated` annotates the `customDouble` expression. This shows a warning while compiling telling consumers to not rely on this method long-term.
-6. `@deprecated("Use SomeOther.customTriple instead")` annotates the `customTriple` expression with a string to describe the reason for deprecation.
-
-For a list of all decorators and their usage, please refer to the [Syntax Lookup](/syntax-lookup) page.
-
-## Extension Point
-
-There's a second category of attributes, called "extension points" (a remnant term of our early systems):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-%raw("var a = 1")
-```
-```js
-var a = 1
-```
-
-</CodeTab>
-
-Extension points are attributes that don't _annotate_ an item; they _are_ the item. Usually they serve as placeholders for the compiler to implicitly substitute them with another item.
-
-Extension points start with `%`. A standalone extension point (akin to a standalone regular attribute) starts with `%%`.
-
-For a list of all extension points and their usage, please refer to the [Syntax Lookup](/syntax-lookup) page.
\ No newline at end of file
diff --git a/pages/docs/manual/v11.0.0/bind-to-global-js-values.mdx b/pages/docs/manual/v11.0.0/bind-to-global-js-values.mdx
deleted file mode 100644
index 6d1455f37..000000000
--- a/pages/docs/manual/v11.0.0/bind-to-global-js-values.mdx
+++ /dev/null
@@ -1,145 +0,0 @@
----
-title: "Bind to Global JS Values"
-description: "JS interop with global JS values in ReScript"
-canonical: "/docs/manual/v11.0.0/bind-to-global-js-values"
----
-
-# Bind to Global JS Values
-
-**First**, make sure the value you'd like to model doesn't already exist in our [provided API](api/core).
-
-Some JS values, like `setTimeout`, live in the global scope. You can bind to them like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external setTimeout: (unit => unit, int) => float = "setTimeout"
-@val external clearTimeout: float => unit = "clearTimeout"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-(We already provide `setTimeout`, `clearTimeout` and others in the [Core API](api/core) module).
-
-This binds to the JavaScript [`setTimeout`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrworkerGlobalScope/setTimeout) methods and the corresponding `clearTimeout`. The `external`'s type annotation specifies that `setTimeout`:
-
-- Takes a function that accepts `unit` and returns `unit` (which on the JS side turns into a function that accepts nothing and returns nothing aka `undefined`),
-- and an integer that specifies the duration before calling said function,
-- returns a number that is the timeout's ID. This number might be big, so we're modeling it as a float rather than the 32-bit int.
-
-### Tips & Tricks
-
-**The above isn't ideal**. See how `setTimeout` returns a `float` and `clearTimeout` accepts one. There's no guarantee that you're passing the float created by `setTimeout` into `clearTimeout`! For all we know, someone might pass it `Math.random()` into the latter.
-
-We're in a language with a great type system now! Let's leverage a popular feature to solve this problem: abstract types.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type timerId
-@val external setTimeout: (unit => unit, int) => timerId = "setTimeout"
-@val external clearTimeout: timerId => unit = "clearTimeout"
-
-let id = setTimeout(() => Console.log("hello"), 100)
-clearTimeout(id)
-```
-```js
-var id = setTimeout(function (param) {
-  console.log("hello");
-}, 100);
-
-clearTimeout(id);
-```
-
-</CodeTab>
-
-Clearly, `timerId` is a type that can only be created by `setTimeout`! Now we've guaranteed that `clearTimeout` _will_ be passed a valid ID. Whether it's a number under the hood is now a mere implementation detail.
-
-Since `external`s are inlined, we end up with JS output as readable as hand-written JS.
-
-## Global Modules
-
-If you want to bind to a value inside a global module, e.g. `Math.random`, attach a `scope` to your `val` external:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@scope("Math") @val external random: unit => float = "random"
-let someNumber = random()
-```
-```js
-var someNumber = Math.random();
-```
-
-</CodeTab>
-
-you can bind to an arbitrarily deep object by passing a tuple to `scope`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val @scope(("window", "location", "ancestorOrigins"))
-external length: int = "length"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-This binds to `window.location.ancestorOrigins.length`.
-
-## Special Global Values
-
-Global values like `__filename` and `__DEV__` don't always exist; you can't even model them as an `option`, since the mere act of referring to them in ReScript (then compiled into JS) would trigger the usual `Uncaught ReferenceError: __filename is not defined` error in e.g. the browser environment.
-
-For these troublesome global values, ReScript provides a special approach: `%external(a_single_identifier)`.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch %external(__DEV__) {
-| Some(_) => Console.log("dev mode")
-| None => Console.log("production mode")
-}
-```
-```js
-var match = typeof __DEV__ === "undefined" ? undefined : __DEV__;
-
-if (match !== undefined) {
-  console.log("dev mode");
-} else {
-  console.log("production mode");
-}
-```
-
-</CodeTab>
-
-That first line's `typeof` check won't trigger a JS ReferenceError.
-
-Another example:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch %external(__filename) {
-| Some(f) => Console.log(f)
-| None => Console.log("non-node environment")
-};
-```
-```js
-var match = typeof (__filename) === "undefined" ? undefined : (__filename);
-
-if (match !== undefined) {
-  console.log(match);
-} else {
-  console.log("non-node environment");
-}
-```
-
-</CodeTab>
-
-<!-- TODO: revamp this page. Not good. Tell to use globalThis["foo"], and look in our stdlib -->
diff --git a/pages/docs/manual/v11.0.0/bind-to-js-function.mdx b/pages/docs/manual/v11.0.0/bind-to-js-function.mdx
deleted file mode 100644
index f29c8abd8..000000000
--- a/pages/docs/manual/v11.0.0/bind-to-js-function.mdx
+++ /dev/null
@@ -1,490 +0,0 @@
----
-title: "Bind to JS Function"
-description: "JS interop with functions in ReScript"
-canonical: "/docs/manual/v11.0.0/bind-to-js-function"
----
-
-# Function
-
-Binding a JS function is like binding any other value:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// Import nodejs' path.dirname
-@module("path") external dirname: string => string = "dirname"
-let root = dirname("/User/github") // returns "User"
-```
-```js
-var Path = require("path");
-var root = Path.dirname("/User/github");
-```
-
-</CodeTab>
-
-We also expose a few special features, described below.
-
-## Labeled Arguments
-
-ReScript has [labeled arguments](function.md#labeled-arguments) (that can also be optional). These work on an `external` too! You'd use them to _fix_ a JS function's unclear usage. Assuming we're modeling this:
-
-```js
-// MyGame.js
-
-function draw(x, y, border) {
-   // suppose `border` is optional and defaults to false
-}
-draw(10, 20)
-draw(20, 20, true)
-```
-
-It'd be nice if on ReScript's side, we can bind & call `draw` while labeling things a bit:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("MyGame")
-external draw: (~x: int, ~y: int, ~border: bool=?) => unit = "draw"
-
-draw(~x=10, ~y=20, ~border=true)
-draw(~x=10, ~y=20)
-```
-```js
-var MyGame = require("MyGame");
-
-MyGame.draw(10, 20, true);
-MyGame.draw(10, 20, undefined);
-```
-
-</CodeTab>
-
-We've compiled to the same function, but now the usage is much clearer on the ReScript side thanks to labels!
-
-Note that you can freely reorder the labels on the ReScript side; they'll always correctly appear in their declaration order in the JavaScript output:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("MyGame")
-external draw: (~x: int, ~y: int, ~border: bool=?) => unit = "draw"
-
-draw(~x=10, ~y=20)
-draw(~y=20, ~x=10)
-```
-```js
-var MyGame = require("MyGame");
-
-MyGame.draw(10, 20, undefined);
-MyGame.draw(10, 20, undefined);
-```
-
-</CodeTab>
-
-## Object Method
-
-Functions attached to JS objects (other than JS modules) require a special way of binding to them, using `send`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type document // abstract type for a document object
-@send external getElementById: (document, string) => Dom.element = "getElementById"
-@val external doc: document = "document"
-
-let el = getElementById(doc, "myId")
-```
-```js
-var el = document.getElementById("myId");
-```
-
-</CodeTab>
-
-In a `send`, the object is always the first argument. Actual arguments of the method follow (this is a bit what modern OOP objects are really).
-
-### Chaining
-
-Ever used `foo().bar().baz()` chaining ("fluent api") in JS OOP? We can model that in ReScript too, through the [pipe operator](pipe.md).
-
-### Nested function call
-
-`@send` can also accept a `@scope(("itemOne","itemTwo"))` to access a function on a nested property.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-```res example
-type stripe
-
-@module("stripe") @new
-external make: string => stripe = "default"
-
-type createSession = {}
-
-type sessionResult
-
-@send
-@scope(("checkout", "sessions"))
-external createCheckoutSession: (stripe, createSession) => 
-  Promise.t<sessionResult> = "create"
-
-let stripe = make("sk_...")
-let session = stripe->createCheckoutSession({})
-```
-```js
-import Stripe from "stripe";
-
-var stripe = new Stripe("sk_...");
-var session = stripe.checkout.sessions.create({});
-```
-</CodeTab>
-
-## Variadic Function Arguments
-
-You might have JS functions that take an arbitrary amount of arguments. ReScript supports modeling those, under the condition that the arbitrary arguments part is homogenous (aka of the same type). If so, add `variadic` to your `external`.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("path") @variadic
-external join: array<string> => string = "join"
-
-let v = join(["a", "b"])
-```
-```js
-var Path = require("path");
-var v = Path.join("a", "b");
-```
-
-</CodeTab>
-
-`module` will be explained in [Import from/Export to JS](import-from-export-to-js.md).
-
-## Modeling Polymorphic Function
-
-Apart from the above special-case, JS functions in general are often arbitrarily overloaded in terms of argument types and number. How would you bind to those?
-
-### Trick 1: Multiple `external`s
-
-If you can exhaustively enumerate the many forms an overloaded JS function can take, simply bind to each differently:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("MyGame") external drawCat: unit => unit = "draw"
-@module("MyGame") external drawDog: (~giveName: string) => unit = "draw"
-@module("MyGame") external draw: (string, ~useRandomAnimal: bool) => unit = "draw"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Note how all three externals bind to the same JS function, `draw`.
-
-### Trick 2: Polymorphic Variant + `unwrap`
-
-If you have the irresistible urge of saying "if only this JS function argument was a variant instead of informally being either `string` or `int`", then good news: we do provide such `external` features through annotating a parameter as a polymorphic variant! Assuming you have the following JS function you'd like to bind to:
-
-```js
-function padLeft(value, padding) {
-  if (typeof padding === "number") {
-    return Array(padding + 1).join(" ") + value;
-  }
-  if (typeof padding === "string") {
-    return padding + value;
-  }
-  throw new Error(`Expected string or number, got '${padding}'.`);
-}
-```
-
-Here, `padding` is really conceptually a variant. Let's model it as such.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val
-external padLeft: (
-  string,
-  @unwrap [
-    | #Str(string)
-    | #Int(int)
-  ])
-  => string = "padLeft"
-padLeft("Hello World", #Int(4))
-padLeft("Hello World", #Str("Message from ReScript: "))
-```
-```js
-padLeft("Hello World", 4);
-padLeft("Hello World", "Message from ReScript: ");
-```
-
-</CodeTab>
-
-Obviously, the JS side couldn't have an argument that's a polymorphic variant! But here, we're just piggy backing on poly variants' type checking and syntax. The secret is the `@unwrap` annotation on the type. It strips the variant constructors and compile to just the payload's value. See the output.
-
-## Constrain Arguments Better
-
-Consider the Node `fs.readFileSync`'s second argument. It can take a string, but really only a defined set: `"ascii"`, `"utf8"`, etc. You can still bind it as a string, but we can use poly variants + `string` to ensure that our usage's more correct:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("fs")
-external readFileSync: (
-  ~name: string,
-  @string [
-    | #utf8
-    | @as("ascii") #useAscii
-  ],
-) => string = "readFileSync"
-
-readFileSync(~name="xx.txt", #useAscii)
-```
-```js
-var Fs = require("fs");
-Fs.readFileSync("xx.txt", "ascii");
-```
-
-</CodeTab>
-
-- Attaching `@string` to the whole poly variant type makes its constructor compile to a string of the same name.
-- Attaching a `@as("bla")` to a constructor lets you customize the final string.
-
-And now, passing something like `"myOwnUnicode"` or other variant constructor names to `readFileSync` would correctly error.
-
-Aside from string, you can also compile an argument to an int, using `int` instead of `string` in a similar way:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val
-external testIntType: (
-  @int [
-    | #onClosed
-    | @as(20) #onOpen
-    | #inBinary
-  ])
-  => int = "testIntType"
-testIntType(#inBinary)
-```
-```js
-testIntType(21);
-```
-
-</CodeTab>
-
-`onClosed` compiles to `0`, `onOpen` to `20` and `inBinary` to **`21`**.
-
-## Unknown for type safety
-
-It is best practice to inspect data received from untrusted external functions to ensure it contains what you expect. This helps avoid run-time crashes and unexpected behavior. If you're certain about what an external function returns, simply assert the return value as `string` or `array<int>` or whatever you want it to be. Otherwise use `unknown`. The ReScript type system will prevent you from using an `unknown` until you first inspect it and "convert" it using JSON parsing utilities or similar tools.
-
-Consider the example below of two external functions that access the value of a property on a JavaScript object. `getPropertyUnsafe` returns an `'a`, which means "anything you want it to be." ReScript allows you to use this value as a `string` or `array` or any other type. Quite convenient! But if the property is missing or contains something unexpected, your code might break. You can make the binding more safe by changing `'a` to `string` or `option<'a>`, but this doesn't completely eliminate the problem.
-
-The `getPropertySafe` function returns an `unknown`, which could be `null` or a `string` or anything else. But ReScript prevents you from using this value inappropriately until it has been safely parsed.
-
-```res example
-@get_index external getPropertyUnsafe: ({..}, string) => 'a = ""
-@get_index external getPropertySafe: ({..}, string) => unknown = ""
-
-let person = {"name": "Bob", "age": 12}
-
-let greeting1 = "Hello, " ++ getPropertyUnsafe(person, "name") // works (this time!)
-// let greeting2 = "Hello, " ++ getPropertySafe(person, "name") // syntax error
-```
-
-## Special-case: Event Listeners
-
-One last trick with polymorphic variants:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type readline
-
-@send
-external on: (
-    readline,
-    @string [
-      | #close(unit => unit)
-      | #line(string => unit)
-    ]
-  )
-  => readline = "on"
-
-let register = rl =>
-  rl
-  ->on(#close(event => ()))
-  ->on(#line(line => Console.log(line)));
-```
-```js
-function register(rl) {
-  return rl
-    .on("close", function($$event) {})
-    .on("line", function(line) {
-      console.log(line);
-    });
-}
-```
-
-</CodeTab>
-
-<!-- TODO: GADT phantom type -->
-
-## Fixed Arguments
-
-Sometimes it's convenient to bind to a function using an `external`, while passing predetermined argument values to the JS function:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val
-external processOnExit: (
-  @as("exit") _,
-  int => unit
-) => unit = "process.on"
-
-processOnExit(exitCode =>
-  Console.log("error code: " ++ Int.toString(exitCode))
-);
-```
-```js
-process.on("exit", function (exitCode) {
-  console.log("error code: " + exitCode.toString());
-});
-```
-
-</CodeTab>
-
-The `@as("exit")` and the placeholder `_` argument together indicates that you want the first argument to compile to the string `"exit"`. You can also use any JSON literal with `as`: `` @as(json`true`) ``, `` @as(json`{"name": "John"}`) ``, etc.
-
-## Ignore arguments
-
-You can also explicitly "hide" `external` function parameters in the JS output, which may be useful if you want to add type constraints to other parameters without impacting the JS side:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@val external doSomething: (@ignore 'a, 'a) => unit = "doSomething"
-
-doSomething("this only shows up in ReScript code", "test")
-```
-
-```js
-doSomething("test");
-```
-
-</CodeTab>
-
-**Note:** It's a pretty niche feature, mostly used to map to polymorphic JS APIs.
-
-## Modeling `this`-based Callbacks
-
-Many JS libraries have callbacks which rely on this (the source), for example:
-
-```js
-x.onload = function(v) {
-  console.log(this.response + v)
-}
-```
-
-Here, `this` would point to `x` (actually, it depends on how `onload` is called, but we digress). It's not correct to declare `x.onload` of type `(. unit) -> unit`. Instead, we introduced a special attribute, `this`, which allows us to type `x` as so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type x
-@val external x: x = "x"
-@set external setOnload: (x, @this ((x, int) => unit)) => unit = "onload"
-@get external resp: x => int = "response"
-setOnload(x, @this (o, v) => Console.log(resp(o) + v))
-```
-```js
-x.onload = function (v) {
-  var o = this;
-  console.log((o.response + v) | 0);
-};
-```
-
-</CodeTab>
-
-`@this` reserves the first parameter for the `this` value, and for arity of 0, there is no need for a redundant `unit` type.
-
-## Function Nullable Return Value Wrapping
-
-For JS functions that return a value that can also be `undefined` or `null`, we provide `@return(...)`. To automatically convert that value to an `option` type (recall that ReScript `option` type's `None` value only compiles to `undefined` and not `null`).
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type element
-type dom
-
-@send @return(nullable)
-external getElementById: (dom, string) => option<element> = "getElementById"
-
-let test = dom => {
-  let elem = dom->(getElementById("haha"))
-  switch (elem) {
-  | None => 1
-  | Some(_ui) => 2
-  }
-}
-```
-```js
-function test(dom) {
-  var elem = dom.getElementById("haha");
-  if (elem == null) {
-    return 1;
-  } else {
-    console.log(elem);
-    return 2;
-  }
-}
-
-```
-
-</CodeTab>
-
-`return(nullable)` attribute will automatically convert `null` and `undefined` to `option` type.
-
-Currently 4 directives are supported: `null_to_opt`, `undefined_to_opt`, `nullable` and `identity`.
-
-<!-- When the return type is unit: the compiler will append its return value with an OCaml unit literal to make sure it does return unit. Its main purpose is to make the user consume FFI in idiomatic OCaml code, the cost is very very small and the compiler will do smart optimizations to remove it when the returned value is not used (mostly likely). -->
-
-`identity` will make sure that compiler will do nothing about the returned value. It is rarely used, but introduced here for debugging purpose.
-
-## Tagged template functions
-
-**Since 11.1**
-
-**Experimental** You can easily bind to [JS tagged template functions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#tagged_templates).
-Tag functions in JS expect as input an array of strings and variadic parameters for the arguments of the interpolation.
-To bind to those functions in ReScript, the binding signature must have two arrays as arguments,
-the first one being an array of strings and the second can be an array of anything.
-You add the `@taggedTemplate` annotation and you're good to go!
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// see https://bun.sh/docs/runtime/shell
-type result = {exitCode: int}
-@module("bun") @taggedTemplate
-external sh: (array<string>, array<string>) => promise<result> = "$"
-
-let filename = "index.res"
-let result = await sh`ls ${filename}`
-```
-
-```js 
-import * as $$Bun from "bun";
-var filename = "index.res";
-var result = await $$Bun.$`ls ${filename}`;
-```
-
-</CodeTab>
-
-Notice that it gets compiled to tagged template literals in JS, which allows
-to use JS tools that only work on the literals and not by calling directly the tag function.
-
-There are plenty of useful JS tools you can bind to, like [`gql`](https://github.com/apollographql/graphql-tag),
-[`sql`](https://github.com/porsager/postgres), [`css`](https://github.com/mayank99/ecsstatic) and a lot others!
diff --git a/pages/docs/manual/v11.0.0/bind-to-js-object.mdx b/pages/docs/manual/v11.0.0/bind-to-js-object.mdx
deleted file mode 100644
index 17974feb4..000000000
--- a/pages/docs/manual/v11.0.0/bind-to-js-object.mdx
+++ /dev/null
@@ -1,197 +0,0 @@
----
-title: "Bind to JS Object"
-description: "Interop with JS objects in ReScript"
-canonical: "/docs/manual/v11.0.0/bind-to-js-object"
----
-
-# Bind to JS Object
-
-JavaScript objects are a combination of several use-cases:
-
-- As a "record" or "struct" in other languages (like ReScript and C).
-- As a hash map.
-- As a class.
-- As a module to import/export.
-
-ReScript cleanly separates the binding methods for JS object based on these 4 use-cases. This page documents the first three. Binding to JS module objects is described in the [Import from/Export to JS](import-from-export-to-js.md) section.
-
-<!-- TODO: mention scope here too? -->
-
-## Bind to Record-like JS Objects
-
-### Bind Using ReScript Record
-
-If your JavaScript object has fixed fields, then it's conceptually like a ReScript record. Since a ReScript record compiles to a clean JavaScript object, you can definitely type a JS object as a ReScript record!
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type person = {
-  name: string,
-  friends: array<string>,
-  age: int,
-}
-
-@module("MySchool") external john: person = "john"
-
-let johnName = john.name
-```
-```js
-var MySchool = require("MySchool");
-
-var johnName = MySchool.john.name;
-```
-
-</CodeTab>
-
-External is documented [here](external.md). `@module` is documented [here](import-from-export-to-js.md).
-
-If you want or need to use different field names on the ReScript and the JavaScript side, you can use the `@as` decorator:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type action = {
-  @as("type") type_: string
-}
-
-let action = {type_: "ADD_USER"}
-```
-```js
-var action = {
-  type: "ADD_USER"
-};
-```
-
-</CodeTab>
-
-This is useful to map to JavaScript attribute names that cannot be expressed in ReScript (such as keywords).
-
-It is also possible to map a ReScript record to a JavaScript array by passing indices to the `@as` decorator:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type t = {
-  @as("0") foo: int,
-  @as("1") bar: string,
-}
-
-let value = {foo: 7, bar: "baz"}
-```
-
-```js
-var value = [
-  7,
-  "baz"
-];
-```
-
-</CodeTab>
-
-
-### Bind Using ReScript Object
-
-Alternatively, you can use [ReScript object](object.md) to model a JS object too:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type person = {
-  "name": string,
-  "friends": array<string>,
-  "age": int,
-}
-
-@module("MySchool") external john: person = "john"
-
-let johnName = john["name"]
-```
-```js
-var MySchool = require("MySchool");
-
-var johnName = MySchool.john.name;
-```
-
-</CodeTab>
-
-### Bind Using Special Getter and Setter Attributes
-
-Alternatively, you can use `get` and `set` to bind to individual fields of a JS object:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type textarea
-@set external setName: (textarea, string) => unit = "name"
-@get external getName: textarea => string = "name"
-```
-```js
-```
-
-</CodeTab>
-
-You can also use `get_index` and `set_index` to access a dynamic property or an index:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type t
-@new external create: int => t = "Int32Array"
-@get_index external get: (t, int) => int = ""
-@set_index external set: (t, int, int) => unit = ""
-
-let i32arr = create(3)
-i32arr->set(0, 42)
-Console.log(i32arr->get(0))
-```
-```js
-var i32arr = new Int32Array(3);
-i32arr[0] = 42;
-console.log(i32arr[0]);
-```
-
-</CodeTab>
-
-## Bind to Hash Map-like JS Object
-
-If your JavaScript object:
-
-- might or might not add/remove keys
-- contains only values that are of the same type
-
-Then it's not really an object, it's a hash map. Use [Dict](api/core/dict), which contains operations like `get`, `set`, etc. and cleanly compiles to a JavaScript object still.
-
-## Bind to a JS Object That's a Class
-
-Use `new` to emulate e.g. `new Date()`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type t
-@new external createDate: unit => t = "Date"
-
-let date = createDate()
-```
-```js
-var date = new Date();
-```
-
-</CodeTab>
-
-You can chain `new` and `module` if the JS module you're importing is itself a class:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type t
-@new @module external book: unit => t = "Book"
-let myBook = book()
-```
-```js
-var Book = require("Book");
-var myBook = new Book();
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v11.0.0/browser-support-polyfills.mdx b/pages/docs/manual/v11.0.0/browser-support-polyfills.mdx
deleted file mode 100644
index 5cd65a93f..000000000
--- a/pages/docs/manual/v11.0.0/browser-support-polyfills.mdx
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: "Browser Support & Polyfills"
-description: "Note on browser support in ReScript"
-canonical: "/docs/manual/v11.0.0/browser-support-polyfills"
----
-
-# Browser Support & Polyfills
-
-ReScript compiles to JavaScript **ES5**, with the exception of optionally allowing to compile to ES6's module import & export.
-
-For [old browsers](https://caniuse.com/#search=typed%20array), you also need to polyfill TypedArray. The following standard library functions require it:
-
-- `Int64.float_of_bits`
-- `Int64.bits_of_float`
-- `Int32.float_of_bits`
-- `Int32.bits_of_float`
-
-If you don't use these functions, you're fine. Otherwise, it'll be a runtime failure.
diff --git a/pages/docs/manual/v11.0.0/build-configuration-schema.mdx b/pages/docs/manual/v11.0.0/build-configuration-schema.mdx
deleted file mode 100644
index af0f6d1f5..000000000
--- a/pages/docs/manual/v11.0.0/build-configuration-schema.mdx
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: "Configuration Schema"
-metaTitle: "Build System Configuration Schema"
-description: "Schema exploration widget for the ReScript configuration file"
-canonical: "/docs/manual/v11.0.0/build-configuration-schema"
----
-
-import dynamic from "next/dynamic";
-
-export const Docson = dynamic(
-  () =>
-    import("src/components/Docson").then((comp) => {
-      return comp.make;
-    }),
-  {
-    ssr: false,
-    loading: () => <div> Loading... </div>,
-  }
-);
-
-export default function BuildConfigurationSchemaPage() {
-  return <Docson tag="master" />;
-}
diff --git a/pages/docs/manual/v11.0.0/build-configuration.mdx b/pages/docs/manual/v11.0.0/build-configuration.mdx
deleted file mode 100644
index fe83a9f8c..000000000
--- a/pages/docs/manual/v11.0.0/build-configuration.mdx
+++ /dev/null
@@ -1,245 +0,0 @@
----
-title: "Configuration"
-metaTitle: "Build System Configuration"
-description: "Details about the configuration of the ReScript build system (rescript.json)"
-canonical: "/docs/manual/v11.0.0/build-configuration"
----
-
-# Configuration
-
-`rescript.json` (or `bsconfig.json` in versions prior ReScript 11) is the single, mandatory build meta file needed for `rescript`.
-
-**The complete configuration schema is [here](./build-configuration-schema)**. We'll _non-exhaustively_ highlight the important parts in prose below.
-
-## name, namespace
-
-`name` is the name of the library, used as its "namespace". You can activate namespacing through `"namespace": true` in your `rescript.json`. Namespacing is almost **mandatory**; we haven't turned it on by default yet to preserve backward-compatibility.
-
-**Explanation**: by default, your files, once used as a third-party dependency, are available globally to the consumer. E.g. if you have a `Util.res` and the consumer also has a file of the same name, they will clash. Turning on `namespace` avoids this by wrapping all your own project's files into an extra module layer; instead of a global `Util` module, the consumer will see you as `MyProject.Util`. **The namespacing affects your consumers, not yourself**.
-
-Aka, in ReScript, "namespace" is just a fancy term for an auto-generated module that wraps all your project's files (efficiently and correctly, of course!) for third-party consumption.
-
-We don't do folder-level namespacing for your own project; all your own file names must be unique. This is a constraint that enables several features such as fast search and easier project reorganization.
-
-**Note**: the `rescript.json` `name` should be the same as the `package.json` `name`, to avoid confusing corner-cases. However, this means that you can't use a camelCased names such as `MyProject`, since `package.json` and npm forbid you to do so (some file systems are case-insensitive). To have the namespace/module as `MyProject`, write `"name": "my-project"`. ReScript will turn that into the camelCased name correctly.
-
-**Note on custom namespacing**: if for some reason, you need a namespace that is different from what your `name` will produce, you can directly send a string to the `namespace` option. For example, if your package is a binding named `bs-some-thing`, you can use `"namespace": "some-thing"` to get `SomeThing` namespace instead of `BsSomeThing`.
-
-## sources
-
-Your source files need to be specified explicitly (we don't want to accidentally drill down into some unrelated directories). Examples:
-
-```json
-{
-  "sources": ["src", "examples"]
-}
-```
-
-```json
-{
-  "sources": {
-    "dir": "src",
-    "subdirs": ["page"]
-  }
-}
-```
-
-```json
-{
-  "sources": [
-    "examples",
-    {
-      "dir": "src",
-      "subdirs": true // recursively builds every subdirectory
-    }
-  ]
-}
-```
-
-You can mark your directories as dev-only (for e.g. tests). These won't be built and exposed to third-parties, or even to other "dev" directories in the same project:
-
-```json
-{
-  "sources": {
-    "dir": "test",
-    "type": "dev"
-  }
-}
-```
-
-You can also explicitly allow which modules can be seen from outside. This feature is especially useful for library authors who want to have a single entry point for their users.  
-Here, the file `src/MyMainModule.res` is exposed to outside consumers, while all other files are private.
-
-```json
-{
-  "sources": {
-    "dir": "src",
-    "public": ["MyMainModule"]
-  }
-}
-```
-
-## bs-dependencies, bs-dev-dependencies
-
-List of ReScript dependencies. Just like `package.json`'s dependencies, they'll be searched in `node_modules`.
-
-Note that only sources marked with `"type":"dev"` will be able to resolve modules from `bs-dev-dependencies`.
-
-## pinned-dependencies
-
-**Since 8.4**: List of pinned dependencies. A pinned dependency will always be rebuilt whenever you build a toplevel package (e.g. your main app) with `rescript`.
-
-This is useful for working on multiple independent ReScript packages simultaneously. More usage details can be found in our dedicated [pinned dependencies](./build-pinned-dependencies) page.
-
-## external-stdlib
-
-**Since 9.0**: This setting allows depending on an externally built stdlib package (instead of a locally built stdlib runtime). Useful for shipping packages that are only consumed in JS or TS without any dependencies to the ReScript development toolchain.
-
-More details can be found on our [external stdlib](./build-external-stdlib) page.
-
-## js-post-build
-
-Hook that's invoked every time a file is recompiled. Good for JS build system interop, but please use it **sparingly**. Calling your custom command for every recompiled file slows down your build and worsens the building experience for even third-party users of your lib.
-
-Example:
-
-```json
-{
-  "js-post-build": {
-    "cmd": "/path/to/node ../../postProcessTheFile.js"
-  }
-}
-```
-
-Note that the path resolution for the command (`node` in this case) is done so:
-
-- `/myCommand` is resolved into `/myCommand`
-- `package/myCommand` is resolved into `node_modules/package/myCommand`
-- `./myCommand` is resolved into `myProjectRoot/myCommand`
-- `myCommand` is just called as `myCommand`, aka a globally available executable. But note that ReScript doesn't read into your shell's environment, so if you put e.g. `node`, it won't find it unless you specify an absolute path. Alternatively, add `#!/usr/local/bin/node` to the top of your script to directly call it without prepending `node`.
-
-The command itself is called from inside `lib/bs`.
-
-## package-specs
-
-Output to either CommonJS (the default) or JavaScript module. Example:
-
-```json
-{
-  "package-specs": {
-    "module": "commonjs",
-    "in-source": true
-  }
-}
-```
-
-- `"module": "commonjs"` generates output as CommonJS format.
-- `"module": "esmodule"` generates output as JavaScript module format. Will be default value in next major.
-- `"in-source": true` generates output alongside source files. If you omit it, it'll generate the artifacts into `lib/js`. The output directory is not configurable otherwise.
-
-This configuration only applies to you, when you develop the project. When the project is used as a third-party library, the consumer's own `rescript.json` `package-specs` overrides the configuration here, logically.
-
-## suffix
-
-**Since 11.0**: The suffix can now be freely chosen. However, we still suggest you stick to the convention and use
-one of the following:
-
-- `".js`
-- `".mjs"`
-- `".cjs"`
-- `".res.js"`
-- `".res.mjs"`
-- `".res.cjs"`
-
-### Design Decisions
-
-Generating JS files with the `.res.js` suffix means that, on the JS side, you can do `const myReScriptFile = require('./TheFile.res.js')`. The benefits:
-
-- It's immediately clear that we're dealing with a generated JS file here.
-- It avoids clashes with a potential `TheFile.js` file in the same folder.
-- It avoids the need of using a build system loader for ReScript files. This + in-source build means integrating a ReScript project into your pure JS codebase **basically doesn't touch anything in your build pipeline at all**.
-
-## uncurried
-
-**Since 11.0**: While we strongly encourage all users to use uncurried mode, it is still possible to opt out. Just set `"uncurried"` to `false` to get the old behavior back:
-
-```json
-{
-  "uncurried": false
-}
-```
-
-More details can be found in the [blogpost about "Uncurried Mode"](/blog/uncurried-mode).
-
-## warnings
-
-Selectively turn on/off certain warnings and/or turn them into hard errors. Example:
-
-```json
-{
-  "warnings": {
-    "number": "-44-102",
-    "error": "+5"
-  }
-}
-```
-
-Turn off warning `44` and `102` (polymorphic comparison). Turn warning `5` (partial application whose result has function type and is ignored) into a hard error.
-
-The warning numbers are shown in the build output when they're triggered. See [Warning Numbers](./warning-numbers) for the complete list.
-
-## bsc-flags
-
-Extra flags to pass to the compiler. For advanced usages.
-
-- `-open ABC` opens the module `ABC` for each file in the project. `ABC` can either be a dependency, namespaced project or local module of the current project.
-
-## gentypeconfig
-
-To enable genType, set `"gentypeconfig"` at top level in the project's `rescript.json`.
-
-```json
-{
-  "gentypeconfig": {
-    "module": "esmodule",
-    "moduleResolution": "node",
-    "generatedFileExtension": ".gen.tsx",
-    "debug": {
-      "all": false,
-      "basic": false
-    }
-  }
-}
-```
-
-`generatedFileExtension`: File extension used for genType generated files (defaults to `".gen.tsx"`)
-
-`module`: Module format used for the generated `*.gen.tsx` files (supports `"esmodule"` and `"commonjs"`)
-
-`moduleResolution`: Module resolution strategy used in genType outputs. This may be required for compatibility with TypeScript projects. Specify the value as the same in `tsconfig.json`.
-
-- `"node"`(default): Drop extensions in import paths.
-- `"node16"`: Use TS output's extension. This provides compatibility with projects using `"moduleResolution": "node16"` and ES Modules.
-- `"bundler"`: Use TS input's extension. This provides compatibility with projects using `"moduleResolution": "bundler"` and ES Modules. This also requires TS v5.0+ and `compilerOptions.allowImportingTsExtensions` to `true`
-
-`debug`: Enable debug logs.
-
-### Deprecated options
-
-`language`: the `language` setting is not required from compiler v10.1.
-
-`shims`: Required only if one needs to export certain basic ReScript data types to JS when one cannot modify the sources to add annotations (e.g. exporting ReScript lists), and if the types are not first-classed in genType.
-
-## Environment Variables
-
-We heavily disrecommend the usage of environment variables, but for certain cases, they're justified.
-
-### Error Output Coloring: `NINJA_ANSI_FORCED`
-
-This is mostly for other programmatic usage of `rescript` where outputting colors is not desired.
-
-When `NINJA_ANSI_FORCED` is set to `1`: `rescript` produces color.
-When `NINJA_ANSI_FORCED` is set to `0`: `rescript` doesn't produce color.
-When `NINJA_ANSI_FORCED` is not set: `rescript` might or might not produce color, depending on a smart detection of where it's outputted.
-
-> Note that the underlying compiler will always be passed `-color always`. See more details in [this issue](https://github.com/rescript-lang/rescript/issues/2984#issuecomment-410669163).
diff --git a/pages/docs/manual/v11.0.0/build-external-stdlib.mdx b/pages/docs/manual/v11.0.0/build-external-stdlib.mdx
deleted file mode 100644
index 3ead7e802..000000000
--- a/pages/docs/manual/v11.0.0/build-external-stdlib.mdx
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: "External Stdlib"
-metaTitle: "External Stdlib"
-description: "Configuring an external ReScript stdlib package"
-canonical: "/docs/manual/v11.0.0/build-external-stdlib"
----
-
-# External Stdlib
-
-**Since 9.0**
-
-Your ReScript project depends on the `rescript` package as a [`devDependency`](https://docs.npmjs.com/specifying-dependencies-and-devdependencies-in-a-package-json-file), which includes our compiler, build system and runtime like `Belt`. However, you had to move it to `dependency` in `package.json` if you publish your code:
-- To Docker or other low-storage deployment devices.
-- For pure JS/TS consumers who probably won't install `rescript` in their own project.
-
-In these cases, the size or mere presence of `rescript` can be troublesome, since it includes not just our necessary runtime like `Belt`, but also our compiler and build system.
-
-To solve that, we now publish our runtime as a standalone package at [`@rescript/std`](https://www.npmjs.com/package/@rescript/std), whose versions mirror `rescript`'s. Now you can keep `rescript` as a `devDependency` and have only `@rescript/std` as your runtime `dependency`.
-
-**This is an advanced feature**. Please only use it in the aforementioned scenarios. If you already use a JS bundler with dead code elimination, you might not need this feature.
-
-## Configuration
-
-Say you want to publish a JS-only ReScript 9.0 library. Install the packages like this:
-
-```sh
-npm install rescript@11.0.1 --save-dev
-npm install @rescript/std@11.0.1
-```
-
-Then add this to `rescript.json`:
-
-```json
-{
-  // ...
-  "external-stdlib" : "@rescript/std"
-}
-```
-
-Now the compiled JS code will import using the path defined by `external-stdlib`. Check the JS output tab:
-
-<CodeTab labels={["ReScript", "JS output"]}>
-
-```res
-Array.forEach([1, 2, 3], num => Console.log(num))
-```
-
-```js
-// Note the require path starting with "@rescript/std".
-var Belt_Array = require("@rescript/std/lib/js/belt_Array.js");
-
-Belt_Array.forEach([1, 2, 3], function (num) {
-  console.log(num);
-});
-```
-
-</CodeTab>
-
-**Make sure the version number of `rescript` and `@rescript/std` match in your `package.json`** to avoid running into runtime issues due to mismatching stdlib assumptions.
diff --git a/pages/docs/manual/v11.0.0/build-overview.mdx b/pages/docs/manual/v11.0.0/build-overview.mdx
deleted file mode 100644
index f638ebc51..000000000
--- a/pages/docs/manual/v11.0.0/build-overview.mdx
+++ /dev/null
@@ -1,83 +0,0 @@
----
-title: "Overview"
-metaTitle: "Build System Overview"
-description: "Documentation about the ReScript build system and its toolchain"
-canonical: "/docs/manual/v11.0.0/build-overview"
----
-
-# Build System Overview
-
-ReScript comes with a build system, [`rescript`](https://www.npmjs.com/package/rescript), that's fast, lean and used as the authoritative build system of the community.
-
-Every ReScript project needs a build description file, `rescript.json`.
-
-## Options
-
-See `rescript help`:
-
-```
-❯ rescript help
-Usage: rescript <options> <subcommand>
-
-`rescript` is equivalent to `rescript build`
-
-Options:
-  -v, -version  display version number
-  -h, -help     display help
-
-Subcommands:
-  build
-  clean
-  format
-  convert
-  dump
-  help
-
-Run `rescript <subcommand> -h` for subcommand help. Examples:
-  rescript build -h
-  rescript format -h
-```
-
-## Build Project
-
-Each build will create build artifacts from your project's source files.
-
-**To build a project (including its dependencies / pinned-dependencies)**, run:
-
-```sh
-rescript
-```
-
-Which is an alias for `rescript build`.
-
-To keep a build watcher, run:
-
-```sh
-rescript -w
-```
-
-Any new file change will be picked up and the build will re-run.
-
-**Note**: third-party libraries (in `node_modules`, or via `pinned-dependencies`) aren't watched, as doing so may exceed the node.js watcher count limit.
-
-**Note 2**: In case you want to set up a project in a JS-monorepo-esque approach (`npm` and `yarn` workspaces) where changes in your sub packages should be noticed by the build, you will need to define pinned dependencies in your main project's `rescript.json`. More details [here](./build-pinned-dependencies).
-
-## Clean Project
-
-If you ever get into a stale build for edge-case reasons, use:
-
-```sh
-rescript clean
-```
-
-## Compile with stricter errors in CI
-
-**Since 11.1**
-
-You may want to compile your project with stricter rules for production, than when developing. With the `-warn-error` build flag, this can easily be done, for instance in a continuous integration script. E.g.:
-
-```sh
-rescript -warn-error +110
-```
-
-Here, warning number 110, which is triggered when a [`%todo`](/syntax-lookup#todo) has been found, gets promoted to an error. The full list of warning numbers can be found [here](/docs/manual/latest/warning-numbers).
diff --git a/pages/docs/manual/v11.0.0/build-performance.mdx b/pages/docs/manual/v11.0.0/build-performance.mdx
deleted file mode 100644
index cf04a3dfc..000000000
--- a/pages/docs/manual/v11.0.0/build-performance.mdx
+++ /dev/null
@@ -1,89 +0,0 @@
----
-title: "Performance"
-metaTitle: "Build Performance"
-description: "ReScript build performance and measuring tools"
-canonical: "/docs/manual/v11.0.0/build-performance"
----
-
-# Build Performance
-
-ReScript considers performance at install time, build time and run time as a serious feature; it's one of those things you don't notice until you realize it's missing.
-
-## Profile Your Build
-
-Sometime your build can be slow due to some confused infra setups. We provide an interactive visualization of your build's performance via `bstracing`:
-
-```sh
-./node_modules/.bin/bstracing
-```
-
-Run the above command at your ReScript project's root; it'll spit out a JSON file you can drag and drop into `chrome://tracing`.
-
-import Image from "src/components/Image";
-
-<Image
-  withShadow={true}
-  src="/static/img/bstracing.png"
-  caption="Screenshot of bstracing result"
-/>
-
-## Under the Hood
-
-ReScript itself uses a build system under the hood, called [Ninja](https://ninja-build.org). Ninja is like Make, but cross-platform, minimal, focuses on perf and destined to be more of a low-level building block than a full-blown build system. In this regard, Ninja's a great implementation detail for `rescript`.
-
-ReScript reads into `rescript.json` and generates the Ninja build file in `lib/bs`. The file contains the low-level compiler commands, namespacing rules, intermediate artifacts generation & others. It then runs `ninja` for the actual build.
-
-## The JS Wrapper
-
-`rescript` itself is a Node.js wrapper which takes care of some miscellaneous tasks, plus the watcher. The lower-level, watcher-less, fast native `rescript` is called `rescript.exe`. It's located at `node_modules/rescript/{your-platform}/rescript.exe`.
-
-If you don't need the watcher, you can run said `rescript.exe`. This side-steps Node.js' long startup time, which can be in the order of `100ms`. Our editor plugin finds and uses this native `rescript.exe` for better performance.
-
-## Numbers
-
-Raw `rescript.exe` build on a small project should be around `70ms`. This doubles when you use the JS `rescript` wrapper which comes with a watcher, which is practically faster since you don't manually run the build at every change (though you should opt for the raw `rescript.exe` for programmatic usage, e.g. inserting rescript into your existing JS build pipeline).
-
-No-op build (when no file's changed) should be around `15ms`. Incremental rebuild (described soon) of a single file in a project is around `70ms` too.
-
-Cleaning the artifacts should be instantaneous.
-
-### Extreme Test
-
-We've stress-tested `rescript.exe` on a big project of 10,000 files (2 directories, 5000 files each, first 5000 no dependencies, last 5000 10 dependencies on files from the former directory) using https://github.com/rescript-lang/build-benchmark, on a Retina Macbook Pro Early 2015 (3.1 GHz Intel Core i7).
-
-<!-- TODO: better repro -->
-
-- No-op build of 10k files: `800ms` (the minimum amount of time required to check the mtimes of 10k files).
-- Clean build: \<3 minutes.
-- Incremental build: depends on the number of the dependents of the file. No dependent means `1s`.
-
-### Stability
-
-`rescript` is a file-based build system. We don't do in-memory build, even if that speeds up the build a lot. In-memory builds risk memory leaks, out-of-memory errors, corrupt halfway build and others. Our watcher mode stays open for days or months with no leak.
-
-The watcher is also just a thin file watcher that calls `rescript.exe`. We don't like babysitting daemon processes.
-
-## Incrementality & Correctness
-
-ReScript doesn't take whole seconds to run every time. The bulk of the build performance comes from incremental build, aka re-building a previously built project when a few files changed.
-
-In short, thanks to our compiler and the build system's architecture, we're able to **only build what's needed**. E.g. if `MyFile.res` isn't changed, then it's not recompiled. You can roughly emulate such incrementalism in languages like JavaScript, but the degree of correctness is unfortunately low. For example, if you rename or move a JS file, then the watcher might get confused and not pick up the "new" file or fail to clean things up correctly, resulting in you needing to clean your build and restart anew, which defeats the purpose.
-
-Say goodbye to stale build from your JavaScript ecosystem!
-
-## Speed Up Incremental Build
-
-ReScript uses the concept of interface files (`.resi`) (or, equivalently, [module signatures](module.md#signatures)). Exposing only what you need naturally speeds up incremental builds. E.g. if you change a `.res` file whose corresponding `.resi` file doesn't expose the changed part, then you've reduced the amount of dependent files you have to rebuild.
-
-## Programmatic Usage
-
-Unfortunately, JS build systems are usually the bottleneck for building a JS project nowadays. Having parts of the build blazingly fast doesn't matter much if the rest of the build takes seconds or literally minutes. Here are a few suggestions:
-
-- Convert more files into ReScript =). Fewer files going through fewer parts of the JS pipeline helps a ton.
-- Careful with bringing in more dependencies: libraries, syntax transforms (e.g. the unofficially supported PPX), build step loaders, etc. The bulk of these dragging down the editing & building experience might out-weight the API benefits they provide.
-
-## Hot Reloading
-
-Hot reloading refers to maintaining a dev server and listening to file changes in a way that allows the server to pipe some delta changes right into the currently running browser page. This provides a relatively fast iteration workflow while working in specific frameworks.
-
-However, hot reloading is fragile by nature, and counts on the occasional inconsistencies (bad state, bad eval, etc.) and the heavy devserver setup/config being less of a hassle than the benefits it provides. We err on the side of caution and stability in general, and decided not to provide a built-in hot reloading _yet_. **Note**: you can still use the hot reloading facility provided by your JS build pipeline.
diff --git a/pages/docs/manual/v11.0.0/build-pinned-dependencies.mdx b/pages/docs/manual/v11.0.0/build-pinned-dependencies.mdx
deleted file mode 100644
index a2b87299c..000000000
--- a/pages/docs/manual/v11.0.0/build-pinned-dependencies.mdx
+++ /dev/null
@@ -1,105 +0,0 @@
----
-title: "Pinned Dependencies"
-metaTitle: "Pinned Dependencies"
-description: "Handling multiple packages within one ReScript project with pinned dependencies"
-canonical: "/docs/manual/v11.0.0/build-pinned-dependencies"
----
-
-# Pinned Dependencies
-
-Usually we'd recommend to use ReScript in a single-codebase style by using one `rescript.json` file for your whole codebase.
-
-There are scenarios where you still want to connect and build multiple independent ReScript packages for one main project though (`npm` workspaces-like "monorepos"). This is where `pinned-dependencies` come into play.
-
-## Package Types
-
-Before we go into detail, let's first explain all the different package types recognized by the build system:
-
-- Toplevel (this is usually the final app you are building, which has dependencies to other packages)
-- Pinned dependencies (these are your local packages that should always rebuild when you build your toplevel, those should be listed in `bs-dependencies` and `pinned-dependencies`)
-- Normal dependencies (these are packages that are consumed from npm and listed via `bs-dependencies`)
-
-Whenever a package is being built (`rescript build`), the build system will build the toplevel package with its pinned-dependencies. So any changes made in a pinned dependency will automatically be reflected in the final app.
-
-## Build System Package Rules
-
-The build system respects the following rules for each package type:
-
-**Toplevel**
-
-- Warnings reported
-- Warn-error respected
-- Builds dev dependencies
-- Builds pinned dependencies
-- Runs custom rules
-- Package-specs like JavaScript module or CommonJS overrides all its dependencies
-
-**Pinned dependencies**
-
-- Warnings reported
-- Warn-error respected
-- Ignores pinned dependencies
-- Builds dev dependencies
-- Runs custom rules
-
-**Normal dependencies**
-
-- Warnings, warn-error ignored
-- Ignores dev directories
-- Ignores pinned dependencies
-- Ignores custom generator rules
-
-So with that knowledge in mind, let's dive into some more concrete examples to see our pinned dependencies in action.
-
-## Examples
-
-### Yarn workspaces
-
-Let's assume we have a codebase like this:
-
-```
-myproject/
-  app/
-   - src/App.res
-   - rescript.json
-  common/
-   - src/Header.res
-   - rescript.json
-  myplugin/
-   - src/MyPlugin.res
-   - rescript.json
-  package.json
-```
-
-Our `package.json` file within our codebase root would look like this:
-
-```json
-{
-  "name": "myproject",
-  "private": true,
-  "workspaces": {
-    "packages": ["app", "common", "myplugin"]
-  }
-}
-```
-
-Our `app` folder would be our toplevel package, consuming our `common` and `myplugin` packages as `pinned-dependencies`. The configuration for `app/rescript.json` looks like this:
-
-```json
-{
-  "name": "app",
-  "version": "1.0.0",
-  "sources": {
-    "dir": "src",
-    "subdirs": true
-  },
-  /* ... */
-  "bs-dependencies": ["common", "myplugin"],
-  "pinned-dependencies": ["common", "myplugin"]
-  /* ... */
-}
-```
-
-Now, whenever we are running `rescript build` within our `app` package, the compiler would always rebuild any changes within its pinned dependencies as well.
-
-**Important:** ReScript will not rebuild any `pinned-dependencies` in watch mode! This is due to the complexity of file watching, so you'd need to set up your own file-watcher process that runs `rescript build` on specific file changes.
diff --git a/pages/docs/manual/v11.0.0/control-flow.mdx b/pages/docs/manual/v11.0.0/control-flow.mdx
deleted file mode 100644
index fb2c7a72a..000000000
--- a/pages/docs/manual/v11.0.0/control-flow.mdx
+++ /dev/null
@@ -1,211 +0,0 @@
----
-title: "If-Else & Loops"
-description: "If, else, ternary, for, and while"
-canonical: "/docs/manual/v11.0.0/control-flow"
----
-
-# If-Else & Loops
-
-ReScript supports `if`, `else`, ternary expression (`a ? b : c`), `for` and `while`.
-
-ReScript also supports our famous pattern matching, which will be covered in [its own section](pattern-matching-destructuring.md)
-
-## If-Else & Ternary
-
-Unlike its JavaScript counterpart, ReScript's `if` is an expression; they evaluate to their body's content:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let message = if isMorning {
-  "Good morning!"
-} else {
-  "Hello!"
-}
-```
-```js
-var message = isMorning ? "Good morning!" : "Hello!";
-```
-
-</CodeTab>
-
-**Note:** an `if-else` expression without the final `else` branch implicitly gives `()` (aka the `unit` type). So this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-if showMenu {
-  displayMenu()
-}
-```
-```js
-if (showMenu) {
-  displayMenu();
-}
-```
-
-</CodeTab>
-
-is basically the same as:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-if showMenu {
-  displayMenu()
-} else {
-  ()
-}
-```
-```js
-if (showMenu) {
-  displayMenu()
-}
-```
-
-</CodeTab>
-
-Here's another way to look at it. This is clearly wrong:
-
-```res
-let result = if showMenu {
-  1 + 2
-}
-```
-
-It'll give a type error, saying basically that the implicit `else` branch has the type `unit` while the `if` branch has type `int`. Intuitively, this makes sense: what would `result`'s value be, if `showMenu` was `false`?
-
-We also have ternary sugar, but **we encourage you to prefer if-else when possible**.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let message = isMorning ? "Good morning!" : "Hello!"
-```
-```js
-var message = isMorning ? "Good morning!" : "Hello!";
-```
-
-</CodeTab>
-
-**`if-else` and ternary are much less used** in ReScript than in other languages; [Pattern-matching](pattern-matching-destructuring.md) kills a whole category of code that previously required conditionals.
-
-## For Loops
-
-For loops iterate from a starting value up to (and including) the ending value.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-for i in startValueInclusive to endValueInclusive {
-  Console.log(i)
-}
-```
-```js
-for(var i = startValueInclusive; i <= endValueInclusive; ++i){
-  console.log(i);
-}
-```
-
-</CodeTab>
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// prints: 1 2 3, one per line
-for x in 1 to 3 {
-  Console.log(x)
-}
-```
-```js
-for(var x = 1; x <= 3; ++x){
-  console.log(x);
-}
-```
-
-</CodeTab>
-
-You can make the `for` loop count in the opposite direction by using `downto`.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-for i in startValueInclusive downto endValueInclusive {
-  Console.log(i)
-}
-```
-```js
-for(var i = startValueInclusive; i >= endValueInclusive; --i){
-  console.log(i);
-}
-```
-
-</CodeTab>
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// prints: 3 2 1, one per line
-for x in 3 downto 1 {
-  Console.log(x)
-}
-```
-```js
-for(var x = 3; x >= 1; --x){
-  console.log(x);
-}
-```
-
-</CodeTab>
-
-## While Loops
-
-While loops execute its body code block while its condition is true.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-while testCondition {
-  // body here
-}
-```
-```js
-while (testCondition) {
-  // body here
-}
-```
-
-</CodeTab>
-
-### Tips & Tricks
-
-There's no loop-breaking `break` keyword (nor early `return` from functions, for that matter) in ReScript. However, we can break out of a while loop easily through using a [mutable binding](mutation.md).
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let break = ref(false)
-
-while !break.contents {
-  if Math.random() > 0.3 {
-    break := true
-  } else {
-    Console.log("Still running")
-  }
-}
-```
-```js
-var $$break = {
-  contents: false
-};
-
-while(!$$break.contents) {
-  if (Math.random() > 0.3) {
-    $$break.contents = true;
-  } else {
-    console.log("Still running");
-  }
-};
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v11.0.0/converting-from-js.mdx b/pages/docs/manual/v11.0.0/converting-from-js.mdx
deleted file mode 100644
index 81bf96b45..000000000
--- a/pages/docs/manual/v11.0.0/converting-from-js.mdx
+++ /dev/null
@@ -1,303 +0,0 @@
----
-title: "Converting from JS"
-description: "How to convert to ReScript with an existing JS codebase"
-canonical: "/docs/manual/v11.0.0/converting-from-js"
----
-
-# Converting from JS
-
-ReScript offers a unique project conversion methodology which:
-- Ensures minimal disruption to your teammates (very important!).
-- Remove the typical friction of verifying conversion's correctness and performance guarantees.
-- Doesn't force you to search for pre-made binding libraries made by others. **ReScript doesn't need the equivalent of TypeScript's `DefinitelyTyped`**.
-
-## Step 1: Install ReScript
-
-Run `npm install rescript` on your project, then imitate our [New Project](installation#new-project) workflow by adding a `rescript.json` at the root. Then start `npx rescript -w`.
-
-## Step 2: Copy Paste the Entire JS File
-
-Let's work on converting a file called `src/main.js`.
-
-```js
-const school = require('school');
-
-const defaultId = 10;
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-```
-
-First, copy the entire file content over to a new file called `src/Main.res` by using our [`%%raw` JS embedding trick](embed-raw-javascript):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-%%raw(`
-const school = require('school');
-
-const defaultId = 10;
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-`)
-```
-```js
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-const school = require('school');
-
-const defaultId = 10;
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-
-/*  Not a pure module */
-```
-
-</CodeTab>
-
-Add this file to `rescript.json`:
-
-```json
-  "sources": {
-    "dir" : "src",
-    "subdirs" : true
-  },
-```
-
-Open an editor tab for `src/Main.res.js`. Do a command-line `diff -u src/main.js src/Main.res.js`. Aside from whitespaces, you should see only minimal, trivial differences. You're already a third of the way done!
-
-**Always make sure** that at each step, you keep the ReScript output `.res.js` file open to compare against the existing JavaScript file. Our compilation output is very close to your hand-written JavaScript; you can simply eye the difference to catch conversion bugs!
-
-## Step 3: Extract Parts into Idiomatic ReScript
-
-Let's turn the `defaultId` variable into a ReScript let-binding:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let defaultId = 10
-
-%%raw(`
-const school = require('school');
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-`)
-```
-```js
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-const school = require('school');
-
-function queryResult(usePayload, payload) {
-  if usePayload {
-    return payload.student
-  } else {
-    return school.getStudentById(defaultId)
-  }
-}
-
-var defaultId = 10;
-
-exports.defaultId = defaultId;
-/*  Not a pure module */
-```
-
-</CodeTab>
-
-Check the output. Diff it. Code still works. Moving on! Extract the function:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-%%raw(`
-const school = require('school');
-`)
-
-let defaultId = 10
-
-let queryResult = (usePayload, payload) => {
-  if usePayload {
-    payload.student
-  } else {
-    school.getStudentById(defaultId)
-  }
-}
-```
-```js
-```
-
-</CodeTab>
-
-Format the code: `./node_modules/.bin/rescript format src/Main.res`.
-
-We have a type error: "The record field student can't be found". That's fine! **Always ensure your code is syntactically valid first**. Fixing type errors comes later.
-
-## Step 4: Add `external`s, Fix Types
-
-The previous type error is caused by `payload`'s record declaration (which supposedly contains the field `student`) not being found. Since we're trying to convert as quickly as possible, let's use our [object](object) feature to avoid needing type declaration ceremonies:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-%%raw(`
-const school = require('school');
-`)
-
-let defaultId = 10
-
-let queryResult = (usePayload, payload) => {
-  if usePayload {
-    payload["student"]
-  } else {
-    school["getStudentById"](defaultId)
-  }
-}
-```
-```js
-```
-
-</CodeTab>
-
-Now this triggers the next type error, that `school` isn't found. Let's use [`external`](external) to bind to that module:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module external school: 'whatever = "school"
-
-let defaultId = 10
-
-let queryResult = (usePayload, payload) => {
-  if usePayload {
-    payload["student"]
-  } else {
-    school["getStudentById"](defaultId)
-  }
-}
-```
-```js
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-var School = require("school");
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return School.getStudentById(10);
-  }
-}
-
-var defaultId = 10;
-
-exports.defaultId = defaultId;
-exports.queryResult = queryResult;
-/* school Not a pure module */
-```
-
-</CodeTab>
-
-We hurrily typed `school` as a polymorphic `'whatever` and let its type be inferred by its usage below. The inference is technically correct, but within the context of bringing it a value from JavaScript, slightly dangerous. This is just the interop trick we've shown in the [`external`](external) page.
-
-Anyway, the file passes the type checker again. Check the `.res.js` output, diff with the original `.js`; we've now converted a file over to ReScript!
-
-Now, you can delete the original, hand-written `main.js` file, and grep the files importing `main.js` and change them to importing `Main.res.js`.
-
-## (Optional) Step 5: Cleanup
-
-If you prefer more advanced, rigidly typed `payload` and `school`, feel free to do so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type school
-type student
-type payload = {
-  student: student
-}
-
-@module external school: school = "school"
-@send external getStudentById: (school, int) => student = "getStudentById"
-
-let defaultId = 10
-
-let queryResult = (usePayload, payload) => {
-  if usePayload {
-    payload.student
-  } else {
-    school->getStudentById(defaultId)
-  }
-}
-```
-```js
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-var School = require("school");
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return School.getStudentById(10);
-  }
-}
-
-var defaultId = 10;
-
-exports.defaultId = defaultId;
-exports.queryResult = queryResult;
-/* school Not a pure module */
-```
-
-</CodeTab>
-
-We've:
-- introduced an opaque types for `school` and `student` to prevent misuse of their values
-- typed the payload as a record with only the `student` field
-- typed `getStudentById` as the sole method of `student`
-
-Check that the `.res.js` output didn't change. How rigidly to type your JavaScript code is up to you; we recommend not typing them too elaborately; it's sometime an endless chase, and produces diminishing returns, especially considering that the elaborate-ness might turn off your potential teammates.
-
-## Tips & Tricks
-
-In the same vein of idea, **resist the urge to write your own wrapper functions for the JS code you're converting**. Use [`external`s](external), which are guaranteed to be erased in the output. And avoid trying to take the occasion to convert JS data structures into ReScript-specific data structures like variant or list. **This isn't the time for that**.
-
-The moment you produce extra conversion code in the output, your skeptical teammate's mental model might switch from "I recognize this output" to "this conversion might be introducing more problems than it solves. Why are we testing ReScript again?". Then you've lost.
-
-## Conclusion
-
-- Paste the JS code into a new ReScript file as embedded raw JS code.
-- Compile and keep the output file open. Check and diff against original JS file. Free regression tests.
-- Always make sure your file is syntactically valid. Don't worry about fixing types before that.
-- (Ab)use [object](object.md) accesses to quickly convert things over.
-- Optionally clean up the types for robustness.
-- Don't go overboard and turn off your boss and fellow teammates.
-- Proudly display that you've conserved the semantics and performance characteristics during the conversion by showing your teammates the eerily familiar output.
-- Get promoted for introducing a new technology the safer, mature way.
diff --git a/pages/docs/manual/v11.0.0/editor-plugins.mdx b/pages/docs/manual/v11.0.0/editor-plugins.mdx
deleted file mode 100644
index 357af4d04..000000000
--- a/pages/docs/manual/v11.0.0/editor-plugins.mdx
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: "Editor Plugins"
-description: "List of ReScript editor plugins"
-canonical: "/docs/manual/v11.0.0/editor-plugins"
----
-
-# Editor Plugins
-
-- [VSCode](https://marketplace.visualstudio.com/items?itemName=chenglou92.rescript-vscode)
-- [Sublime Text](https://github.com/rescript-lang/rescript-sublime)
-- [Vim/Neovim](https://github.com/rescript-lang/vim-rescript)
-
-## Community Supported
-
-We don't officially support these; use them at your own risk!
-
-- [Neovim Tree-sitter](https://github.com/nkrkv/nvim-treesitter-rescript)
-- [IDEA](https://github.com/reasonml-editor/reasonml-idea-plugin)
-- [Emacs](https://github.com/jjlee/rescript-mode)
-- [Zed](https://github.com/humaans/rescript-zed)
diff --git a/pages/docs/manual/v11.0.0/embed-raw-javascript.mdx b/pages/docs/manual/v11.0.0/embed-raw-javascript.mdx
deleted file mode 100644
index 51d6df489..000000000
--- a/pages/docs/manual/v11.0.0/embed-raw-javascript.mdx
+++ /dev/null
@@ -1,110 +0,0 @@
----
-title: "Embed Raw JavaScript"
-description: "Utility syntax to for raw JS usage in ReScript"
-canonical: "/docs/manual/v11.0.0/embed-raw-javascript"
----
-
-# Embed Raw JavaScript
-
-## Paste Raw JS Code
-
-First thing first. If you're ever stuck learning ReScript, remember that you can always just paste raw JavaScript code into our source file:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-%%raw(`
-// look ma, regular JavaScript!
-var message = "hello";
-function greet(m) {
-  console.log(m)
-}
-`)
-```
-```js
-// look ma, regular JavaScript!
-var message = "hello";
-function greet(m) {
-  console.log(m)
-}
-```
-
-</CodeTab>
-
-The `%%raw` special ReScript call takes your code string and pastes it as-is into the output. **You've now technically written your first ReScript file!**
-
-(The back tick syntax is a multiline string, similar to JavaScript's. Except for us, no escaping is needed inside the string. More on string in a later section.)
-
-While `%%raw` lets you embed top-level raw JS code, `%raw` lets you embed expression-level JS code:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let add = %raw(`
-  function(a, b) {
-    console.log("hello from raw JavaScript!");
-    return a + b
-  }
-`)
-
-Console.log(add(1, 2))
-```
-```js
-var add = function(a, b) {
-  console.log("hello from raw JavaScript!");
-  return a + b
-};
-
-console.log(add(1, 2));
-```
-
-</CodeTab>
-
-The above code:
-- declared a ReScript variable `add`,
-- with the raw JavaScript value of a function declaration,
-- then called that function in ReScript.
-
-If your boss is ever worried that your teammates can't adopt ReScript, just let them keep writing JavaScript inside ReScript files =).
-
-## Debugger
-
-You can also drop a `%debugger` expression in a body:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let f = (x, y) => {
-  %debugger
-  x + y
-}
-```
-```js
-function f(x, y) {
-  debugger;
-  return x + y | 0;
-}
-```
-
-</CodeTab>
-
-Output:
-
-```js
-function f(x, y) {
-  debugger; // JavaScript developer tools will set an breakpoint and stop here
-  x + y;
-}
-```
-
-## Tips & Tricks
-
-Embedding raw JS snippets isn't the best way to experience ReScript, though it's also highly useful if you're just starting out. As a matter of fact, the first few ReScript projects were converted through:
-
-- pasting raw JS snippets inside a file
-- examining the JS output (identical to the old hand-written JS)
-- gradually extract a few values and functions and making sure the output still looks OK
-
-At the end, we get a fully safe, converted ReScript file whose JS output is clean enough that we can confidently assert that no new bug has been introduced during the conversion process.
-
-We have a small guide on this iteration [here](converting-from-js.md). Feel free to peruse it later.
diff --git a/pages/docs/manual/v11.0.0/equality-comparison.mdx b/pages/docs/manual/v11.0.0/equality-comparison.mdx
deleted file mode 100644
index 89252b884..000000000
--- a/pages/docs/manual/v11.0.0/equality-comparison.mdx
+++ /dev/null
@@ -1,125 +0,0 @@
----
-title: "Equality and Comparison"
-description: "Handling equality and comparison checks"
-canonical: "/docs/manual/v11.0.0/equality-comparison"
----
-
-# Equality and Comparison
-
-ReScript has shallow equality `===`, deep equality `==`, and comparison operators `>`, `>=`, `<`, and `<=`.
-
-## Shallow equality
-The shallow equality operator `===` compares two values and either compiles to `===` or a `bool` if the equality is known to the compiler. 
-It behaves the same as the strict equality operator `===` in JavaScript.
-
-Using `===` will never add a runtime cost.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let t1 = 1 === 1 // true
-let t2 = "foo" === "foo" // true
-let t3 = { "foo": "bar" } === { "foo": "bar"} // false
-
-let doStringsMatch = (s1: string, s2: string) => s1 === s2
-```
-```js
-var t1 = true;
-var t2 = "foo" === "foo";
-var t3 = ({ foo: "bar" }) === ({ foo: "bar" });
-
-function doStringsMatch(s1, s2) {
-  return s1 === s2;
-}
-```
-
-</CodeTab>
-
-## Deep equality
-ReScript has the deep equality operator `==` to check deep equality of two items, which is very different from the loose equality operator like `==` in JavaScript.
-
-When using `==` in ReScript it will never compile to `==` in JavaScript, 
-it will either compile to `===`, a runtime call to an internal function that deeply compares the equality, or a `bool` if the equality is known to the compiler.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let t1 = 1 == 1 // true
-let t2 = "foo" == "foo" // true
-let t3 = { "foo": "bar" } == { "foo": "bar"} // true
-
-let doStringsMatch = (s1: string, s2: string) => s1 == s2
-```
-```js
-import * as Caml_obj from "./stdlib/caml_obj.js";
-
-var t1 = true;
-var t2 = true;
-var t3 = Caml_obj.equal({ foo: "bar" }, { foo: "bar" });
-
-function doStringsMatch(s1, s2) {
-  return s1 === s2;
-}
-```
-</CodeTab>
-
-`==` will compile to `===` (or a `bool` if the compiler can determine equality) when:
-
-- Comparing `string`, `char`, `int`, `float`, `bool`, or `unit`
-- Comparing variants or polymorphic variants that do not have constructor values
-
-`==` will compile to a runtime check for deep equality when:
-- Comparing `array`, `tuple`, `list`, `object`, `record`, or regular expression `Re.t`
-- Comparing variants or polymorphic variants that have constructor values
-
-> When using `==` pay close attention to the JavaScript output if you're not sure what `==` will compile to.
-
-## Comparison
-ReScript has operators for comparing values that compile to the the same operator in JS, a runtime check using an internal function, or a `bool` if the equality is known to the compiler,
-
-| operator | comparison |
-| --- | ----------- |
-| `>` | greater than |
-| `>=` | greater than or equal |
-| `<` | less than |
-| `<=` | less than or equal |
-
-Comparison can be done on any type.
-
-An operator will compile to the same operator (or a `bool` if the compiler can determine equality) when:
-- Comparing `int`, `float`, `string`, `char`, `bool`
-
-An operator will compile to a runtime check for deep equality when:
-- Comparing `array`, `tuple`, `list`, `object`, `record`, or regular expression (`Re.t`)
-- Comparing variants or polymorphic variants
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let compareInt = (a: int, b: int) => a > b
-let t1 = 1 > 10
-let compareArray = (a: array<int>, b: array<int>) => a > b
-let compareOptions = (a: option<float>, b: option<float>) => a < b
-```
-```js
-import * as Caml_obj from "./stdlib/caml_obj.js";
-
-function compareInt(a, b) {
-  return a > b;
-}
-
-var t1 = false;
-
-var compareArray = Caml_obj.greaterthan;
-
-var compareOptions = Caml_obj.lessthan;
-```
-</CodeTab>
-
-## Performance of runtime equality checks
-The runtime equality check ReScript uses is quite fast and should be adequate for almost all use cases.
-For small objects it can be 2x times faster than alternative deep compare functions such as Lodash's [`_.isEqual`](https://lodash.com/docs/4.17.15#isEqual).
-
-For larger objects instead of using `==` you could manually use a faster alternative such as [fast-deep-compare](https://www.npmjs.com/package/fast-deep-equal), or write a custom comparator function.
-
-[This repo](https://github.com/jderochervlk/rescript-perf) has benchmarks comparing results of different libraries compared to ReScript's built-in equality function.
\ No newline at end of file
diff --git a/pages/docs/manual/v11.0.0/exception.mdx b/pages/docs/manual/v11.0.0/exception.mdx
deleted file mode 100644
index cba5ff865..000000000
--- a/pages/docs/manual/v11.0.0/exception.mdx
+++ /dev/null
@@ -1,498 +0,0 @@
----
-title: "Exception"
-description: "Exceptions and exception handling in ReScript"
-canonical: "/docs/manual/v11.0.0/exception"
----
-
-# Exception
-
-Exceptions are just a special kind of variant, thrown in **exceptional** cases (don't abuse them!). Consider using the [`option`](null-undefined-option.mdx) or [`result`](api/core/result) type for recoverable errors.
-
-You can create your own exceptions like you'd make a variant (exceptions need to be capitalized too).
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-exception InputClosed(string)
-// later on
-raise(InputClosed("The stream has closed!"))
-```
-```js
-import * as Caml_exceptions from "./stdlib/caml_exceptions.js";
-
-var InputClosed = /* @__PURE__ */Caml_exceptions.create("Playground.InputClosed");
-
-throw {
-      RE_EXN_ID: InputClosed,
-      _1: "The stream has closed!",
-      Error: new Error()
-    };
-```
-
-</CodeTab>
-
-## Built-in Exceptions
-
-ReScript has some built-in exceptions:
-
-### `Not_found`
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let getItem = (item: int) =>
-  if (item === 3) {
-    // return the found item here
-    1
-  } else {
-    raise(Not_found)
-  }
-
-let result =
-  try {
-    getItem(2)
-  } catch {
-  | Not_found => 0 // Default value if getItem throws
-  }
-```
-```js
-import * as Caml_js_exceptions from "./stdlib/caml_js_exceptions.js";
-
-function getItem(item) {
-  if (item === 3) {
-    return 1;
-  }
-  throw {
-        RE_EXN_ID: "Not_found",
-        Error: new Error()
-      };
-}
-
-var result;
-
-try {
-  result = getItem(2);
-}
-catch (raw_exn){
-  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-  if (exn.RE_EXN_ID === "Not_found") {
-    result = 0;
-  } else {
-    throw exn;
-  }
-}
-```
-
-</CodeTab>
-
-Note that the above is just for demonstration purposes; in reality, you'd return an `option<int>` directly from `getItem` and avoid the `try` altogether.
-
-You can directly match on exceptions _while_ getting another return value from a function:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-switch list{1, 2, 3}->List.getExn(4) {
-| item => Console.log(item)
-| exception Not_found => Console.log("No such item found!")
-}
-```
-```js
-import * as Core__List from "./stdlib/core__List.js";
-import * as Caml_js_exceptions from "./stdlib/caml_js_exceptions.js";
-
-var exit = 0;
-
-var item;
-
-try {
-  item = Core__List.getExn({
-        hd: 1,
-        tl: {
-          hd: 2,
-          tl: {
-            hd: 3,
-            tl: /* [] */0
-          }
-        }
-      }, 4);
-  exit = 1;
-}
-catch (raw_exn){
-  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-  if (exn.RE_EXN_ID === "Not_found") {
-    console.log("No such item found!");
-  } else {
-    throw exn;
-  }
-}
-
-if (exit === 1) {
-  console.log(item);
-}
-```
-
-</CodeTab>
-
-### `Invalid_argument`
-
-Used to check if argument is valid. This exception takes a string.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-```res example
-let divide = (a, b) =>
-  if b == 0 {
-    raise(Invalid_argument("Denominator is zero"))
-  } else {
-    a / b
-  }
-
-// catch error
-try divide(2, 0)->Console.log catch {
-| Invalid_argument(msg) => Console.log(msg) // Denominator is zero
-}
-```
-
-```js
-import * as Caml_int32 from "./stdlib/caml_int32.js";
-import * as Caml_js_exceptions from "./stdlib/caml_js_exceptions.js";
-
-function divide(a, b) {
-  if (b === 0) {
-    throw {
-          RE_EXN_ID: "Invalid_argument",
-          _1: "Denominator is zero",
-          Error: new Error()
-        };
-  }
-  return Caml_int32.div(a, b);
-}
-
-try {
-  console.log(divide(2, 0));
-}
-catch (raw_msg){
-  var msg = Caml_js_exceptions.internalToOCamlException(raw_msg);
-  if (msg.RE_EXN_ID === "Invalid_argument") {
-    console.log(msg._1);
-  } else {
-    throw msg;
-  }
-}
-```
-
-</CodeTab>
-
-### `Assert_failure`
-
-Raise when you use `assert(condition)` and `condition` is false. The arguments
-are the location of the `assert` in the source code (file name, line number, column number).
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let decodeUser = (json: JSON.t) =>
-  switch json {
-  | Object(userDict) =>
-    switch (userDict->Dict.get("name"), userDict->Dict.get("age")) {
-    | (Some(String(name)), Some(Number(age))) => (name, age->Float.toInt)
-    | _ => assert(false)
-    }
-  | _ => assert(false)
-  }
-
-
-try decodeUser(%raw("{}"))->Console.log catch {
-| Assert_failure(loc) => Console.log(loc) // ("filename", line, col)
-}
-```
-
-```js
-mport * as Caml_js_exceptions from "./stdlib/caml_js_exceptions.js";
-
-function decodeUser(json) {
-  if (!Array.isArray(json) && (json === null || typeof json !== "object") && typeof json !== "number" && typeof json !== "string" && typeof json !== "boolean") {
-    throw {
-          RE_EXN_ID: "Assert_failure",
-          _1: [
-            "playground.res",
-            8,
-            9
-          ],
-          Error: new Error()
-        };
-  }
-  if (typeof json === "object" && !Array.isArray(json)) {
-    var match = json["name"];
-    var match$1 = json["age"];
-    if (match !== undefined && !(!Array.isArray(match) && (match === null || typeof match !== "object") && typeof match !== "number" && typeof match !== "string" && typeof match !== "boolean") && typeof match === "string" && match$1 !== undefined && !(!Array.isArray(match$1) && (match$1 === null || typeof match$1 !== "object") && typeof match$1 !== "number" && typeof match$1 !== "string" && typeof match$1 !== "boolean") && typeof match$1 === "number") {
-      return [
-              match,
-              match$1 | 0
-            ];
-    }
-    throw {
-          RE_EXN_ID: "Assert_failure",
-          _1: [
-            "playground.res",
-            6,
-            11
-          ],
-          Error: new Error()
-        };
-  }
-  throw {
-        RE_EXN_ID: "Assert_failure",
-        _1: [
-          "playground.res",
-          8,
-          9
-        ],
-        Error: new Error()
-      };
-}
-
-try {
-  console.log(decodeUser({}));
-}
-catch (raw_loc){
-  var loc = Caml_js_exceptions.internalToOCamlException(raw_loc);
-  if (loc.RE_EXN_ID === "Assert_failure") {
-    console.log(loc._1);
-  } else {
-    throw loc;
-  }
-}
-```
-
-</CodeTab>
-
-### `Failure`
-
-Exception raised to signal that the given arguments do not make sense. This
-exception takes a string as an argument.
-
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-```res example
-let isValidEmail = email => {
-  let hasAtSign = String.includes(email, "@")
-  let hasDot = String.includes(email, ".")
-  if !(hasAtSign && hasDot) {
-    raise(Failure("Invalid email address"))
-  } else {
-    true
-  }
-}
-
-
-let isValid = try isValidEmail("rescript.org") catch {
-| Failure(msg) => {
-    Console.error(msg)
-    false
-  }
-}
-```
-
-```js
-import * as Caml_js_exceptions from "./stdlib/caml_js_exceptions.js";
-
-function isValidEmail(email) {
-  var hasAtSign = email.includes("@");
-  var hasDot = email.includes(".");
-  if (hasAtSign && hasDot) {
-    return true;
-  }
-  throw {
-        RE_EXN_ID: "Failure",
-        _1: "Invalid email address",
-        Error: new Error()
-      };
-}
-
-var isValid;
-
-try {
-  isValid = isValidEmail("rescript.org");
-}
-catch (raw_msg){
-  var msg = Caml_js_exceptions.internalToOCamlException(raw_msg);
-  if (msg.RE_EXN_ID === "Failure") {
-    console.error(msg._1);
-    isValid = false;
-  } else {
-    throw msg;
-  }
-}
-```
-
-</CodeTab>
-
-### `Division_by_zero`
-
-Exception raised by integer division and remainder operations when their second argument is zero.
-
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-```res example
-// ReScript raise `Division_by_zero` if the denominator is zero
-let result = try Some(10 / 0) catch {
-| Division_by_zero => None
-}
-
-Console.log(result) // None
-```
-
-```js
-import * as Caml_int32 from "./stdlib/caml_int32.js";
-import * as Caml_js_exceptions from "./stdlib/caml_js_exceptions.js";
-
-var result;
-
-try {
-  result = Caml_int32.div(10, 0);
-}
-catch (raw_exn){
-  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-  if (exn.RE_EXN_ID === "Division_by_zero") {
-    result = undefined;
-  } else {
-    throw exn;
-  }
-}
-
-console.log(result);
-```
-
-</CodeTab>
-
-## Catching JS Exceptions
-
-To distinguish between JavaScript exceptions and ReScript exceptions, ReScript namespaces JS exceptions under the `Exn.Error(payload)` variant. To catch an exception thrown from the JS side:
-
-
-Throw an exception from JS:
-
-```js
-// Example.js
-
-exports.someJsFunctionThatThrows = () => {
-    throw new Error("A Glitch in the Matrix!");
-}
-```
-
-Then catch it from ReScript:
-
-```res
-// import the method in Example.js
-@module("./Example") 
-external someJsFunctionThatThrows: () => unit = "someJsFunctionThatThrows"
-
-try {
-  // call the external method
-  someJSFunctionThatThrows()
-} catch {
-| Exn.Error(obj) =>
-  switch Exn.message(obj) {
-  | Some(m) => Console.log("Caught a JS exception! Message: " ++ m)
-  | None => ()
-  }
-}
-```
-
-The `obj` here is of type `Exn.t`, intentionally opaque to disallow illegal operations. To operate on `obj`, do like the code above by using the standard library's [`Exn`](api/js/exn) module's helpers.
-
-## Raise a JS Exception
-
-`raise(MyException)` raises a ReScript exception. To raise a JavaScript exception (whatever your purpose is), use `Exn.raiseError`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myTest = () => {
-  Exn.raiseError("Hello!")
-}
-```
-```js
-var Js_exn = require("./stdlib/js_exn.js");
-
-function myTest() {
-  return Js_exn.raiseError("Hello!");
-}
-```
-
-</CodeTab>
-
-Then you can catch it from the JS side:
-
-```js
-// after importing `myTest`...
-try {
-  myTest()
-} catch (e) {
-  console.log(e.message) // "Hello!"
-}
-```
-
-## Catch ReScript Exceptions from JS
-
-The previous section is less useful than you think; to let your JS code work with your exception-throwing ReScript code, the latter doesn't actually need to throw a JS exception. ReScript exceptions can be used by JS code!
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-exception BadArgument({myMessage: string})
-
-let myTest = () => {
-  raise(BadArgument({myMessage: "Oops!"}))
-}
-```
-```js
-var Caml_exceptions = require("./stdlib/caml_exceptions.js");
-
-var BadArgument = Caml_exceptions.create("Playground.BadArgument");
-
-function myTest() {
-  throw {
-    RE_EXN_ID: BadArgument,
-    myMessage: "Oops!",
-    Error: new Error()
-  };
-}
-```
-
-</CodeTab>
-
-Then, in your JS:
-
-```js
-// after importing `myTest`...
-try {
-  myTest()
-} catch (e) {
-  console.log(e.myMessage) // "Oops!"
-  console.log(e.Error.stack) // the stack trace
-}
-```
-
-> Note: `RE_EXN_ID` is an internal field for bookkeeping purposes. Don't use it on the JS side. Use the other fields.
-
-The above `BadArgument` exception takes an inline record type. We special-case compile the exception as `{RE_EXN_ID, myMessage, Error}` for good ergonomics. If the exception instead took ordinary positional arguments, l like the standard library's `Invalid_argument("Oops!")`, which takes a single argument, the argument is compiled to JS as the field `_1` instead. A second positional argument would compile to `_2`, etc.
-
-## Tips & Tricks
-
-When you have ordinary variants, you often don't **need** exceptions. For example, instead of throwing when `item` can't be found in a collection, try to return an `option<item>` (`None` in this case) instead.
-
-### Catch Both ReScript and JS Exceptions in the Same `catch` Clause
-
-```res
-try {
-  someOtherJSFunctionThatThrows()
-} catch {
-| Not_found => ... // catch a ReScript exception
-| Invalid_argument(_) => ... // catch a second ReScript exception
-| Exn.Error(obj) => ... // catch the JS exception
-}
-```
-
-This technically works, but hopefully you don't ever have to work with such code...
diff --git a/pages/docs/manual/v11.0.0/extensible-variant.mdx b/pages/docs/manual/v11.0.0/extensible-variant.mdx
deleted file mode 100644
index 8fa0b42ad..000000000
--- a/pages/docs/manual/v11.0.0/extensible-variant.mdx
+++ /dev/null
@@ -1,75 +0,0 @@
----
-title: "Extensible Variant"
-description: "Extensible Variants in ReScript"
-canonical: "/docs/manual/v11.0.0/extensible-variant"
----
-
-# Extensible Variant
-
-Variant types are usually constrained to a fixed set of constructors. There may be very rare cases where you still want to be able to add constructors to a variant type even after its initial type declaration. For this, we offer extensible variant types.
-
-## Definition and Usage
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type t = ..
-
-type t += Other
-
-type t +=
-  | Point(float, float)
-  | Line(float, float, float, float)
-```
-```js
-var Caml_exceptions = require("./stdlib/caml_exceptions.js");
-
-var Other = Caml_exceptions.create("Playground.Other");
-
-var Point = Caml_exceptions.create("Playground.Point");
-
-var Line = Caml_exceptions.create("Playground.Line");
-```
-
-</CodeTab>
-
-The `..` in the type declaration above defines an extensible variant `type t`. The `+=` operator is then used to add constructors to the given type. 
-
-**Note:** Don't forget the leading `type` keyword when using the `+=` operator!
-
-## Pattern Matching Caveats
-
-Extensible variants are open-ended, so the compiler will not be able to exhaustively pattern match all available cases. You will always need to provide a default `_` case for every `switch` expression. 
-
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-
-```res
-let print = v =>
-  switch v {
-  | Point(x, y) => Console.log2("Point", (x, y))
-  | Line(ax, ay, bx, by) => Console.log2("Line", (ax, ay, bx, by))
-  | Other
-  | _ => Console.log("Other")
-  }
-```
-```js
-function print(v) {
-  if (v.RE_EXN_ID === Point) {
-    console.log("Point", [v._1, v._2]);
-  } else if (v.RE_EXN_ID === Line) {
-    console.log("Line", [v._1, v._2, v._3, v._4]);
-  } else {
-    console.log("Other");
-  } 
-}
-```
-
-</CodeTab>
-
-## Tips & Tricks
-
-**Fun fact:** In ReScript, [exceptions](./exception) are actually extensible variants under the hood, so `exception UserError(string)` is equivalent to `type exn += UserError(string)`. It's one of the very few use-case where extensible variants make sense.
-
-We usually recommend sticking with common [variants](./variant) as much as possible to reap the benefits of exhaustive pattern matching.
\ No newline at end of file
diff --git a/pages/docs/manual/v11.0.0/external.mdx b/pages/docs/manual/v11.0.0/external.mdx
deleted file mode 100644
index f3cfaaa32..000000000
--- a/pages/docs/manual/v11.0.0/external.mdx
+++ /dev/null
@@ -1,91 +0,0 @@
----
-title: "External (Bind to Any JS Library)"
-description: "The external keyword"
-canonical: "/docs/manual/v11.0.0/external"
----
-
-# External (Bind to Any JS Library)
-
-`external` is the primary ReScript feature for bringing in and using JavaScript values.
-
-`external` is like a let binding, but:
-- The right side of `=` isn't a value; it's the name of the JS value you're referring to.
-- The type for the binding is mandatory, since we need to know what the type of that JS value is.
-- Can only exist at the top level of a file or module.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external setTimeout: (unit => unit, int) => float = "setTimeout"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-There are several kinds of `external`s, differentiated and/or augmented through the [attribute](attribute.md) they carry. This page deals with the general, shared mechanism behind most `external`s. The different `external`s are documented in their respective pages later. A few notable ones:
-
-- `@val`, `@scope`: [bind to global JS values](bind-to-global-js-values).
-- `@module`: [bind to JS imported/exported values](import-from-export-to-js).
-- `@send`: [bind to JS methods](bind-to-js-function).
-
-You can also use our [Syntax Lookup](/syntax-lookup) tool to find them.
-
-Related: see also our [list of external decorators](interop-cheatsheet#list-of-decorators).
-
-## Usage
-
-Once declared, you can use an `external` as a normal value, just like a let binding.
-
-## Tips & Tricks
-
-`external` + ReScript objects are a wonderful combination for quick prototyping. Check the JS output tab:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// The type of document is just some random type 'a
-// that we won't bother to specify
-@val external document: 'a = "document"
-
-// call a method
-document["addEventListener"]("mouseup", _event => {
-  Console.log("clicked!")
-})
-
-// get a property
-let loc = document["location"]
-
-// set a property
-document["location"]["href"] = "rescript-lang.org"
-```
-```js
-document.addEventListener("mouseup", function(_event) {
-  console.log("clicked!");
-});
-
-var loc = document.location;
-
-document.location.href = "rescript-lang.org";
-```
-
-</CodeTab>
-
-We've specified `document`'s type as `'a`, aka a placeholder type that's polymorphic. Any value can be passed there, so you're not getting much type safety (except the inferences at various call sites). However, this is excellent for quickly getting started using a JavaScript library in ReScript **without needing the equivalent of a repository of typed bindings** like TypeScript's `DefinitelyTyped` repo.
-
-However, if you want to more rigidly bind to the JavaScript library you want, keep reading the next few interop pages.
-
-## Performance & Output Readability
-
-`external`s declarations are inlined into their callers during compilation, **and completely disappear from the JS output**. This means any time you use one, you can be sure that you're not incurring extra JavaScript \<-> ReScript conversion cost.
-
-Additionally, no extra ReScript-specific runtime is better for output readability.
-
-> **Note:** do also use `external`s and the `@blabla` attributes in the interface files. Otherwise the inlining won't happen.
-
-## Design Decisions
-
-ReScript takes interoperating with existing code very seriously. Our type system has very strong guarantees. However, such strong feature also means that, without a great interop system, it'd be very hard to gradually convert a codebase over to ReScript. Fortunately, our interop are comprehensive and cooperate very well with most existing JavaScript code.
-
-The combination of a sound type system + great interop means that we get the benefits of a traditional gradual type system regarding incremental codebase coverage & conversion, without the downside of such gradual type system: complex features to support existing patterns, slow analysis, diminishing return in terms of type coverage, etc.
diff --git a/pages/docs/manual/v11.0.0/faq.mdx b/pages/docs/manual/v11.0.0/faq.mdx
deleted file mode 100644
index a2c6ec366..000000000
--- a/pages/docs/manual/v11.0.0/faq.mdx
+++ /dev/null
@@ -1,67 +0,0 @@
----
-title: "FAQ"
-description: "Frequently asked questions about ReScript and its ecosystem"
-canonical: "/docs/manual/v11.0.0/faq"
----
-
-# Frequently Asked Questions
-
-**What's the goal of this project?**
-
-We aim to provide the best typed language experience for the JavaScript platform.
-
-**What’s the relationship with BuckleScript?**
-
-BuckleScript is ReScript's old branding, with a sharper focus on proper JS support and familiarity which we previously couldn't achieve to the degree we wanted, due to us needing to cater to various different crowds.
-
-**What’s ReScript's relationship with OCaml?**
-
-We reuse and adjust the excellent type system and lots of other high quality components from OCaml for JS experience.
-Additionally, ReScript provides its own syntax, build system, IDE, backend, JS interop, extra language features, etc.
-
-The ReScript toolchain is developed using OCaml, however, the version of ReScript is decoupled against the version of OCaml,
-ReScript compiler should build against any reasonable modern version of OCaml compiler.
-
-For the majority of ReScript users, they don't need to learn OCaml or use OCaml toolchain to be productive in ReScript.
-
-**What’s the relationship with Reason?**
-
-See [here](/blog/bucklescript-is-rebranding). Reason is a syntax layer for OCaml that BuckleScript also adopted. The current ReScript compiler also supports the old Reason syntax v3.6 for backward compatibility. We will support it for a long time to make sure existing users do not get breaking changes.
-
-**I come from Reason/OCaml. Will ReScript keep supporting X?**
-
-Please see our [blog post](/blog/a-note-on-bucklescripts-future-commitments) on this matter.
-
-**Where can I see the docs in old Reason/OCaml syntax?**
-
-Switch the doc version to `v8.0.0` in the sidebar on the left!
-
-**Will ReScript support native compilation eventually?**
-
-Our focus is a solid JS story right now. In the future, if there’s strong demand, we might consider it.
-
-**What’s the current state of ReScript?**
-
-We're working on the v12.0 release (see [v12 milestone](https://github.com/rescript-lang/rescript/milestone/16)).
-
-- Move the [Rescript Core](https://github.com/rescript-lang/rescript-core) standard library into the compiler / remove the OCaml standard library
-- A new build system tailored to ReScript's needs ([rewatch](https://github.com/teamwalnut/rewatch)) for better monorepo support and even faster compilation speed
-- Make it easier to create libraries for consumption from TypeScript with GenType
-
-**When will we get the `async/await` keywords?**
-
-async/await has arrived in ReScript 10.1!
-
-**Why create a new syntax?**
-
-The existing Reason syntax is owned by a different team with a different vision. Reason aims to be 100% compatible with OCaml syntax and to support all versions of OCaml. In the last few years, we've drawn the conclusion that it’s very hard to deliver such goal without sacrificing user experience. The other reason is that we feel it’s better to have the same vision as a team so that we can make more coherent decisions.
-
-**Who is behind the project?**
-
-The ReScript team (Hongbo, Cheng, Cristiano, Maxim, Patrick, Ricky).
-
-**We have a new forum; will we also have our own Discord?**
-
-Not now. We've found that too much important information get casually passed in Discord then lost within the noise. We prefer folks to communicate on the [forum](https://forum.rescript-lang.org). This is nicer to the less active members.
-
-The team doesn't use the old Discord anymore. We encourage you to move your questions to the forum instead.
diff --git a/pages/docs/manual/v11.0.0/function.mdx b/pages/docs/manual/v11.0.0/function.mdx
deleted file mode 100644
index 8be81acaf..000000000
--- a/pages/docs/manual/v11.0.0/function.mdx
+++ /dev/null
@@ -1,620 +0,0 @@
----
-title: "Function"
-description: "Function syntax in ReScript"
-canonical: "/docs/manual/v11.0.0/function"
----
-
-# Function
-
-_Cheat sheet for the full function syntax at the end_.
-
-ReScript functions are declared with an arrow and return an expression, just like JS functions. They compile to clean JS functions too.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let greet = (name) => "Hello " ++ name
-```
-```js
-function greet(name) {
-  return "Hello " + name;
-}
-```
-
-</CodeTab>
-
-This declares a function and assigns to it the name `greet`, which you can call like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-greet("world!") // "Hello world!"
-```
-```js
-greet("world!");
-```
-
-</CodeTab>
-
-Multi-arguments functions have arguments separated by comma:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let add = (x, y, z) => x + y + z
-add(1, 2, 3) // 6
-```
-```js
-function add(x, y, z) {
-  return (x + y | 0) + z | 0;
-}
-```
-
-</CodeTab>
-
-For longer functions, you'd surround the body with a block:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let greetMore = (name) => {
-  let part1 = "Hello"
-  part1 ++ " " ++ name
-}
-```
-```js
-function greetMore(name) {
-  return "Hello " + name;
-}
-```
-
-</CodeTab>
-
-If your function has no argument, just write `let greetMore = () => {...}`.
-
-## Labeled Arguments
-
-Multi-arguments functions, especially those whose arguments are of the same type, can be confusing to call.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let addCoordinates = (x, y) => {
-  // use x and y here
-}
-// ...
-addCoordinates(5, 6) // which is x, which is y?
-```
-```js
-function addCoordinates(x, y) {
-  // use x and y here
-}
-
-addCoordinates(5, 6);
-```
-
-</CodeTab>
-
-You can attach labels to an argument by prefixing the name with the `~` symbol:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let addCoordinates = (~x, ~y) => {
-  // use x and y here
-}
-// ...
-addCoordinates(~x=5, ~y=6)
-```
-```js
-function addCoordinates(x, y) {
-  // use x and y here
-}
-
-addCoordinates(5, 6);
-```
-
-</CodeTab>
-
-You can provide the arguments in **any order**:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-addCoordinates(~y=6, ~x=5)
-```
-```js
-addCoordinates(5, 6);
-```
-
-</CodeTab>
-
-The `~x` part in the declaration means the function accepts an argument labeled `x` and can refer to it in the function body by the same name. You can also refer to the arguments inside the function body by a different name for conciseness:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let drawCircle = (~radius as r, ~color as c) => {
-  setColor(c)
-  startAt(r, r)
-  // ...
-}
-
-drawCircle(~radius=10, ~color="red")
-```
-```js
-function drawCircle(r, c) {
-  setColor(c);
-  return startAt(r, r);
-}
-
-drawCircle(10, "red");
-```
-
-</CodeTab>
-
-As a matter of fact, `(~radius)` is just a shorthand for `(~radius as radius)`.
-
-Here's the syntax for typing the arguments:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let drawCircle = (~radius as r: int, ~color as c: string) => {
-  // code here
-}
-```
-```js
-function drawCircle(r, c) {
-  // code here
-}
-```
-
-</CodeTab>
-
-## Optional Labeled Arguments
-
-Labeled function arguments can be made optional during declaration. You can then omit them when calling the function.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// radius can be omitted
-let drawCircle = (~color, ~radius=?) => {
-  setColor(color)
-  switch radius {
-  | None => startAt(1, 1)
-  | Some(r_) => startAt(r_, r_)
-  }
-}
-```
-```js
-var Caml_option = require("./stdlib/caml_option.js");
-
-function drawCircle(color, radius) {
-  setColor(color);
-  if (radius === undefined) {
-    return startAt(1, 1);
-  }
-  var r_ = Caml_option.valFromOption(radius);
-  return startAt(r_, r_);
-}
-```
-
-</CodeTab>
-
-When given in this syntax, `radius` is **wrapped** in the standard library's `option` type, defaulting to `None`. If provided, it'll be wrapped with a `Some`. So `radius`'s type value is `None | Some(int)` here.
-
-More on `option` type [here](null-undefined-option.md).
-
-### Signatures and Type Annotations
-
-Functions with optional labeled arguments can be confusing when it comes to signature and type annotations. Indeed, the type of an optional labeled argument looks different depending on whether you're calling the function, or working inside the function body. Outside the function, a raw value is either passed in (`int`, for example), or left off entirely. Inside the function, the parameter is always there, but its value is an option (`option<int>`). This means that the type signature is different, depending on whether you're writing out the function type, or the parameter type annotation. The first being a raw value, and the second being an option.
-
-If we get back to our previous example and both add a signature and type annotations to its argument, we get this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let drawCircle: (~color: color, ~radius: int=?) => unit =
-  (~color: color, ~radius: option<int>=?) => {
-    setColor(color)
-    switch radius {
-    | None => startAt(1, 1)
-    | Some(r_) => startAt(r_, r_)
-    }
-  }
-```
-```js
-function drawCircle(color, radius) {
-  setColor(color);
-  if (radius !== undefined) {
-    return startAt(radius, radius);
-  } else {
-    return startAt(1, 1);
-  }
-}
-```
-
-</CodeTab>
-
-The first line is the function's signature, we would define it like that in an interface file (see [Signatures](module.md#signatures)). The function's signature describes the types that the **outside world** interacts with, hence the type `int` for `radius` because it indeed expects an `int` when called.
-
-In the second line, we annotate the arguments to help us remember the types of the arguments when we use them **inside** the function's body, here indeed `radius` will be an `option<int>` inside the function.
-
-So if you happen to struggle when writing the signature of a function with optional labeled arguments, try to remember this!
-
-### Explicitly Passed Optional
-
-Sometimes, you might want to forward a value to a function without knowing whether the value is `None` or `Some(a)`. Naively, you'd do:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result =
-  switch payloadRadius {
-  | None => drawCircle(~color)
-  | Some(r) => drawCircle(~color, ~radius=r)
-  }
-```
-```js
-var r = payloadRadius;
-
-var result = r !== undefined
-  ? drawCircle(color, Caml_option.valFromOption(r))
-  : drawCircle(color);
-```
-
-</CodeTab>
-
-This quickly gets tedious. We provide a shortcut:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result = drawCircle(~color, ~radius=?payloadRadius)
-```
-```js
-var result = drawCircle(1, undefined);
-```
-
-</CodeTab>
-
-This means "I understand `radius` is optional, and that when I pass it a value it needs to be an `int`, but I don't know whether the value I'm passing is `None` or `Some(val)`, so I'll pass you the whole `option` wrapper".
-
-### Optional with Default Value
-
-Optional labeled arguments can also be provided a default value. In this case, they aren't wrapped in an `option` type.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let drawCircle = (~radius=1, ~color) => {
-  setColor(color)
-  startAt(radius, radius)
-}
-```
-```js
-function drawCircle(radiusOpt, color) {
-  var radius = radiusOpt !== undefined ? radiusOpt : 1;
-  setColor(color);
-  return startAt(radius, radius);
-}
-```
-
-</CodeTab>
-
-## Recursive Functions
-
-ReScript chooses the sane default of preventing a function to be called recursively within itself. To make a function recursive, add the `rec` keyword after the `let`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let rec neverTerminate = () => neverTerminate()
-```
-```js
-function neverTerminate(_param) {
-  while(true) {
-    _param = undefined;
-    continue ;
-  };
-}
-```
-
-</CodeTab>
-
-A simple recursive function may look like this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// Recursively check every item on the list until one equals the `item`
-// argument. If a match is found, return `true`, otherwise return `false`
-let rec listHas = (list, item) =>
-  switch list {
-  | list{} => false
-  | list{a, ...rest} => a === item || listHas(rest, item)
-  }
-```
-```js
-function listHas(_list, item) {
-  while(true) {
-    var list = _list;
-    if (!list) {
-      return false;
-    }
-    if (list.hd === item) {
-      return true;
-    }
-    _list = list.tl;
-    continue ;
-  };
-}
-```
-
-</CodeTab>
-
-Recursively calling a function is bad for performance and the call stack. However, ReScript intelligently compiles [tail recursion](https://stackoverflow.com/questions/33923/what-is-tail-recursion) into a fast JavaScript loop. Try checking the JS output of the above code!
-
-### Mutually Recursive Functions
-
-Mutually recursive functions start like a single recursive function using the
-`rec` keyword, and then are chained together with `and`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let rec callSecond = () => callFirst()
-and callFirst = () => callSecond()
-```
-```js
-function callSecond(_param) {
-  while(true) {
-    _param = undefined;
-    continue ;
-  };
-}
-
-function callFirst(_param) {
-  while(true) {
-    _param = undefined;
-    continue ;
-  };
-}
-```
-
-</CodeTab>
-
-## Partial Application
-
-**Since 11.0**
-
-To partially apply a function, use the explicit `...` syntax. 
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-```res
-let add = (a, b) => a + b
-let addFive = add(5, ...)
-```
-
-```js
-function add(a, b) {
-  return a + b | 0;
-}
-
-function addFive(extra) {
-  return 5 + extra | 0;
-}
-```
-</CodeTab>
-
-## Async/Await
-
-Just as in JS, an async function can be declared by adding `async` before the definition, and `await` can be used in the body of such functions.
-The output looks like idiomatic JS:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let getUserName = async (userId) => userId
-
-let greetUser = async (userId) => {
-  let name = await getUserName(userId)  
-  "Hello " ++ name ++ "!"
-}
-```
-```js
-async function greetUser(userId) {
-  var name = await getUserName(userId);
-  return "Hello " + name + "!";
-}
-```
-</CodeTab>
-
-The return type of `getUser` is inferred to be `promise<string>`.
-Similarly, `await getUserName(userId)` returns a `string` when the function returns `promise<string>`.
-Using `await` outside of an `async` function (including in a non-async callback to an async function) is an error.
-
-### Ergonomic error handling
-
-Error handling is done by simply using `try`/`catch`, or a switch with an `exception` case, just as in functions that are not async.
-Both JS exceptions and exceptions defined in ReScript can be caught. The compiler takes care of packaging JS exceptions into the builtin `JsError` exception:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-exception SomeReScriptException
-
-let somethingThatMightThrow = async () => raise(SomeReScriptException)
-
-let someAsyncFn = async () => {
-  switch await somethingThatMightThrow() {
-  | data => Some(data)
-  | exception JsError(_) => None
-  | exception SomeReScriptException => None
-  }
-}
-```
-```js
-var SomeReScriptException = /* @__PURE__ */Caml_exceptions.create("Example.SomeReScriptException");
-
-async function someAsyncFn(param) {
-  var data;
-  try {
-    data = await somethingThatMightThrow(undefined);
-  }
-  catch (raw_exn){
-    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-    if (exn.RE_EXN_ID === "JsError") {
-      return ;
-    }
-    if (exn.RE_EXN_ID === SomeReScriptException) {
-      return ;
-    }
-    throw exn;
-  }
-  return data;
-}
-```
-</CodeTab>
-
-
-
-## The ignore() Function
-
-Occasionally you may want to ignore the return value of a function. ReScript provides an `ignore()` function that discards the value of its argument and returns `()`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-mySideEffect()->Promise.catch(handleError)->ignore
-
-setTimeout(myFunc, 1000)->ignore
-```
-
-```js
-$$Promise.$$catch(mySideEffect(), function (prim) {
-  return handleError(prim);
-});
-
-setTimeout(function (prim) {
-  myFunc();
-}, 1000);
-```
-
-</CodeTab>
-
-## Tips & Tricks
-
-Cheat sheet for the function syntaxes:
-
-### Declaration
-
-```res
-// anonymous function
-(x, y) => 1
-// bind to a name
-let add = (x, y) => 1
-
-// labeled
-let add = (~first as x, ~second as y) => x + y
-// with punning sugar
-let add = (~first, ~second) => first + second
-
-// labeled with default value
-let add = (~first as x=1, ~second as y=2) => x + y
-// with punning
-let add = (~first=1, ~second=2) => first + second
-
-// optional
-let add = (~first as x=?, ~second as y=?) => switch x {...}
-// with punning
-let add = (~first=?, ~second=?) => switch first {...}
-```
-
-#### With Type Annotation
-
-```res
-// anonymous function
-(x: int, y: int): int => 1
-// bind to a name
-let add = (x: int, y: int): int => 1
-
-// labeled
-let add = (~first as x: int, ~second as y: int) : int => x + y
-// with punning sugar
-let add = (~first: int, ~second: int) : int => first + second
-
-// labeled with default value
-let add = (~first as x: int=1, ~second as y: int=2) : int => x + y
-// with punning sugar
-let add = (~first: int=1, ~second: int=2) : int => first + second
-
-// optional
-let add = (~first as x: option<int>=?, ~second as y: option<int>=?) : int => switch x {...}
-// with punning sugar
-// note that the caller would pass an `int`, not `option<int>`
-// Inside the function, `first` and `second` are `option<int>`.
-let add = (~first: option<int>=?, ~second: option<int>=?) : int => switch first {...}
-```
-
-### Application
-
-```res
-add(x, y)
-
-// labeled
-add(~first=1, ~second=2)
-// with punning sugar
-add(~first, ~second)
-
-// application with default value. Same as normal application
-add(~first=1, ~second=2)
-
-// explicit optional application
-add(~first=?Some(1), ~second=?Some(2))
-// with punning
-add(~first?, ~second?)
-```
-
-#### With Type Annotation
-
-```res
-// labeled
-add(~first=1: int, ~second=2: int)
-// with punning sugar
-add(~first: int, ~second: int)
-
-// application with default value. Same as normal application
-add(~first=1: int, ~second=2: int)
-
-// explicit optional application
-add(~first=?Some(1): option<int>, ~second=?Some(2): option<int>)
-// no punning sugar when you want to type annotate
-```
-
-### Standalone Type Signature
-
-```res
-// first arg type, second arg type, return type
-type add = (int, int) => int
-
-// labeled
-type add = (~first: int, ~second: int) => int
-
-// labeled
-type add = (~first: int=?, ~second: int=?, unit) => int
-```
-
-#### In Interface Files
-
-To annotate a function from the implementation file (`.res`) in your interface file (`.resi`):
-
-```res sig
-let add: (int, int) => int
-```
-
-The type annotation part is the same as the previous section on With Type Annotation.
-
-**Don't** confuse `let add: myType` with `type add = myType`. When used in `.resi` interface files, the former exports the binding `add` while annotating it as type `myType`. The latter exports the type `add`, whose value is the type `myType`.
diff --git a/pages/docs/manual/v11.0.0/generate-converters-accessors.mdx b/pages/docs/manual/v11.0.0/generate-converters-accessors.mdx
deleted file mode 100644
index 3dc42a317..000000000
--- a/pages/docs/manual/v11.0.0/generate-converters-accessors.mdx
+++ /dev/null
@@ -1,114 +0,0 @@
----
-title: "Generate Converters & Helpers"
-description: "All about the @deriving decorator, and how to generate code from types"
-canonical: "/docs/manual/v11.0.0/generate-converters-accessors"
----
-
-# Generate Converters & Helpers
-
-**Note**: if you're looking for:
-- `@deriving(jsConverter)` for records
-- `@deriving({jsConverter: newType})` for records
-- `@deriving(abstract)` for records
-- `@deriving(jsConverter)` for plain and polymorphic variants
-
-These particular ones are no longer needed. Select a doc version lower than `9.0` in the sidebar to see their old docs.
-
-<!-- TODO: genType -->
-
-When using ReScript, you will sometimes come into situations where you want to
-
-- Automatically generate functions that convert between ReScript's internal and JS runtime values (e.g. variants).
-- Convert a record type into an abstract type with generated creation, accessor and method functions.
-- Generate some other helper functions, such as functions from record attribute names.
-
-You can use the `@deriving` decorator for different code generation scenarios. All different options and configurations will be discussed on this page.
-
-**Note:** Please be aware that extensive use of code generation might make it harder to understand your programs (since the code being generated is not visible in the source code, and you just need to know what kind of functions / values a decorator generates).
-
-## Generate Functions & Plain Values for Variants
-
-Use `@deriving(accessors)` on a variant type to create accessor functions for its constructors.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@deriving(accessors)
-type action =
-  | Click
-  | Submit(string)
-  | Cancel;
-```
-
-```js
-function submit(param_0) {
-  return /* Submit */[param_0];
-}
-
-var click = /* Click */0;
-
-var cancel = /* Cancel */1;
-
-exports.click  = click;
-exports.submit = submit;
-exports.cancel = cancel;
-```
-
-</CodeTab>
-
-Variants constructors with payloads generate functions, payload-less constructors generate plain integers (the internal representation of variants).
-
-**Note**:
-- The generated accessors are lower-cased.
-- You can now use these helpers on the JavaScript side! But don't rely on their actual values please.
-
-### Usage
-
-```res
-let s = submit("hello"); /* gives Submit("hello") */
-```
-
-This is useful:
-
-- When you're passing the accessor function as a higher-order function (which plain variant constructors aren't).
-- When you'd like the JS side to use these values & functions opaquely and pass you back a variant constructor (since JS has no such thing).
-
-Please note that in case you just want to _pipe a payload into a constructor_, you don't need to generate functions for that. Use the `->` syntax instead, e.g. `"test"->Submit`.
-
-## Generate Field Accessors for Records
-
-Use `@deriving(accessors)` on a record type to create accessors for its record field names.
-
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@deriving(accessors)
-type pet = {name: string}
-
-let pets = [{name: "bob"}, {name: "bob2"}]
-
-pets
- ->Array.map(name)
- ->Array.joinWith("&")
- ->Console.log
-```
-
-```js
-function name(param) {
-  return param.name;
-}
-
-var pets = [
-  {
-    name: "bob"
-  },
-  {
-    name: "bob2"
-  }
-];
-
-console.log(Belt_Array.map(pets, name).join("&"));
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v11.0.0/import-export.mdx b/pages/docs/manual/v11.0.0/import-export.mdx
deleted file mode 100644
index 1ebdb39c4..000000000
--- a/pages/docs/manual/v11.0.0/import-export.mdx
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: "Import & Export"
-description: "Importing / exporting in ReScript modules"
-canonical: "/docs/manual/v11.0.0/import-export"
----
-
-# Import & Export
-
-## Import a Module/File
-
-Unlike JavaScript, ReScript doesn't have or need import statements:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Inside School.res
-let studentMessage = Student.message
-```
-```js
-var Student = require("./Student.res.js");
-var studentMessage = Student.message
-```
-
-</CodeTab>
-
-The above code refers to the `message` binding in the file `Student.res`. Every ReScript file is also a module, so accessing another file's content is the same as accessing another module's content!
-
-A ReScript project's file names need to be unique.
-
-## Export Stuff
-
-By default, every file's type declaration, binding and module is exported, aka publicly usable by another file. **This also means those values, once compiled into JS, are immediately usable by your JS code**.
-
-To only export a few selected things, use a `.resi` [interface file](module.md#signatures).
-
-## Work with JavaScript Import & Export
-
-To see how to import JS modules and export stuff for JS consumption, see the JavaScript Interop section's [Import from/Export to JS](import-from-export-to-js.md).
diff --git a/pages/docs/manual/v11.0.0/import-from-export-to-js.mdx b/pages/docs/manual/v11.0.0/import-from-export-to-js.mdx
deleted file mode 100644
index fb149fd2e..000000000
--- a/pages/docs/manual/v11.0.0/import-from-export-to-js.mdx
+++ /dev/null
@@ -1,244 +0,0 @@
----
-title: "Import from / Export to JS"
-description: "Importing / exporting JS module content in ReScript"
-canonical: "/docs/manual/v11.0.0/import-from-export-to-js"
----
-
-# Import from/Export to JS
-
-You've seen how ReScript's idiomatic [Import & Export](import-export.md) works. This section describes how we work with importing stuff from JavaScript and exporting stuff for JavaScript consumption.
-
-If you're looking for react-specific interop guidance, check out the [React JS Interop guide](../../react/latest/import-export-reactjs.mdx).
-
-**Note**: due to JS ecosystem's module compatibility issues, our advice of keeping your ReScript file's compiled JS output open in a tab applies here **more than ever**, as you don't want to subtly output the wrong JS module import/export code, on top of having to deal with Babel/Webpack/Jest/Node's CommonJS \<-> JavaScript module compatibility shims.
-
-In short: **make sure your bindings below output what you'd have manually written in JS**.
-
-## Output Format
-
-We support 2 JavaScript import/export formats:
-
-- JavaScript module: `import * from 'MyReScriptFile'` and `export let ...`.
-- CommonJS: `require('myFile')` and `module.exports = ...`.
-
-The format is [configurable in via `rescript.json`](build-configuration.md#package-specs).
-
-## Import From JavaScript
-
-### Import a JavaScript Module's Named Export
-
-Use the `module` [external](external.md):
-
-<CodeTab labels={["ReScript", "JS Output (Module)", "JS Output (CommonJS)"]}>
-
-```res example
-// Import nodejs' path.dirname
-@module("path") external dirname: string => string = "dirname"
-let root = dirname("/User/github") // returns "User"
-```
-```js
-import * as Path from "path";
-var root = Path.dirname("/User/github");
-```
-```js
-var Path = require("path");
-var root = Path.dirname("/User/github");
-```
-
-</CodeTab>
-
-Here's what the `external` does:
-
-- `@module("path")`: pass the name of the JS module; in this case, `"path"`. The string can be anything: `"./src/myJsFile"`, `"@myNpmNamespace/myLib"`, etc.
-- `external`: the general keyword for declaring a value that exists on the JS side.
-- `dirname`: the binding name you'll use on the ReScript side.
-- `string => string`: the type signature of `dirname`. Mandatory for `external`s.
-- `= "dirname"`: the name of the variable inside the `path` JS module. There's repetition in writing the first and second `dirname`, because sometime the binding name you want to use on the ReScript side is different than the variable name the JS module exported.
-
-### Import a JavaScript Module As a Single Value
-
-By omitting the string argument to `module`, you bind to the whole JS module:
-
-<CodeTab labels={["ReScript", "JS Output (Module)", "JS Output (CommonJS)"]}>
-
-```res example
-@module external leftPad: (string, int) => string = "./leftPad"
-let paddedResult = leftPad("hi", 5)
-```
-```js
-import * as LeftPad from "./leftPad";
-var paddedResult = LeftPad("hi", 5);
-```
-```js
-var LeftPad = require("./leftPad");
-var paddedResult = LeftPad("hi", 5);
-```
-
-</CodeTab>
-
-Depending on whether you're compiling ReScript to JavaScript module or CommonJS, **this feature will generate subtly different code**. Please check both output tabs to see the difference. The JavaScript module output here would be wrong!
-
-### Import an `default` Export
-
-Use the value `default` on the right hand side:
-
-<CodeTab labels={["ReScript", "JS Output (Module)"]}>
-
-```res example
-@module("./student") external studentName: string = "default"
-Console.log(studentName)
-```
-```js
-import Student from "./student";
-var studentName = Student;
-```
-
-</CodeTab>
-
-### Use Import Attributes
-
-**Since 11.1**
-
-[Import attributes](https://github.com/tc39/proposal-import-attributes) can be used in ReScript, as long as ReScript is configured to output JavaScript module. You do that by passing configuration to the `@module` attribute:
-
-<CodeTab labels={["ReScript", "JS Output (Module)"]}>
-```rescript
-@module({from: "./myJson.json", with: {type_: "json", \"some-exotic-identifier": "someValue"}})
-external myJson: JSON.t = "default"
-
-Console.log(myJson)
-```
-
-```javascript
-import MyJsonJson from "./myJson.json" with {"type": "json", "some-exotic-identifier": "someValue"};
-
-var myJson = MyJsonJson;
-
-console.log(myJson);
-```
-</CodeTab>
-
-This above imports the local `./myJson.json` file, adding import attributes.
-
-This is how it works:
-1. Instead of passing a string or tuple to `@module`, pass a record.
-2. This record should have a `from` key. The value of that is where you want the module to be imported from (just like the regular string to `@module` is).
-3. It should also have a `with` key, with another record where you put all the import attributes you want emitted.
-
-Notice `\"some-exotic-identifier"` - you'll need to escape any key that's not a valid ReScript record key.
-Also notice `type_`. Since `type` is a reserved keyword in ReScript, you can use `type_` instead. It will be output as `type` in the JavaScript code.
-
-## Dynamic Import
-Leveraging JavaScript's [dynamic `import`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import) to reduce bundle size and lazy load code as needed is easy in ReScript. It's also a little bit more convenient than in regular JavaScript because you don't need to keep track of file paths manually with ReScript's module system.
-
-### Dynamically Importing Parts of a Module
-Use the `import` function to dynamically import a specific part of a module. Put whatever `let` binding you want to import in there, and you'll get a `promise` back resolving to that specific binding.
-
-Let's look at an example. Imagine the following file `MathUtils.res`:
-
-```rescript
-let add = (a, b) => a + b
-let sub = (a, b) => a - b
-```
-
-Now let's dynamically import the add function in another module, e.g. `App.res`:
-
-<CodeTab labels={["ReScript", "JS Output (Module)"]}>
-```rescript
-// App.res
-let main = async () => {
-  let add = await import(MathUtils.add)
-  let onePlusOne = add(1, 1)
-
-  Console.log(onePlusOne)
-}
-```
-```javascript
-async function main() {
-  var add = await import("./MathUtils.mjs").then(function(m) {
-    return m.add;
-  });
-
-  var onePlusOne = add(1, 1);
-  console.log(onePlusOne);
-}
-```
-</CodeTab>
-
-### Dynamically Importing an Entire Module
-The syntax for importing a whole module looks a little different, since we are operating on the module syntax level; instead of using `import`, you may simply `await` the module itself:
-<CodeTab labels={["ReScript", "JS Output (Module)"]}>
-```rescript
-// App.res
-let main = async () => {
-  module Utils = await MathUtils
-
-  let twoPlusTwo = Utils.add(2, 2)
-  Console.log(twoPlusTwo)
-}
-```
-```javascript
-async function main() {
-  var Utils = await import("./MathUtils.mjs");
-
-  var twoPlusTwo = Utils.add(2, 2);
-  console.log(twoPlusTwo);
-}
-```
-</CodeTab>
-
-## Export To JavaScript
-
-### Export a Named Value
-
-As mentioned in ReScript's idiomatic [Import & Export](import-export.md), every let binding and module is exported by default to other ReScript modules (unless you use a `.resi` [interface file](module#signatures)). If you open up the compiled JS file, you'll see that these values can also directly be used by a _JavaScript_ file too.
-
-### Export a `default` Value
-
-If your JS project uses JavaScript module, you're likely exporting & importing some default values:
-
-```js
-// student.js
-export default name = "Al";
-```
-
-```js
-// teacher.js
-import studentName from 'student.js';
-```
-
-A JavaScript default export is really just syntax sugar for a named export implicitly called `default` (now you know!). So to export a default value from ReScript, you can just do:
-
-<CodeTab labels={["ReScript", "JS Output (Module)", "JS Output (CommonJS)"]}>
-
-```res example
-// ReScriptStudent.res
-let default = "Bob"
-```
-```js
-var $$default = "Bob";
-
-exports.$$default = $$default;
-exports.default = $$default;
-// informal transpiler-compatible marker of a default export compiled from JavaScript module
-exports.__esModule = true;
-```
-```js
-var $$default = "Bob";
-
-export {
-  $$default,
-  $$default as default,
-}
-```
-
-</CodeTab>
-
-You can then import this default export as usual on the JS side:
-
-```js
-// teacher2.js
-import studentName from 'ReScriptStudent.js';
-```
-
-If your JavaScript's default import is transpiled by Babel/Webpack/Jest into CommonJS `require`s, we've taken care of that too! See the CommonJS output tab for `__esModule`.
diff --git a/pages/docs/manual/v11.0.0/inlining-constants.mdx b/pages/docs/manual/v11.0.0/inlining-constants.mdx
deleted file mode 100644
index 053c6ccd2..000000000
--- a/pages/docs/manual/v11.0.0/inlining-constants.mdx
+++ /dev/null
@@ -1,78 +0,0 @@
----
-title: "Inlining Constants"
-description: "Inlining constants"
-canonical: "/docs/manual/v11.0.0/inlining-constants"
----
-
-# Inlining Constants
-
-Sometimes, in the JavaScript output, you might want a certain value to be forcefully inlined. For example:
-
-```js
-if (process.env.mode === 'development') {
-  console.log("Dev-only code here!")
-}
-```
-
-The reason is that your JavaScript bundler (e.g. Webpack) might turn that into:
-
-```js
-if ('production' === 'development') {
-  console.log("Dev-only code here!")
-}
-```
-
-Then your subsequent Uglifyjs optimization would remove that entire `if` block. This is how projects like ReactJS provide a development mode code with plenty of dev warnings, while ensuring that the uglified (minified) production code is free of those expensive blocks.
-
-So, in ReScript, producing that example `if (process.env.mode === 'development')` output is important. This first try doesn't work:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external process: 'a = "process"
-
-let mode = "development"
-
-if (process["env"]["mode"] === mode) {
-  Console.log("Dev-only code here!")
-}
-```
-```js
-var mode = "development";
-
-if (process.env.mode === mode) {
-  console.log("Dev-only code here!");
-}
-```
-
-</CodeTab>
-
-The JS output shows `if (process.env.mode === mode)`, which isn't what we wanted. To inline `mode`'s value, use `@inline`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external process: 'a = "process"
-
-@inline
-let mode = "development"
-
-if (process["env"]["mode"] === mode) {
-  Console.log("Dev-only code here!")
-}
-```
-```js
-if (process.env.mode === "development") {
-  console.log("Dev-only code here!");
-}
-```
-
-</CodeTab>
-
-Now your resulting JS code can pass through Webpack and Uglifyjs like the rest of your JavaScript code, and that whole `console.log` can be removed.
-
-The inlining currently only works for **string, float and boolean**.
-
-## Tips & Tricks
-
-This is **not** an optimization. This is an edge-case feature for folks who absolutely need particular values inlined for a JavaScript post-processing step, like conditional compilation. Beside the difference in code that the conditional compilation might end up outputting, there's no performance difference between inlining and not inlining simple values in the eyes of a JavaScript engine.
diff --git a/pages/docs/manual/v11.0.0/installation.mdx b/pages/docs/manual/v11.0.0/installation.mdx
deleted file mode 100644
index 9a2735204..000000000
--- a/pages/docs/manual/v11.0.0/installation.mdx
+++ /dev/null
@@ -1,153 +0,0 @@
----
-title: "Installation"
-description: "ReScript installation and setup instructions"
-canonical: "/docs/manual/v11.0.0/installation"
----
-
-# Installation
-
-## Notes
-
-With the instructions below, our new standard library [ReScript Core](https://github.com/rescript-lang/rescript-core) will be included by default. (In ReScript 11, it comes as a separate npm package `@rescript/core`. In future versions, it will be included in the `rescript` npm package itself.)
-
-## Prerequisites
-
-- [Node.js](https://nodejs.org/) version >= 14
-- One of the following package managers:
-  - [npm](https://docs.npmjs.com/cli/) (comes with Node.js)
-  - [yarn](https://yarnpkg.com/) (yarn versions >1 need to set `nodeLinker: node-modules` in `.yarnrc.yml`)
-  - [pnpm](https://pnpm.io/)
-  - [bun](https://bun.sh/)
-
-## New Project
-
-The fastest and easiest way to spin up a new ReScript project is with the [create-rescript-app](https://github.com/rescript-lang/create-rescript-app) project generator. You can start it with any of the aforementioned package managers or `npx`.
-
-<CodeTab labels={["npm", "npx", "yarn", "pnpm", "bun"]}>
-
-```sh example
-npm create rescript-app@latest
-```
-```sh
-npx create-rescript-app
-```
-```sh
-yarn create rescript-app
-```
-```sh
-pnpm create rescript-app
-```
-```sh
-bun create rescript-app
-```
-
-</CodeTab>
-
-- Follow the steps of the setup.
-- Trigger a ReScript build:
-  ```sh
-  npm run res:build
-  ```
-- If you selected the "basic" template, simply run it with:
-  ```sh
-  node src/Demo.res.mjs
-  ```
-
-That compiles your ReScript into JavaScript, then uses Node.js to run said JavaScript.
-
-**When taking your first steps with ReScript, we recommend you use our unique workflow of keeping a tab open for the generated JS file** (`.res.js`/`.res.mjs`), so that you can learn how ReScript transforms into JavaScript.  Not many languages output clean JavaScript code you can inspect and learn from! With our [VS Code extension](https://marketplace.visualstudio.com/items?itemName=chenglou92.rescript-vscode), use the command "ReScript: Open the compiled JS file for this implementation file" to open the generated JS file for the currently active ReScript source file.
-
-During development, instead of running `npm run res:build` each time to compile, use `npm run res:dev` to start a watcher that recompiles automatically after file changes.
-
-## Integrate Into an Existing JS Project
-
-If you already have a JavaScript project into which you'd like to add ReScript you can do that in the following ways:
-
-### Quick Setup
-
-In the root directory of your project, execute:
-<CodeTab labels={["npm", "npx", "yarn", "pnpm", "bun"]}>
-
-```sh
-npm create rescript-app@latest
-```
-```sh
-npx create-rescript-app
-```
-```sh
-yarn create rescript-app
-```
-```sh
-pnpm create rescript-app
-```
-```sh
-bun create rescript-app
-```
-
-</CodeTab>
-
-`create-rescript-app` will tell you that a `package.json` file has been detected and ask you if it should install ReScript into your project. Just follow the steps accordingly.
-
-### Manual Setup
-- Install ReScript locally:
-  <CodeTab labels={["npm", "yarn", "pnpm", "bun"]}>
-
-  ```sh
-  npm install rescript @rescript/core
-  ```
-  ```sh
-  yarn add rescript @rescript/core
-  ```
-  ```sh
-  pnpm install rescript @rescript/core
-  ```
-  ```sh
-  bun install rescript @rescript/core
-  ```
-
-  </CodeTab>
-- Create a ReScript build configuration file (called `rescript.json`) at the root:
-  ```json
-  {
-    "name": "your-project-name",
-    "sources": [
-      {
-        "dir": "src", // update this to wherever you're putting ReScript files
-        "subdirs": true
-      }
-    ],
-    "package-specs": [
-      {
-        "module": "esmodule",
-        "in-source": true
-      }
-    ],
-    "suffix": ".res.js",
-    "bs-dependencies": [
-      "@rescript/core"
-    ],
-    "bsc-flags": [
-      "-open RescriptCore"
-    ]
-  }
-  ```
-  See [Build Configuration](build-configuration) for more details on `rescript.json`.
-- Add convenience `npm` scripts to `package.json`:
-  ```json
-  "scripts": {
-    "res:build": "rescript",
-    "res:dev": "rescript -w"
-  }
-  ```
-
-Since ReScript compiles to clean readable JS files, the rest of your existing toolchain (e.g. Babel and Webpack) should just work!
-
-Helpful guides:
-
-- [Converting from JS](/docs/manual/latest/converting-from-js).
-- [Shared Data Types](shared-data-types).
-- [Import from/Export to JS](import-from-export-to-js).
-
-### Integrate with a ReactJS Project
-
-To start a [rescript-react](/docs/react/latest/introduction) app, or to integrate ReScript into an existing ReactJS app, follow the instructions [here](/docs/react/latest/installation).
diff --git a/pages/docs/manual/v11.0.0/interop-cheatsheet.mdx b/pages/docs/manual/v11.0.0/interop-cheatsheet.mdx
deleted file mode 100644
index 04c556061..000000000
--- a/pages/docs/manual/v11.0.0/interop-cheatsheet.mdx
+++ /dev/null
@@ -1,274 +0,0 @@
----
-title: "Interop Cheatsheet"
-description: "Cheatsheet for various interop scenarios in ReScript"
-canonical: "/docs/manual/v11.0.0/interop-cheatsheet"
----
-
-# Interop Cheatsheet
-
-This is a glossary with examples. All the features are described by later pages.
-
-## List of Decorators
-
-> **Note:** In ReScript < 8.3, all our attributes started with the `bs.` prefix. This is no longer needed and our formatter automatically removes them in newer ReScript versions.
-
-<!-- Synced from https://github.com/rescript-lang/syntax/blob/123760c5a264da5288eeee5213ddd25eb86d62fe/src/res_printer.ml#L19-L51 -->
-
-### Attributes
-
-- `@as`: [here](attribute#usage), [here](bind-to-js-function#fixed-arguments), [here](bind-to-js-function#constrain-arguments-better) and [here](generate-converters-accessors#usage-3)
-- [`@deriving`](generate-converters-accessors#generate-functions--plain-values-for-variants)
-- [`@get`](bind-to-js-object#bind-using-special-bs-getters--setters)
-- [`@get_index`](bind-to-js-object#bind-using-special-bs-getters--setters)
-<!-- - `@ignore` -->
-- [`@inline`](inlining-constants)
-- [`@int`](bind-to-js-function#constrain-arguments-better)
-<!-- - `@meth` -->
-- [`@module`](import-from-export-to-js#import-a-javascript-modules-content)
-- [`@new`](bind-to-js-object#bind-to-a-js-object-thats-a-class)
-- [`@optional`](generate-converters-accessors#optional-labels)
-- [`@return`](bind-to-js-function#function-nullable-return-value-wrapping)
-- `@send`: [here](bind-to-js-function#object-method) and [here](pipe#js-method-chaining)
-- [`@scope`](bind-to-global-js-values#global-modules)
-- [`@set`](bind-to-js-object#bind-using-special-bs-getters--setters)
-- [`@set_index`](bind-to-js-object#bind-using-special-bs-getters--setters)
-- [`@variadic`](bind-to-js-function#variadic-function-arguments)
-- [`@string`](bind-to-js-function#constrain-arguments-better)
-- [`@this`](bind-to-js-function#modeling-this-based-callbacks)
-- [`@uncurry`](bind-to-js-function#extra-solution)
-- [`@unwrap`](bind-to-js-function#trick-2-polymorphic-variant--bsunwrap)
-- [`@val`](bind-to-global-js-values#global-modules)
-- [`@taggedTemplate`](bind-to-js-function#tagged_template-functions)
-
-- [`@deprecated`](attribute#usage)
-- [`genType`](https://github.com/reason-association/genType)
-- [`@JSX`](jsx)
-- `@react.component`: [here](/docs/react/latest/introduction) and [here](https://github.com/reasonml/reason-react)
-- [`@warning`](attribute#usage)
-- [`@unboxed`](variant#untagged-variants)
-
-### Extension Points
-
-- [`%debugger`](embed-raw-javascript#debugger)
-- [`%external`](bind-to-global-js-values#special-global-values)
-- [`%raw`](embed-raw-javascript#paste-raw-js-code)
-- [`%re`](primitive-types#regular-expression)
-- [`%todo`](/syntax-lookup#todo)
-
-## Raw JS
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let add = %raw("(a, b) => a + b")
-%%raw("const a = 1")
-```
-```js
-var add = ((a, b) => a + b);
-const a = 1
-```
-
-</CodeTab>
-
-## Global Value
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external setTimeout: (unit => unit, int) => float = "setTimeout"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Global Module's Value
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val @scope("Math")
-external random: unit => float = "random"
-
-let someNumber = random()
-
-@val @scope(("window", "location", "ancestorOrigins"))
-external length: int = "length"
-```
-```js
-var someNumber = Math.random();
-```
-
-</CodeTab>
-
-## Nullable
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let a = Some(5) // compiles to 5
-let b = None // compiles to undefined
-```
-```js
-var a = 5;
-var b;
-```
-
-</CodeTab>
-
-Handling a value that can be `undefined` and `null`, by ditching the `option` type and using `Nullable.t`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let jsNull = Nullable.null
-let jsUndefined = Nullable.undefined
-let result1: Nullable.t<string> = Nullable.make("hello")
-let result2: Nullable.t<int> = Nullable.fromOption(Some(10))
-let result3: option<int> = Nullable.toOption(Nullable.make(10))
-```
-```js
-import * as Caml_option from "./stdlib/caml_option.js";
-import * as Core__Nullable from "./stdlib/core__Nullable.js";
-
-var result2 = Core__Nullable.fromOption(10);
-
-var jsNull = null;
-
-var jsUndefined;
-
-var result1 = "hello";
-
-var result3 = Caml_option.nullable_to_opt(10);
-```
-
-</CodeTab>
-
-## JS Object
-
-- [Bind to a JS object as a ReScript record](bind-to-js-object#bind-to-record-like-js-objects).
-- [Bind to a JS object that acts like a hash map](bind-to-js-object#bind-to-hash-map-like-js-object).
-- [Bind to a JS object that's a class](bind-to-js-object#bind-to-a-js-object-thats-a-class).
-
-## Function
-
-### Object Method & Chaining
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@send external map: (array<'a>, 'a => 'b) => array<'b> = "map"
-@send external filter: (array<'a>, 'a => bool) => array<'a> = "filter"
-[1, 2, 3]
-  ->map(a => a + 1)
-  ->filter(a => mod(a, 2) == 0)
-  ->Console.log
-```
-```js
-console.log(
-  [1, 2, 3]
-    .map(function (a) {
-      return (a + 1) | 0;
-    })
-    .filter(function (a) {
-      return a % 2 === 0;
-    })
-);
-```
-
-</CodeTab>
-
-### Variadic Arguments
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("path") @variadic
-external join: array<string> => string = "join"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-### Tagged template functions
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// see https://bun.sh/docs/runtime/shell
-type result = {exitCode: int}
-@module("bun") @taggedTemplate
-external sh: (array<string>, array<string>) => promise<result> = "$"
-
-let filename = "index.res"
-let result = await sh`ls ${filename}`
-```
-
-```js 
-import * as $$Bun from "bun";
-var filename = "index.res";
-var result = await $$Bun.$`ls ${filename}`;
-```
-
-</CodeTab>
-
-### Polymorphic Function
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("Drawing") external drawCat: unit => unit = "draw"
-@module("Drawing") external drawDog: (~giveName: string) => unit = "draw"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val
-external padLeft: (
-  string,
-  @unwrap [
-    | #Str(string)
-    | #Int(int)
-  ])
-  => string = "padLeft"
-
-padLeft("Hello World", #Int(4))
-padLeft("Hello World", #Str("Message from ReScript: "))
-```
-```js
-padLeft("Hello World", 4);
-padLeft("Hello World", "Message from ReScript: ");
-```
-
-</CodeTab>
-
-## JS Module Interop
-
-[See here](import-from-export-to-js.md)
-
-## Dangerous Type Cast
-
-Final escape hatch converter. Do not abuse.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-external convertToFloat: int => float = "%identity"
-let age = 10
-let gpa = 2.1 +. convertToFloat(age)
-```
-```js
-var age = 10;
-var gpa = 2.1 + 10;
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v11.0.0/interop-with-js-build-systems.mdx b/pages/docs/manual/v11.0.0/interop-with-js-build-systems.mdx
deleted file mode 100644
index 35c8c18db..000000000
--- a/pages/docs/manual/v11.0.0/interop-with-js-build-systems.mdx
+++ /dev/null
@@ -1,57 +0,0 @@
----
-title: "Interop with JS Build Systems"
-description: "Documentation on how to interact with existing JS build systems"
-canonical: "/docs/manual/v11.0.0/interop-with-js-build-systems"
----
-
-# Interop with JS Build Systems
-
-If you come from JS, chances are that you already have a build system in your existing project. Here's an overview of the role `rescript` would play in your build pipeline, if you want to introduce some ReScript code.
-
-> **Please** try not to wrap `rescript` into your own incremental build framework. ReScript's compilation is very hard to get right, and you'll inevitably run into stale or badly performing builds (therefore erasing much of our value proposition) if you create your own meta layer on top.
-
-## Popular JS Build Systems
-
-The JS ecosystem uses a few build systems: [vite](https://vite.dev/), [browserify](http://browserify.org/), [rollup](https://github.com/rollup/rollup), [webpack](https://webpack.js.org/), etc. The first one is probably the most popular of the four (as of 2025 =P). These build systems do both the compilation and the linking (aka, bundling many files into one or few files).
-
-`rescript` only takes care of the compilation step; it maps one `.res`/`.resi` file into one JS output file. As such, in theory, no build system integration is needed from our side. From e.g. the webpack watcher's perspective, the JS files ReScript generates are almost equivalent to your hand-written JS files. We also recommend **that you initially check in those ReScript-generated JS files**, as this workflow means:
-
-- You can introduce ReScript silently into your codebase without disturbing existing infra.
-- You have a **visual** diff of the performance & correctness of your JS file when you update the `.res` files and the JS artifacts change.
-- You can let teammates hot-patch the JS files in emergency situations, without needing to first start learning ReScript.
-- You can remove ReScript completely from your codebase and things will still work (in case your company decides to stop using us for whatever reason).
-
-For what it's worth, you can also turn `rescript` into an automated step in your build pipeline, e.g. into a Webpack loader; but such approach is error-prone and therefore discouraged.
-
-### Tips & Tricks
-
-You can make ReScript JS files look even more idiomatic through the in-source + bs suffix config in `rescript.json`:
-
-```json
-{
-  "package-specs": {
-    "module": "commonjs", // or whatever module system your project uses
-    "in-source": true
-  },
-  "suffix": ".res.js"
-}
-```
-
-This will:
-
-- Generate the JS files alongside your ReScript source files.
-- Use the file extension `.res.js`, so that you can require these files on the JS side through `require('./MyFile.res.js')`, without needing a loader.
-
-## Use Loaders on ReScript Side
-
-"What if my build system uses a CSS/png/whatever loader and I'd like to use it in ReScript?"
-
-Loaders are indeed troublesome; in the meantime, please use e.g. `%raw("require('./myStyles.css')")` at the top of your file. This just uses [`raw`](embed-raw-javascript.md) to compile the snippet into an actual JS require.
-
-## Getting Project's Dependencies
-
-`rescript` generates one `MyFile.d` file per `MyFile` source file; you'll find them in `lib/bs`. These are human readable, machine-friendly list of the dependencies of said `MyFile`. You can read into them for your purpose (though mind the IO overhead). Use these files instead of creating your own dependency graph; we did the hard work of tracking the dependencies as best as possible (including inner modules, `open`s, module names overlap, etc).
-
-## Run Script Per File Built
-
-See [js-post-build](build-configuration#js-post-build). Though please use it sparingly; if you hook up a node.js script after each file built, you'll incur the node startup time per file!
diff --git a/pages/docs/manual/v11.0.0/introduction.mdx b/pages/docs/manual/v11.0.0/introduction.mdx
deleted file mode 100644
index 747ae1344..000000000
--- a/pages/docs/manual/v11.0.0/introduction.mdx
+++ /dev/null
@@ -1,80 +0,0 @@
----
-title: "Introduction"
-description: "The hows and whys of ReScript"
-canonical: "/docs/manual/v11.0.0/introduction"
----
-
-# ReScript
-
-Ever wanted a language like JavaScript, but without the warts, with a great type system, and with a lean build toolchain that doesn't waste your time?
-
-ReScript looks like JS, acts like JS, and compiles to the highest quality of clean, readable and performant JS, directly runnable in browsers and Node.
-
-**This means you can pick up ReScript and access the vast JavaScript ecosystem and tooling as if you've known ReScript for a long time!**
-
-**ReScript is the language for folks who don't necessarily love JavaScript, but who still acknowledge its importance**.
-
-## Difference vs TypeScript
-
-We respect TypeScript very much and think that it's a positive force in the JavaScript ecosystem. ReScript shares some of the same goals as TypeScript, but is different enough regarding some important nuances:
-
-- TypeScript's (admittedly noble) goal is to cover the entire JavaScript feature set and more. **ReScript covers only a curated subset of JavaScript**. For example, we emphasize plain data + functions over classes, clean [pattern matching](pattern-matching-destructuring.md) over fragile `if`s and virtual dispatches, [proper data modeling](variant.md) over string abuse, etc. JavaScript supersets will only grow larger over time; ReScript doesn't. \*
-
-- Consequently, TypeScript's type system is necessarily complex, pitfalls-ridden, potentially requires tweaking, sometimes slow, and requires quite a bit of noisy annotations that often feel like manual bookkeeping rather than clear documentation. In contrast, ReScript's type system:
-
-  - Is deliberately curated to be a simple subset most folks will have an easier time to use.
-  - Has **no** pitfalls, aka the type system is "sound" (the types will always be correct). E.g. If a type isn't marked as nullable, its value will never lie and let through some `undefined` value silently. **ReScript code has no null/undefined errors**.
-  - Is the same for everyone. No knobs, no bikeshedding opportunity.
-  - Runs extremely fast precisely thanks to its simplicity and curation. It's one of the fastest compiler & build system toolchains for JavaScript development.
-  - **Doesn't need type annotations**. Annotate as much or as little as you'd like. The types are inferred by the language (and, again, are guaranteed correct).
-
-- Migrating to TypeScript is done "breadth-first," whereas migrating to ReScript is done "depth-first." You can convert your codebase to TypeScript by "turning it on" for all files and annotate here and there; but how much type safety did you gain? How do you measure it? Type errors can still slip in and out of the converted pieces. For ReScript, our interop features draw clear boundaries: there's pure ReScript code, and there's JS interop code. Every piece of converted ReScript code is 100% clean. You'd convert file by file and each conversion increases your safety monotonically.
-
-\* When you absolutely need to write or interoperate with free-for-all JavaScript, we expose enough escape hatches for you.
-
-## Other Highlights
-
-Aside from the aforementioned simple, robust and fast type system, ReScript presents a few more advantages.
-
-### Faster than JavaScript
-
-JavaScript's been aggressively optimized by talented engineers over a long span. Unfortunately, even for seasoned JS devs, it can be hard to know how to properly leverage JS's performance. ReScript's type system and compiler naturally guides you toward writing code that's very often performant by default, with good leverage of various Just-In-Time optimizations (hidden classes, inline caching, avoiding deopts, etc).
-
-A widespread adage to write fast JavaScript code is to write as if there's a type system (in order to trigger JS engines' good optimization heuristics); ReScript gives you a real one and generates code that's friendly to optimizations by default.
-
-### High Quality Dead Code Elimination
-
-The JavaScript ecosystem is very reliant on dependencies. Shipping the final product inevitably drags in a huge amount of code, lots of which the project doesn't actually use. These regions of dead code impact loading, parsing and interpretation speed. ReScript provides powerful dead code elimination at all levels:
-
-- Function- and module-level code elimination is facilitated by the well-engineered type system and purity analysis.
-- At the global level, ReScript generates code that is naturally friendly to dead code elimination done by bundling tools such as [Rollup](https://github.com/rollup/rollup) and [Closure Compiler](https://developers.google.com/closure/compiler/), after its own sophisticated elimination pass.
-- The same applies for ReScript's own tiny runtime (which is written in ReScript itself).
-
-### Tiny JS Output
-
-A `Hello world` ReScript program generates **20 bytes** of JS code. Additionally, the standard library pieces you require in are only included when needed.
-
-### Fast Iteration Loop
-
-ReScript's build time is **one or two orders of magnitude** faster than alternatives. In its watcher mode, the build system usually finishes before you switch screen from the editor to the terminal tab (two digits of milliseconds). A fast iteration cycle reduces the need of keeping one's mental state around longer; this in turn allows one to stay in the flow longer and more often.
-
-### Readable Output & Great Interop
-
-Unreadable JavaScript code generated from other compiled-to-js languages makes it so that it could be, practically speaking:
-
-- Hard to debug (cryptic stack trace, mangled variable names)
-- Hard to learn from (non-straightforward mapping of concepts from one language to another)
-- Hard to profile for performance (unclear what runtime performance cost there is)
-- Hard to integrate with existing hand-written JS code
-
-ReScript's JS output is very readable. This is especially important while learning, where users might want to understand how the code's compiled, and to audit for bugs.
-
-This characteristic, combined with a fully-featured JS interop system, allows ReScript code to be inserted into an existing JavaScript codebase almost unnoticed.
-
-### Preservation of Code Structure
-
-ReScript maps one source file to one JavaScript output file. This eases the integration of existing tools such as bundlers and test runners. You can even start writing a single file without much change to your build setup. Each file's code structure is approximately preserved, too.
-
-## Conclusion
-
-We hope the above gave you enough of an idea of ReScript and its differentiators. Feel free to [try it online](/try) to get a feel!
diff --git a/pages/docs/manual/v11.0.0/json.mdx b/pages/docs/manual/v11.0.0/json.mdx
deleted file mode 100644
index a0004bcd5..000000000
--- a/pages/docs/manual/v11.0.0/json.mdx
+++ /dev/null
@@ -1,82 +0,0 @@
----
-title: "JSON"
-description: "Interacting with JSON in ReScript"
-canonical: "/docs/manual/v11.0.0/json"
----
-
-# JSON
-
-## Parse
-
-Bind to JavaScript's `JSON.parse` and type the return value as the type you're expecting:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// declare the shape of the json you're binding to
-type data = {names: array<string>}
-
-// bind to JS' JSON.parse
-@scope("JSON") @val
-external parseIntoMyData: string => data = "parse"
-
-let result = parseIntoMyData(`{"names": ["Luke", "Christine"]}`)
-let name1 = result.names[0]
-```
-```js
-var result = JSON.parse("{\"names\": [\"Luke\", \"Christine\"]}");
-var name1 = result.names[0];
-```
-
-</CodeTab>
-
-Where `data` can be any type you assume the JSON is. As you can see, this compiles to a straightforward `JSON.parse` call. As with regular JS, this is convenient, but has no guarantee that e.g. the data is correctly shaped, or even syntactically valid. Slightly dangerous.
-
-## Stringify
-
-Use [`JSON.stringify`](api/core/json#value-stringify) if your data is of type `JSON.t` or [`JSON.stringifyAny`](api/core/json#value-stringifyAny) if it is not.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-Console.log(JSON.stringifyAny(["Amy", "Joe"]))
-```
-```js
-console.log(JSON.stringify([
-  "Amy",
-  "Joe"
-]));
-```
-
-</CodeTab>
-
-## Import a JSON file
-
-Use the `@module` attribute to import JSON files directly.
-
-<CodeTab labels={["ReScript", "JS Output (Module)", "JS Output (CommonJS)"]}>
-
-```res example
-@module external studentNames: JSON.t = "./students.json"
-Console.log(studentNames)
-```
-```js
-import * as StudentsJson from "./students.json";
-
-var studentNames = StudentsJson;
-
-console.log(studentNames);
-```
-```js
-var StudentsJson = require("./students.json");
-
-var studentNames = StudentsJson;
-
-console.log(studentNames);
-```
-
-</CodeTab>
-
-## Advanced
-
-Thanks to untagged variants, JSON can be encoded and decoded idiomatically. Check it out on [the variants page](variant#decoding-and-encoding-json-idiomatically).
diff --git a/pages/docs/manual/v11.0.0/jsx.mdx b/pages/docs/manual/v11.0.0/jsx.mdx
deleted file mode 100644
index f3bc8bb32..000000000
--- a/pages/docs/manual/v11.0.0/jsx.mdx
+++ /dev/null
@@ -1,383 +0,0 @@
----
-title: "JSX"
-description: "JSX syntax in ReScript and React"
-canonical: "/docs/manual/v11.0.0/jsx"
----
-
-# JSX
-
-Would you like some HTML syntax in your ReScript? If not, quickly skip over this section and pretend you didn't see anything!
-
-ReScript supports the JSX syntax, with some slight differences compared to the one in [ReactJS](https://facebook.github.io/react/docs/introducing-jsx.html). ReScript JSX isn't tied to ReactJS; they translate to normal function calls:
-
-**Note** for [ReScriptReact](https://rescript-lang.org/docs/react/latest/introduction) readers: this isn't what ReScriptReact turns JSX into, in the end. See Usage section for more info.
-
-## Capitalized
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<MyComponent name={"ReScript"} />
-```
-```js
-React.createElement(MyComponent, {
-  name: "ReScript",
-});
-```
-
-</CodeTab>
-
-becomes
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-MyComponent.createElement(~name="ReScript", ~children=list{}, ())
-```
-```js
-React.createElement(MyComponent, {
-  name: "ReScript",
-});
-```
-
-</CodeTab>
-
-## Uncapitalized
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<div onClick={handler}> child1 child2 </div>
-```
-```js
-React.createElement("div", {
-  onClick: handler
-}, child1, child2);
-```
-
-</CodeTab>
-
-becomes
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-div(~onClick=handler, ~children=list{child1, child2}, ())
-```
-```js
-React.createElement("div", {
-  onClick: handler
-}, child1, child2);
-```
-
-</CodeTab>
-
-## Fragment
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<> child1 child2 </>
-```
-```js
-React.createElement(React.Fragment, undefined, child1, child2);
-```
-
-</CodeTab>
-
-becomes
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-list{child1, child2}
-```
-```js
-React.createElement(React.Fragment, undefined, child1, child2);
-```
-
-</CodeTab>
-
-### Children
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<MyComponent> child1 child2 </MyComponent>
-```
-```js
-React.createElement(MyComponent, { children: null }, child1, child2);
-```
-
-</CodeTab>
-
-This is the syntax for passing a list of two items, `child1` and `child2`, to the children position. It transforms to a list containing `child1` and `child2`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-MyComponent.createElement(~children=list{child1, child2}, ())
-```
-```js
-React.createElement(MyComponent.make, MyComponent.makeProps(null, undefined), child1, child2);
-```
-
-</CodeTab>
-
-**Note** again that this isn't the transform for ReScriptReact; ReScriptReact turns the final list into an array. But the idea still applies.
-
-So naturally, `<MyComponent> myChild </MyComponent>` is transformed to `MyComponent.createElement(~children=list{myChild}, ())`. I.e. whatever you do, the arguments passed to the children position will be wrapped in a list.
-
-## Usage
-
-See [ReScriptReact Elements & JSX](https://rescript-lang.org/docs/react/latest/elements-and-jsx) for an example application of JSX, which transforms the above calls into a ReScriptReact-specific call.
-
-Here's a JSX tag that shows most of the features.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<MyComponent
-  booleanAttribute={true}
-  stringAttribute="string"
-  intAttribute=1
-  forcedOptional=?{Some("hello")}
-  onClick={handleClick}>
-  <div> {React.string("hello")} </div>
-</MyComponent>
-```
-```js
-React.createElement(MyComponent, {
-  children: React.createElement("div", undefined, "hello"),
-  booleanAttribute: true,
-  stringAttribute: "string",
-  intAttribute: 1,
-  forcedOptional: "hello",
-  onClick: handleClick
-});
-```
-
-</CodeTab>
-
-## Departures From JS JSX
-
-- Attributes and children don't mandate `{}`, but we show them anyway for ease of learning. Once you format your file, some of them go away and some turn into parentheses.
-- Props spread is supported, but there are some restrictions (see below).
-- Punning!
-- Props and tag names have to follow ReScript's restrictions on identifiers at the exception of hyphens for lowercase tags ([see below](#hyphens-in-tag-names)).
-
-### Spread Props
-
-**Since 10.1**
-
-JSX props spread is supported now, but in a stricter way than in JS.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<Comp {...props} a="a" />
-```
-```js
-React.createElement(Comp, {
-  a: "a",
-  b: "b"
-});
-```
-
-</CodeTab>
-
-Multiple spreads are not allowed:
-
-<CodeTab labels={["ReScript"]}>
-
-```res
-<NotAllowed {...props1} {...props2} />
-```
-
-</CodeTab>
-
-The spread must be at the first position, followed by other props:
-
-<CodeTab labels={["ReScript"]}>
-
-```res
-<NotAllowed a="a" {...props} />
-```
-
-</CodeTab>
-
-### Punning
-
-"Punning" refers to the syntax shorthand for when a label and a value are the same. For example, in JavaScript, instead of doing `return {name: name}`, you can do `return {name}`.
-
-JSX supports punning. `<input checked />` is just a shorthand for `<input checked=checked />`. The formatter will help you format to the punned syntax whenever possible. This is convenient in the cases where there are lots of props to pass down:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<MyComponent isLoading text onClick />
-```
-```js
-React.createElement(MyComponent, {
-  isLoading: true,
-  text: text,
-  onClick: onClick
-});
-```
-
-</CodeTab>
-
-Consequently, a JSX component can cram in a few more props before reaching for extra libraries solutions that avoids props passing.
-
-**Note** that this is a departure from ReactJS JSX, which does **not** have punning. ReactJS' `<input checked />` desugars to `<input checked=true />`, in order to conform to DOM's idioms and for backward compatibility.
-
-### Hyphens in tag names
-
-**Since 11.1**
-
-JSX now supports lowercase tags with hyphens in their name. This allows to bind 
-to web components.
-
-Note though that props names can't have hyphens, you should use `@as` to bind to
-such props in your custom `JsxDOM.domProps` type ([see generic JSX transform](#generic-jsx-transform-jsx-beyond-react-experimental)).
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<model-viewer src touchActions="pan-y"></model-viewer>
-```
-```js
-React.createElement("model-viewer", {
-  "touch-actions": "pan-y",
-  src: src
-});
-```
-
-</CodeTab>
-
-## Generic JSX transform: JSX beyond React (experimental)
-
-**Since 11.1**
-
-While ReScript comes with first class support for JSX in React, it's also possible to have ReScript delegate JSX to other frameworks. You do that by configuring a _generic JSX transform_. 
-
-This is what you need to do to use a generic JSX transform:
-1. Make sure you have a ReScript module that [implements the functions and types necessary for the JSX transform](#implementing-a-generic-jsx-transform-module).
-2. Configure `rescript.json` to delegated JSX to that module.
-
-That's it really. We'll expand on each point below.
-
-### Configuration
-You configure a generic JSX transform by putting any module name in the `module` config of JSX in `rescript.json`. This can be _any valid module name_. Example part from `rescript.json`:
-
-```json
-"jsx": {
-  "module": "Preact"
- },
-```
-
-This will now put the `Preact` module in control of the generated JSX calls. The `Preact` module can be defined by anyone - locally in your project, or by a package. As long a it's available in the global scope. The JSX transform will delegate any JSX related code to `Preact`.
-
-#### What about `@react.component` for components?
-
-`@react.component` will still be available, and so is a generic `@jsx.component` notation. Both work the same way.
-
-### Usage Example
-Here's a quick usage example (the actual definition of `Preact.res` comes below):
-
-First, configure `rescript.json`:
-```json
-"jsx": {
-  "module": "Preact"
- },
-```
-
-Now you can build Preact components:
-```rescript
-// Name.res
-@jsx.component // or @react.component if you want
-let make = (~name) => Preact.string(`Hello ${name}!`)
-```
-
-And you can use them just like normal with JSX:
-```rescript
-let name = <Name name="Test" />
-```
-
-#### File level configuration
-You can configure what JSX transform is used at the file level via `@@jsxConfig`, just like before. Like:
-```rescript
-@@jsxConfig({module_: "Preact"})
-```
-
-This can be convenient if you're mixing different JSX frameworks in the same project.
-
-### Implementing a generic JSX transform module
-Below is a full list of everything you need in a generic JSX transform module, including code comments to clarify. It's an example implementation of a `Preact` transform, so when doing this for other frameworks you'd of course adapt what you import from, and so on.
-
-> You can easily copy-paste-and-adapt this to your needs if you're creating bindings to a JSX framework. Most often, all you'll need to change is what the `@module("") external` points to, so the runtime calls point to the correct JS module.
-
-```rescript
-// Preact.res
-/* Below is a number of aliases to the common `Jsx` module */
-type element = Jsx.element
-
-type component<'props> = Jsx.component<'props>
-
-type componentLike<'props, 'return> = Jsx.componentLike<'props, 'return>
-
-@module("preact")
-external jsx: (component<'props>, 'props) => element = "jsx"
-
-@module("preact")
-external jsxKeyed: (component<'props>, 'props, ~key: string=?, @ignore unit) => element = "jsx"
-
-@module("preact")
-external jsxs: (component<'props>, 'props) => element = "jsxs"
-
-@module("preact")
-external jsxsKeyed: (component<'props>, 'props, ~key: string=?, @ignore unit) => element = "jsxs"
-
-/* These identity functions and static values below are optional, but lets 
-you move things easily to the `element` type. The only required thing to 
-define though is `array`, which the JSX transform will output. */
-external array: array<element> => element = "%identity"
-@val external null: element = "null"
-
-external float: float => element = "%identity"
-external int: int => element = "%identity"
-external string: string => element = "%identity"
-
-/* These are needed for Fragment (<> </>) support */
-type fragmentProps = {children?: element}
-
-@module("preact") external jsxFragment: component<fragmentProps> = "Fragment"
-
-/* The Elements module is the equivalent to the ReactDOM module in React. This holds things relevant to _lowercase_ JSX elements. */
-module Elements = {
-  /* Here you can control what props lowercase JSX elements should have. 
-  A base that the React JSX transform uses is provided via JsxDOM.domProps, 
-  but you can make this anything. The editor tooling will support 
-  autocompletion etc for your specific type. */
-  type props = JsxDOM.domProps
-
-  @module("preact")
-  external jsx: (string, props) => Jsx.element = "jsx"
-
-  @module("preact")
-  external div: (string, props) => Jsx.element = "jsx"
-
-  @module("preact")
-  external jsxKeyed: (string, props, ~key: string=?, @ignore unit) => Jsx.element = "jsx"
-
-  @module("preact")
-  external jsxs: (string, props) => Jsx.element = "jsxs"
-
-  @module("preact")
-  external jsxsKeyed: (string, props, ~key: string=?, @ignore unit) => Jsx.element = "jsxs"
-
-  external someElement: element => option<element> = "%identity"
-}
-```
-
-As you can see, most of the things you'll want to implement will be copy paste from the above. But do note that **everything needs to be there unless explicitly noted** or the transform will fail at compile time.
\ No newline at end of file
diff --git a/pages/docs/manual/v11.0.0/lazy-values.mdx b/pages/docs/manual/v11.0.0/lazy-values.mdx
deleted file mode 100644
index 1b9bf27de..000000000
--- a/pages/docs/manual/v11.0.0/lazy-values.mdx
+++ /dev/null
@@ -1,126 +0,0 @@
----
-title: "Lazy Value"
-description: "Data type for deferred computation in ReScript"
-canonical: "/docs/manual/v11.0.0/lazy-values"
----
-
-# Lazy Value
-
-If you have some expensive computations you'd like to **defer and cache** subsequently, you can wrap it with `lazy`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-@module("node:fs")
-external readdirSync: string => array<string> = "readdirSync"
-
-// Read the directory, only once
-let expensiveFilesRead = lazy({
-  Console.log("Reading dir")
-  readdirSync("./pages")
-})
-```
-```js
-var Fs = require("fs");
-
-var expensiveFilesRead = {
-  LAZY_DONE: false,
-  VAL: (function () {
-    console.log("Reading dir");
-    return Fs.readdirSync("./pages");
-  })
-};
-```
-
-</CodeTab>
-
-Check the JS Output tab: that `expensiveFilesRead`'s code isn't executed yet, even though you declared it! You can carry it around without fearing that it'll run the directory read.
-
-**Note**: a lazy value is **not** a [shared data type](shared-data-types.md). Don't rely on its runtime representation in your JavaScript code.
-
-## Execute The Lazy Computation
-
-To actually run the lazy value's computation, use `Lazy.force` from the globally available `Lazy` module:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// First call. The computation happens
-Console.log(Lazy.force(expensiveFilesRead)) // logs "Reading dir" and the directory content
-
-// Second call. Will just return the already calculated result
-Console.log(Lazy.force(expensiveFilesRead)) // logs the directory content
-```
-```js
-console.log(CamlinternalLazy.force(expensiveFilesRead));
-
-console.log(CamlinternalLazy.force(expensiveFilesRead));
-```
-
-</CodeTab>
-
-The first time `Lazy.force` is called, the expensive computation happens and the result is **cached**. The second time, the cached value is directly used.
-
-**You can't re-trigger the computation after the first `force` call**. Make sure you only use a lazy value with computations whose results don't change (e.g. an expensive server request whose response is always the same).
-
-Instead of using `Lazy.force`, you can also use [pattern matching](pattern-matching-destructuring.md) to trigger the computation:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch expensiveFilesRead {
-| lazy(result) => Console.log(result)
-}
-```
-```js
-var result = CamlinternalLazy.force(expensiveFilesRead);
-```
-
-</CodeTab>
-
-Since pattern matching also works on a `let` binding, you can also do:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let lazy(result) = expensiveFilesRead
-Console.log(result)
-```
-```js
-var result = CamlinternalLazy.force(expensiveFilesRead);
-console.log(result);
-```
-
-</CodeTab>
-
-## Exception Handling
-
-For completeness' sake, our files read example might raise an exception because of `readdirSync`. Here's how you'd handle it:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let result = try {
-  Lazy.force(expensiveFilesRead)
-} catch {
-| Not_found => [] // empty array of files
-}
-```
-```js
-var result;
-
-try {
-  result = CamlinternalLazy.force(expensiveFilesRead);
-} catch (raw_exn) {
-  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-  if (exn.RE_EXN_ID === "Not_found") {
-    result = [];
-  } else {
-    throw exn;
-  }
-}
-```
-
-</CodeTab>
-
-Though you should probably handle the exception inside the lazy computation itself.
diff --git a/pages/docs/manual/v11.0.0/let-binding.mdx b/pages/docs/manual/v11.0.0/let-binding.mdx
deleted file mode 100644
index 54602b353..000000000
--- a/pages/docs/manual/v11.0.0/let-binding.mdx
+++ /dev/null
@@ -1,185 +0,0 @@
----
-title: "Let Binding"
-description: "Let binding syntax for binding to values in ReScript"
-canonical: "/docs/manual/v11.0.0/let-binding"
----
-
-# Let Binding
-
-A "let binding", in other languages, might be called a "variable declaration". `let` _binds_ values to names. They can be seen and referenced by code that comes _after_ them.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let greeting = "hello!"
-let score = 10
-let newScore = 10 + score
-```
-```js
-var greeting = "hello!";
-var score = 10;
-var newScore = 20;
-```
-
-</CodeTab>
-
-## Block Scope
-
-Bindings can be scoped through `{}`.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let message = {
-  let part1 = "hello"
-  let part2 = "world"
-  part1 ++ " " ++ part2
-}
-// `part1` and `part2` not accessible here!
-```
-```js
-var message = "hello world";
-```
-
-</CodeTab>
-
-The value of the last line of a scope is implicitly returned.
-
-### Design Decisions
-
-ReScript's `if`, `while` and functions all use the same block scoping mechanism. The code below works **not** because of some special "if scope"; but simply because it's the same scope syntax and feature you just saw:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-if displayGreeting {
-  let message = "Enjoying the docs so far?"
-  Console.log(message)
-}
-// `message` not accessible here!
-```
-```js
-if (displayGreeting) {
-  console.log("Enjoying the docs so far?");
-}
-```
-
-</CodeTab>
-
-## Bindings Are Immutable
-
-Let bindings are "immutable", aka "cannot change". This helps our type system deduce and optimize much more than other languages (and in turn, help you more).
-
-## Binding Shadowing
-
-The above restriction might sound unpractical at first. How would you change a value then? Usually, 2 ways:
-
-The first is to realize that many times, what you want isn't to mutate a variable's value. For example, this JavaScript pattern:
-
-```js
-var result = 0;
-result = calculate(result);
-result = calculateSomeMore(result);
-```
-
-...is really just to comment on intermediate steps. You didn't need to mutate `result` at all! You could have just written this JS:
-
-```js
-var result1 = 0;
-var result2 = calculate(result1);
-var result3 = calculateSomeMore(result2);
-```
-
-In ReScript, this obviously works too:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result1 = 0
-let result2 = calculate(result1)
-let result3 = calculateSomeMore(result2)
-```
-```js
-var result1 = 0;
-var result2 = calculate(0);
-var result3 = calculateSomeMore(result2);
-```
-
-</CodeTab>
-
-Additionally, reusing the same let binding name overshadows the previous bindings with the same name. So you can write this too:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result = 0
-let result = calculate(result)
-let result = calculateSomeMore(result)
-```
-```js
-var result = calculate(0);
-var result$1 = calculateSomeMore(result);
-```
-
-</CodeTab>
-
-(Though for the sake of clarity, we don't recommend this).
-
-As a matter of fact, even this is valid code:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let result = "hello"
-Console.log(result) // prints "hello"
-let result = 1
-Console.log(result) // prints 1
-```
-```js
-var result = 1;
-console.log("hello");
-console.log(1);
-```
-
-</CodeTab>
-
-The binding you refer to is whatever's the closest upward. No mutation here!
-If you need _real_ mutation, e.g. passing a value around, have it modified by many pieces of code, we provide a slightly heavier [mutation feature](mutation.md).
-
-## Private let bindings
-
-Private let bindings are introduced in the release [7.2](https://rescript-lang.org/blog/bucklescript-release-7-2).
-
-In the module system, everything is public by default,
-the only way to hide some values is by providing a separate signature to
-list public fields and their types:
-
-```res
-module A: {
-  let b: int
-} = {
-  let a = 3
-  let b = 4
-}
-```
-`%%private` gives you an option to mark private fields directly
-
-```res
-module A = {
-  %%private(let a = 3)
-  let b = 4
-}
-```
-
-`%%private` also applies to file level modules, so in some cases,
-users do not need to provide a separate interface file just to hide some particular values.
-
-Note interface files are still recommended as a general best practice since they give you better
-separate compilation units and also they're better for documentation.
-
-Still, `%%private` is useful in the following scenarios:
-
-- **Code generators.** Some code generators want to hide some values but it is sometimes very hard or time consuming for code generators to synthesize the types for public fields.
-
-- **Quick prototyping.** During prototyping, we still want to hide some values, but the interface file is not stable yet. `%%private` provides you such convenience.
-
diff --git a/pages/docs/manual/v11.0.0/libraries.mdx b/pages/docs/manual/v11.0.0/libraries.mdx
deleted file mode 100644
index df230de26..000000000
--- a/pages/docs/manual/v11.0.0/libraries.mdx
+++ /dev/null
@@ -1,27 +0,0 @@
----
-title: "Libraries & Publishing"
-description: "Install & publish ReScript packages"
-canonical: "/docs/manual/v11.0.0/libraries"
----
-
-# Libraries & Publishing
-
-ReScript libraries are just like JavaScript libraries: published & hosted on [NPM](http://npmjs.com). You can reuse your `npm`, `yarn` and `package.json`-related tools to manage them!
-
-## Tips & Tricks
-
-### Publish
-
-We recommend you to check in your compiled JavaScript output, for its [various benefits](interop-with-js-build-systems.md#popular-js-build-systems). If not, then at least consider publishing the JavaScript output by un-ignoring them in your [npmignore](https://docs.npmjs.com/cli/v7/using-npm/developers#keeping-files-out-of-your-package). This way, your published ReScript package comes with plain JavaScript files that JS users can consume. If your project's good, JS users might not even realize that they've installed a library written in ReScript!
-
-In case your library is only consumed by JS users, you may want to check out our [external stdlib](./build-external-stdlib) configuration as well.
-
-### Find Libraries
-
-Search `rescript`-related packages on NPM, or use our [Package Index](/packages).
-
-If you can't find what you're looking for, remember that **you don't need a wrapper** to use a JS library:
-
-- Most JS data types, such as array and objects, [map over cleanly to ReScript and vice-versa](shared-data-types.md).
-- You also have access to the familiar [Core API](api/core).
-- You can use a JavaScript library without needing to install dedicated binding libraries. Check the [`external`](external) page.
diff --git a/pages/docs/manual/v11.0.0/migrate-to-v11.mdx b/pages/docs/manual/v11.0.0/migrate-to-v11.mdx
deleted file mode 100644
index f63c09ec8..000000000
--- a/pages/docs/manual/v11.0.0/migrate-to-v11.mdx
+++ /dev/null
@@ -1,131 +0,0 @@
----
-title: "Migrate to v11"
-description: "Instructions on upgrading to ReScript 11"
-canonical: "/docs/manual/v11.0.0/migrate-to-v11"
----
-
-# Migrate to ReScript 11
-
-## Foreword
-
-The ReScript community is proud to introduce ReScript V11 which comes with a ton of new features but also removes a lot of bulk.
-A migration to it can be very straightforward, but it can also take some time, depending on your code style or what dependencies you use.
-
-Please have a look at the full [set of breaking changes](#list-of-all-breaking-changes) below to be able to decide whether this is a task you want to undertake. There is also the possibilty to [opt-out of uncurried mode](#minimal-migration) for now, which is probably the most fundamental change of this release. That and other new and notable features are discussed in the following blogposts:
-
-- [Better interop with customizable variants](/blog/improving-interop)
-- [Enhanced Ergonomics for Record Types](/blog/enhanced-ergonomics-for-record-types)
-- [First-class Dynamic Import Support](/blog/first-class-dynamic-import-support)
-- [Uncurried Mode](/blog/uncurried-mode)
-
-## Recommended Migration
-
-### Uncurried Mode
-
-For uncurried mode to take effect in ReScript 11 there is nothing to configure, it is activated by default.
-
-### Adapt suffix
-
-ReScript 11 now allows having arbitrary suffixes in the generated JavaScript files. However, it is still recommended to stick to using `.res.js`, `.res.mjs` or `.res.cjs`. For more information, read the Build System Configuration about [suffixes](/docs/manual/latest/build-configuration#suffix).
-
-### rescript.json
-
-The old configuration filename `bsconfig.json` is deprecated. Rename `bsconfig.json` to `rescript.json` to get rid of the deprecation warning.
-
-### ReScript Core standard library
-
-[ReScript Core](https://github.com/rescript-lang/rescript-core) is ReScript's new standard library. It replaces the complete `Js` module as well as some of the more frequently used modules from `Belt` and is recommended to use with uncurried mode.
-
-It will be integrated into the compiler in a future version. In ReScript 11, it still needs to be installed manually:
-
-```console
-$ npm install @rescript/core
-```
-
-Then add `@rescript/core` to your `rescript.json`'s dependencies:
-
-```diff
- {
-   "bs-dependencies": [
-+    "@rescript/core"
-   ]
- }
-```
-
-Open it so it's available in the global scope.
-
-```diff
- {
-   "bsc-flags": [
-+    "-open RescriptCore",
-   ]
- }
-```
-
-One major change to be aware of is that array access now returns an `option`.
-
-```res
-let firstItem = myArray[0] // Some("hello")
-```
-
-If you would like to not use an `option`, you can use [`Array.getUnsafe`](api/core/array#value-getUnsafe).
-
-For a detailed explanation on migration to ReScript Core, please refer to its [migration guide](https://github.com/rescript-lang/rescript-core#migration). A semi-automated script is available as well.
-
-See ReScript Core API docs [here](api/core).
-
-### Removed bindings
-
-Many Node bindings have been removed from the compiler. Please use [rescript-nodejs](https://github.com/TheSpyder/rescript-nodejs) instead or write your own local bindings.
-
-## Minimal Migration
-
-This guide describes the things to do at least to migrate to ReScript 11.
-
-### Disable uncurried mode
-
-If you use currying extensively and don't want to bother with adapting your code, or have dependencies that just don't work with uncurried mode yet, just set it to false in your `rescript.json`.
-
-```json
-{
-  "uncurried": false
-}
-```
-
-For more information, read the Build System Configuration about [uncurried](/docs/manual/latest/build-configuration#uncurried).
-
-## List of all breaking changes
-
-Below is an excerpt from the compiler changelog about all the breaking changes of ReScript 11.
-
-### Language and Compiler
-
-- Add smart printer for pipe chains. https://github.com/rescript-lang/rescript/pull/6411 (the formatter will reformat existing code in certain cases)
-- Parse `assert` as a regular function. `assert` is no longer a unary expression. Example: before `assert 1 == 2` is parsed as `(assert 1) == 2`, now it is parsed as `assert(1 == 2)`. https://github.com/rescript-lang/rescript/pull/6180
-- Remove support for the legacy Reason syntax. Existing Reason code can be converted to ReScript syntax using ReScript 9 as follows:
-  - `npx rescript@9 convert <reason files>`
-- Curried after uncurried is not fused anymore: `(. x) => y => 3` is not equivalent to `(. x, y) => 3` anymore. It's instead equivalent to `(. x) => { y => 3 }`.
-  Also, `(. int) => string => bool` is not equivalen to `(. int, string) => bool` anymore.
-  These are only breaking changes for unformatted code.
-- Exponentiation operator `**` is now right-associative. `2. ** 3. ** 2.` now compile to `Math.pow(2, Math.pow(3, 2))` and not anymore `Math.pow(Math.pow(2, 3), 2)`. Parentheses can be used to change precedence.
-- Stop mangling object field names. If you had objects with field names containing "\__" or leading "_", they won't be mangled in the compiled JavaScript and represented as it is without changes. https://github.com/rescript-lang/rescript/pull/6354
-- `$$default` is no longer exported from the generated JavaScript when using default exports. https://github.com/rescript-lang/rescript/pull/6328
-- `-bs-super-errors` flag has been deprecated along with Super_errors. https://github.com/rescript-lang/rescript/pull/6243
-- Remove unsafe `` j`$(a)$(b)` `` interpolation deprecated in compiler version 10 https://github.com/rescript-lang/rescript/pull/6068
-- `@deriving(jsConverter)` not supported anymore for variant types https://github.com/rescript-lang/rescript/pull/6088
-- New representation for variants, where the tag is a string instead of a number. https://github.com/rescript-lang/rescript/pull/6088
-
-### Compiler Libraries
-
-- Fixed name collision between the newly defined Js.Json.t and the variant constructor in the existing Js.Json.kind type. To address this, the usage of the existing Js.Json.kind type can be updated to Js.Json.Kind.t. https://github.com/rescript-lang/rescript/pull/6317
-- Remove rudimentary node bindings and undocumented `%node` extension. https://github.com/rescript-lang/rescript/pull/6285
-- `@rescript/react` >= 0.12.0-alpha.2 is now required because of the React.fragment's children type fix. https://github.com/rescript-lang/rescript/pull/6238
-- Remove deprecated module `Printexc`
-
-### Build System and Tools
-
-- Update watcher rules to recompile only on config and `*.res`/`*.resi`/`*.ml`/`.mli` file changes. Solves the issue of unnecessary recompiles on `.css`, `.ts`, and other unrelated file changes. https://github.com/rescript-lang/rescript/pull/6420
-- Made pinned dependencies transitive: if _a_ is a pinned dependency of _b_ and _b_ is a pinned dependency of _c_, then _a_ is implicitly a pinned dependency of _c_. This change is only breaking if your build process assumes non-transitivity.
-- Remove obsolete built-in project templates and the "rescript init" functionality. This is replaced by [create-rescript-app](https://github.com/rescript-lang/create-rescript-app) which is maintained separately.
-- Do not attempt to build ReScript from source on npm postinstall for platforms without prebuilt binaries anymore.
-- GenType: removed support for `@genType.as` for records and variants which has become unnecessary. Use the language's `@as` instead to channge the runtime representation without requiring any runtime conversion during FFI. https://github.com/rescript-lang/rescript/pull/6099 https://github.com/rescript-lang/rescript/pull/6101
diff --git a/pages/docs/manual/v11.0.0/module-functions.mdx b/pages/docs/manual/v11.0.0/module-functions.mdx
deleted file mode 100644
index 18f74a4bb..000000000
--- a/pages/docs/manual/v11.0.0/module-functions.mdx
+++ /dev/null
@@ -1,311 +0,0 @@
----
-title: "Module Functions"
-description: "Module Functions in ReScript"
-canonical: "/docs/manual/v11.0.0/module-functions"
----
-
-# Module Functions
-
-Module functions can be used to create modules based on types, values, or functions from other modules. 
-This is a powerful tool that can be used to create abstractions and reusable code that might not be possible with functions, or might have a runtime cost if done with functions.
-
-This is an advanced part of ReScript and you can generally get by with normal values and functions.
-
-## Quick example
-Next.js has a `useParams` hook that returns an unknown type, 
-and it's up to the developer in TypeScript to add a type annotation for the parameters returned by the hook.
-```TS
-const params = useParams<{ tag: string; item: string }>()
-```
-
-In ReScript we can create a module function that will return a typed response for the `useParams` hook.
-<CodeTab labels={["ReScript", "JS Output"]}>
-```res example
-module Next = {
-  // define our module function
-  module MakeParams = (Params: { type t }) => {
-    @module("next/navigation")
-    external useParams: unit => Params.t = "useParams"
-    /* You can use values from the function parameter, such as Params.t */
-  }
-}
-
-module Component: {
-  @react.component
-  let make: unit => Jsx.element
-} = {
-  // Create a module that matches the module type expected by Next.MakeParams
-  module P = {
-    type t = {
-      tag: string,
-      item: string,
-    }
-  }
-
-  // Create a new module using the Params module we created and the Next.MakeParams module function
-  module Params = Next.MakeParams(P)
-
-  @react.component
-  let make = () => {
-    // Use the functions, values, or types created by the module function
-    let params = Params.useParams()
-    <div>
-      <p>
-        {React.string("Tag: " ++ params.tag /* params is fully typed! */)}
-      </p>
-      <p> {React.string("Item: " ++ params.item)} </p>
-    </div>
-  }
-}
-```
-```js
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as $$Navigation from "next/navigation";
-import * as JsxRuntime from "react/jsx-runtime";
-
-function MakeParams(Params) {
-  return {};
-}
-
-var Next = {
-  MakeParams: MakeParams
-};
-
-function Playground$Component(props) {
-  var params = $$Navigation.useParams();
-  return JsxRuntime.jsxs("div", {
-              children: [
-                JsxRuntime.jsx("p", {
-                      children: "Tag: " + params.tag
-                    }),
-                JsxRuntime.jsx("p", {
-                      children: "Item: " + params.item
-                    })
-              ]
-            });
-}
-
-var Component = {
-  make: Playground$Component
-};
-
-export {
-  Next ,
-  Component ,
-}
-/* next/navigation Not a pure module */
-
-```
-</ CodeTab>
-
-## Sharing a type with an external binding
-This becomes incredibly useful when you need to have types that are unique to a project but shared across multiple components.
-Let's say you want to create a library with a `getEnv` function to load in environment variables found in `import.meta.env`.
-```res
-@val external env: 'a = "import.meta.env"
-
-let getEnv = () => {
-  env
-}
-```
-It's not possible to define types for this that will work for every project, so we just set it as 'a and the consumer of our library can define the return type.
-```res
-type t = {"LOG_LEVEL": string}
-
-let values: t = getEnv()
-```
-This isn't great and it doesn't take advantage of ReScript's type system and ability to use types without type definitions, and it can't be easily shared across our application.
-
-We can instead create a module function that can return a module that has contains a `getEnv` function that has a typed response.
-```res
-module MakeEnv = (
-  E: {
-    type t
-  },
-) => {
-  @val external env: E.t = "import.meta.env"
-
-  let getEnv = () => {
-    env
-  }
-}
-```
-And now consumers of our library can define the types and create a custom version of the hook for their application.
-Notice that in the JavaScript output that the `import.meta.env` is used directly and doesn't require any function calls or runtime overhead.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-```res
-module Env = MakeEnv({
-	type t = {"LOG_LEVEL": string}
-})
-
-let values = Env.getEnv()
-```
-```js
-var Env = {
-  getEnv: getEnv
-};
-
-var values = import.meta.env;
-```
-</ CodeTab>
-
-## Shared functions
-You might want to share functions across modules, like a way to log a value or render it in React.
-Here's an example of module function that takes in a type and a transform to string function.
-
-```res
-module MakeDataModule = (
-  T: {
-    type t
-    let toString: t => string
-  },
-) => {
-  type t = T.t
-  let log = a => Console.log("The value is " ++ T.toString(a))
-
-  module Render = {
-    @react.component
-    let make = (~value) => value->T.toString->React.string
-  }
-}
-```
-You can now take a module with a type of `t` and a `toString` function and create a new module that has the `log` function and the `Render` component.
-<CodeTab labels={["ReScript", "JS Output"]}>
-```res
-module Person = {
-  type t = { firstName: string, lastName: string } 
-  let toString = person => person.firstName ++ person.lastName
-}
-
-module PersonData = MakeDataModule(Person)
-```
-
-```js
-// Notice that none of the JS output references the MakeDataModule function
-
-function toString(person) {
-  return person.firstName + person.lastName;
-}
-
-var Person = {
-  toString: toString
-};
-
-function log(a) {
-  console.log("The value is " + toString(a));
-}
-
-function Person$MakeDataModule$Render(props) {
-  return toString(props.value);
-}
-
-var Render = {
-  make: Person$MakeDataModule$Render
-};
-
-var PersonData = {
-  log: log,
-  Render: Render
-};
-```
-</CodeTab>
-
-Now the `PersonData` module has the functions from the `MakeDataModule`.
-<CodeTab labels={["ReScript", "JS Output"]}>
-```res
-@react.component
-let make = (~person) => {
-  let handleClick = _ => PersonData.log(person)
-  <div>
-    {React.string("Hello ")}
-    <PersonData.Render value=person />
-    <button onClick=handleClick>
-      {React.string("Log value to console")}
-    </button>
-  </div>
-}
-```
-```js
-function Person$1(props) {
-  var person = props.person;
-  var handleClick = function (param) {
-    log(person);
-  };
-  return JsxRuntime.jsxs("div", {
-              children: [
-                "Hello ",
-                JsxRuntime.jsx(Person$MakeDataModule$Render, {
-                      value: person
-                    }),
-                JsxRuntime.jsx("button", {
-                      children: "Log value to console",
-                      onClick: handleClick
-                    })
-              ]
-            });
-}
-```
-</CodeTab>
-
-## Dependency injection
-Module functions can be used for dependency injection.
-Here's an example of injecting in some config values into a set of functions to access a database.
-<CodeTab labels={["ReScript", "JS Output"]}>
-```res
-module type DbConfig = {
-  let host: string
-  let database: string
-  let username: string
-  let password: string
-}
-
-module MakeDbConnection = (Config: DbConfig) => {
-  type client = {
-    write: string => unit,
-    read: string => string,
-  }
-  @module("database.js")
-  external makeClient: (string, string, string, string) => client = "makeClient"
-
-  let client = makeClient(Config.host, Config.database, Config.username, Config.password)
-}
-
-module Db = MakeDbConnection({
-  let host = "localhost"
-  let database = "mydb"
-  let username = "root"
-  let password = "password"
-})
-
-let updateDb = Db.client.write("new value")
-```
-```js
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as DatabaseJs from "database.js";
-
-function MakeDbConnection(Config) {
-  var client = DatabaseJs.makeClient(Config.host, Config.database, Config.username, Config.password);
-  return {
-          client: client
-        };
-}
-
-var client = DatabaseJs.makeClient("localhost", "mydb", "root", "password");
-
-var Db = {
-  client: client
-};
-
-var updateDb = client.write("new value");
-
-export {
-  MakeDbConnection ,
-  Db ,
-  updateDb ,
-}
-/* client Not a pure module */
-```
-</CodeTab>
\ No newline at end of file
diff --git a/pages/docs/manual/v11.0.0/module.mdx b/pages/docs/manual/v11.0.0/module.mdx
deleted file mode 100644
index 3d9f29800..000000000
--- a/pages/docs/manual/v11.0.0/module.mdx
+++ /dev/null
@@ -1,569 +0,0 @@
----
-title: "Module"
-description: "ReScript modules, module signatures and interface files"
-canonical: "/docs/manual/v11.0.0/module"
----
-
-# Module
-
-## Basics
-
-**Modules are like mini files**! They can contain type definitions, `let`
-bindings, nested modules, etc.
-
-### Creation
-
-To create a module, use the `module` keyword. The module name must start with a
-**capital letter**. Whatever you could place in a `.res` file, you may place
-inside a module definition's `{}` block.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module School = {
-  type profession = Teacher | Director
-
-  let person1 = Teacher
-  let getProfession = (person) =>
-    switch person {
-    | Teacher => "A teacher"
-    | Director => "A director"
-    }
-}
-```
-```js
-function getProfession(person) {
-  if (person) {
-    return "A director";
-  } else {
-    return "A teacher";
-  }
-}
-
-var School = {
-  person1: /* Teacher */0,
-  getProfession: getProfession
-};
-```
-
-</CodeTab>
-
-A module's contents (including types!) can be accessed much like a record's,
-using the `.` notation. This demonstrates modules' utility for namespacing.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let anotherPerson: School.profession = School.Teacher
-Console.log(School.getProfession(anotherPerson)) /* "A teacher" */
-```
-```js
-var anotherPerson = /* Teacher */0;
-console.log("A teacher");
-```
-
-</CodeTab>
-
-Nested modules work too.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module MyModule = {
-  module NestedModule = {
-    let message = "hello"
-  }
-}
-
-let message = MyModule.NestedModule.message
-```
-```js
-var NestedModule = {
-  message: message
-};
-
-var MyModule = {
-  NestedModule: NestedModule
-};
-
-var message = MyModule.NestedModule.message;
-```
-
-</CodeTab>
-
-### `open`ing a module
-
-Constantly referring to a value/type in a module can be tedious. Instead, we can "open" a module and refer to its contents without always prepending them with the
-module's name. Instead of writing:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let p = School.getProfession(School.person1)
-```
-```js
-var p = School.getProfession(School.person1);
-```
-
-</CodeTab>
-
-We can write:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-open School
-let p = getProfession(person1)
-```
-```js
-var p = School.getProfession(School.person1);
-```
-
-</CodeTab>
-
-The content of `School` module are made visible (**not** copied into the file, but simply made visible!) in scope. `profession`, `getProfession` and `person1` will thus correctly be found.
-
-**Use `open` this sparingly, it's convenient, but makes it hard to know where some values come from**. You should usually use `open` in a local scope:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let p = {
-  open School
-  getProfession(person1)
-}
-/* School's content isn't visible here anymore */
-```
-```js
-var p = School.getProfession(School.person1);
-```
-
-</CodeTab>
-
-### Use `open!` to ignore shadow warnings
-
-There are situations where `open` will cause a warning due to existing identifiers (bindings, types) being redefined. Use `open!` to explicitly tell the compiler that this is desired behavior.
-
-```res
-let map = (arr, value) => {
-  value
-}
-
-// opening Array would shadow our previously defined `map`
-// `open!` will explicitly turn off the automatic warning
-open! Array
-let arr = map([1,2,3], (a) => { a + 1})
-```
-
-**Note:** Same as with `open`, don't overuse `open!` statements if not necessary. Use (sub)modules to prevent shadowing issues.
-
-### Destructuring modules
-
-**Since 9.0.2**
-
-As an alternative to `open`ing a module, you can also destructure a module's functions and values into separate let bindings (similarly on how we'd destructure an object in JavaScript).
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-module User = {
-  let user1 = "Anna"
-  let user2 = "Franz"
-}
-
-// Destructure by name
-let {user1, user2} = module(User)
-
-// Destructure with different alias
-let {user1: anna, user2: franz} = module(User)
-```
-
-```js
-var user1 = "Anna";
-
-var user2 = "Franz";
-
-var User = {
-  user1: user1,
-  user2: user2
-};
-```
-
-</CodeTab>
-
-**Note:** You can't extract types with module destructuring — use a type alias instead (`type user = User.myUserType`).
-
-### Extending modules
-
-Using `include` in a module statically "spreads" a module's content into a new one, thus often fulfill the role of "inheritance" or "mixin".
-
-**Note**: this is equivalent to a compiler-level copy paste. **We heavily discourage `include`**. Use it as last resort!
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module BaseComponent = {
-  let defaultGreeting = "Hello"
-  let getAudience = (~excited) => excited ? "world!" : "world"
-}
-
-module ActualComponent = {
-  /* the content is copied over */
-  include BaseComponent
-  /* overrides BaseComponent.defaultGreeting */
-  let defaultGreeting = "Hey"
-  let render = () => defaultGreeting ++ " " ++ getAudience(~excited=true)
-}
-```
-```js
-function getAudience(excited) {
-  if (excited) {
-    return "world!";
-  } else {
-    return "world";
-  }
-}
-
-var BaseComponent = {
-  defaultGreeting: "Hello",
-  getAudience: getAudience
-};
-
-var defaultGreeting = "Hey";
-
-function render(param) {
-  return "Hey world!";
-}
-
-var ActualComponent = {
-  getAudience: getAudience,
-  defaultGreeting: defaultGreeting,
-  render: render
-};
-```
-
-</CodeTab>
-
-**Note**: `open` and `include` are very different! The former brings a module's content into your current scope, so that you don't have to refer to a value by prefixing it with the module's name every time. The latter **copies over** the definition of a module statically, then also do an `open`.
-
-### Every `.res` file is a module
-
-Every ReScript file is itself compiled to a module of the same name as the file name, capitalized. The file `React.res` implicitly forms a module `React`, which can be seen by other source files.
-
-**Note**: ReScript file names should, by convention, be capitalized so that their casing matches their module name. Uncapitalized file names are not invalid, but will be implicitly transformed into a capitalized module name. I.e. `file.res` will be compiled into the module `File`. To simplify and minimize the disconnect here, the convention is therefore to capitalize file names.
-
-## Signatures
-
-A module's type is called a "signature", and can be written explicitly. If a
-module is like a `.res` (implementation) file, then a module's signature is like
-a `.resi` (interface) file.
-
-### Creation
-
-To create a signature, use the `module type` keyword. The signature name must start with a
-**capital letter**. Whatever you could place in a `.resi` file, you may place
-inside a signature definition's `{}` block.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-/* Picking up previous section's example */
-module type EstablishmentType = {
-  type profession
-  let getProfession: profession => string
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-A signature defines the list of requirements that a module must satisfy in order
-for that module to match the signature. Those requirements are of the form:
-
-- `let x: int` requires a `let` binding named `x`, of type `int`.
-- `type t = someType` requires a type field `t` to be equal to `someType`.
-- `type t` requires a type field `t`, but without imposing any requirements on the actual, concrete type of `t`. We'd use `t` in other entries in the signature to describe relationships, e.g. `let makePair: t => (t, t)` but we cannot, for example, assume that `t` is an `int`. This gives us great, enforced abstraction abilities.
-
-To illustrate the various kinds of type entries, consider the above signature
-`EstablishmentType` which requires that a module:
-
-- Declare a type named `profession`.
-- Must include a function that takes in a value of the type `profession` and returns a string.
-
-**Note**:
-
-Modules of the type `EstablishmentType` can contain more fields than the
-signature declares, just like the module `School` in the previous section (if we
-choose to assign it the type `EstablishmentType`. Otherwise, `School` exposes
-every field). This effectively makes the `person1` field an enforced
-implementation detail! Outsiders can't access it, since it's not present in the
-signature; the signature **constrained** what others can access.
-
-The type `EstablishmentType.profession` is **abstract**: it doesn't have a
-concrete type; it's saying "I don't care what the actual type is, but it's used
-as input to `getProfession`". This is useful to fit many modules under the same
-interface:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-module Company: EstablishmentType = {
-  type profession = CEO | Designer | Engineer | ...
-
-  let getProfession = (person) => ...
-  let person1 = ...
-  let person2 = ...
-}
-```
-```js
-function getProfession(person) {
-  ...
-}
-
-var person1 = ...
-
-var person2 = ...
-
-var Company = {
-  getProfession: getProfession,
-  person1: person1,
-  person2: person2
-};
-```
-
-</CodeTab>
-
-It's also useful to hide the underlying type as an implementation detail others
-can't rely on. If you ask what the type of `Company.profession` is, instead of
-exposing the variant, it'll only tell you "it's `Company.profession`".
-
-### Extending module signatures
-
-Like modules themselves, module signatures can also be extended by other module signatures using `include`. Again, **heavily discouraged**:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module type BaseComponent = {
-  let defaultGreeting: string
-  let getAudience: (~excited: bool) => string
-}
-
-module type ActualComponent = {
-  /* the BaseComponent signature is copied over */
-  include BaseComponent
-  let render: unit => string
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-**Note**: `BaseComponent` is a module **type**, not an actual module itself!
-
-If you do not have a defined module type, you can extract it from an actual module
-using `include (module type of ActualModuleName)`. For example, we can extend the
-`List` module from the standard library, which does not define a module
-type.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module type MyList = {
-  include (module type of List)
-  let myListFun: list<'a> => list<'a>
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-### Every `.resi` file is a signature
-
-Similar to how a `React.res` file implicitly defines a module `React`, a file
-`React.resi` implicitly defines a signature for `React`. If `React.resi` isn't
-provided, the signature of `React.res` defaults to exposing all the fields of the
-module. Because they don't contain implementation files, `.resi` files are used
-in the ecosystem to also document the public API of their corresponding modules.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-/* file React.res (implementation. Compiles to module React) */
-type state = int
-let render = (str) => str
-```
-```js
-function render(str) {
-  return str;
-}
-```
-
-</CodeTab>
-
-```res sig
-/* file React.resi (interface. Compiles to the signature of React.res) */
-type state = int
-let render: string => string
-```
-
-## Module Functions
-
-Modules can be passed to functions! It would be the equivalent of passing a file
-as a first-class item. However, modules are at a different "layer" of the
-language than other common concepts, so we can't pass them to *regular*
-functions. Instead, we pass them to special functions called module functions.
-
-The syntax for defining and using module functions is very much like the syntax
-for defining and using regular functions. The primary differences are:
-
-- Module functions use the `module` keyword instead of `let`.
-- Module functions take modules as arguments and return a module.
-- Module functions *require* annotating arguments.
-- Module functions must start with a capital letter (just like modules/signatures).
-
-Here's an example `MakeSet` module function, that takes in a module of the type
-`Comparable` and returns a new set that can contain such comparable items.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-module type Comparable = {
-  type t
-  let equal: (t, t) => bool
-}
-
-module MakeSet = (Item: Comparable) => {
-  // let's use a list as our naive backing data structure
-  type backingType = list<Item.t>
-  let empty = list{}
-  let add = (currentSet: backingType, newItem: Item.t): backingType =>
-    // if item exists
-    if currentSet->List.some(x => Item.equal(x, newItem)) {
-      currentSet // return the same (immutable) set (a list really)
-    } else {
-      list{
-        newItem,
-        ...currentSet // prepend to the set and return it
-      }
-    }
-}
-```
-```js
-var List = require("./stdlib/list.js");
-
-function MakeSet(Item) {
-  var add = function(currentSet, newItem) {
-    if (
-      List.exists(function(x) {
-        return Item.equal(x, newItem);
-      }, currentSet)
-    ) {
-      return currentSet;
-    } else {
-      return {
-        hd: newItem,
-        tl: currentSet,
-      };
-    }
-  };
-  return {
-    empty: /* [] */ 0,
-    add: add,
-  };
-}
-```
-
-</CodeTab>
-
-Module functions can be applied using function application syntax. In this case, we're
-creating a set, whose items are pairs of integers.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module IntPair = {
-  type t = (int, int)
-  let equal = ((x1: int, y1: int), (x2, y2)) => x1 == x2 && y1 == y2
-  let create = (x, y) => (x, y)
-}
-
-/* IntPair abides by the Comparable signature required by MakeSet */
-module SetOfIntPairs = MakeSet(IntPair)
-```
-```js
-function equal(param, param$1) {
-  if (param[0] === param$1[0]) {
-    return param[1] === param$1[1];
-  } else {
-    return false;
-  }
-}
-
-function create(x, y) {
-  return [x, y];
-}
-
-var IntPair = {
-  equal: equal,
-  create: create,
-};
-
-var SetOfIntPairs = {
-  empty: /* [] */ 0,
-  add: add,
-};
-```
-
-</CodeTab>
-
-### Module functions types
-
-Like with module types, module function types also act to constrain and hide what we may
-assume about module functions. The syntax for module function types are consistent with those
-for function types, but with types capitalized to represent the signatures of
-modules the module functions accepts as arguments and return values. In the
-previous example, we're exposing the backing type of a set; by giving `MakeSet`
-a module function signature, we can hide the underlying data structure!
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-module type Comparable = ...
-
-module type MakeSetType = (Item: Comparable) => {
-  type backingType
-  let empty: backingType
-  let add: (backingType, Item.t) => backingType
-}
-
-module MakeSet: MakeSetType = (Item: Comparable) => {
-  ...
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Exotic Module Filenames
-
-**Since 8.3**
-
-It is possible to use non-conventional characters in your filenames (which is sometimes needed for specific JS frameworks). Here are some examples:
-
-- `src/Button.ios.res`
-- `pages/[id].res`
-
-Please note that modules with an exotic filename will not be accessible from other ReScript modules.
-
-## Tips & Tricks
-
-Modules and module functions are at a different "layer" of language than the rest (functions, let bindings, data structures, etc.). For example, you can't easily pass them into a tuple or record. Use them judiciously, if ever! Lots of times, just a record or a function is enough.
diff --git a/pages/docs/manual/v11.0.0/mutation.mdx b/pages/docs/manual/v11.0.0/mutation.mdx
deleted file mode 100644
index 33d4050f0..000000000
--- a/pages/docs/manual/v11.0.0/mutation.mdx
+++ /dev/null
@@ -1,75 +0,0 @@
----
-title: "Mutation"
-description: "Imperative and mutative programming capabilities in ReScript"
-canonical: "/docs/manual/v11.0.0/mutation"
----
-
-# Mutation
-
-ReScript has great traditional imperative & mutative programming capabilities. You should use these features sparingly, but sometimes they allow your code to be more performant and written in a more familiar pattern.
-
-## Mutate Let-binding
-
-Let-bindings are immutable, but you can wrap it with a `ref`, exposed as a record with a single mutable field in the standard library:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let myValue = ref(5)
-```
-```js
-var myValue = {
-  contents: 5
-};
-```
-
-</CodeTab>
-
-## Usage
-
-You can get the actual value of a `ref` box through accessing its `contents` field:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let five = myValue.contents // 5
-```
-```js
-var five = myValue.contents;
-```
-
-</CodeTab>
-
-Assign a new value to `myValue` like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-myValue.contents = 6
-```
-```js
-myValue.contents = 6;
-```
-
-</CodeTab>
-
-We provide a syntax sugar for this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-myValue := 6
-```
-```js
-myValue.contents = 6;
-```
-
-</CodeTab>
-
-Note that the previous binding `five` stays `5`, since it got the underlying item on the `ref` box, not the `ref` itself.
-
-**Note**: you might see in the JS output tabs above that `ref` allocates an object. Worry not; local, non-exported `ref`s allocations are optimized away.
-
-## Tip & Tricks
-
-Before reaching for `ref`, know that you can achieve lightweight, local "mutations" through [overriding let bindings](let-binding.md#binding-shadowing).
diff --git a/pages/docs/manual/v11.0.0/newcomer-examples.mdx b/pages/docs/manual/v11.0.0/newcomer-examples.mdx
deleted file mode 100644
index 30b241781..000000000
--- a/pages/docs/manual/v11.0.0/newcomer-examples.mdx
+++ /dev/null
@@ -1,134 +0,0 @@
----
-title: "Newcomer Examples"
-description: "Quick examples for users new to ReScript"
-canonical: "/docs/manual/v11.0.0/newcomer-examples"
----
-
-# Newcomer Examples
-
-<!-- TODO: this whole page needs a revamp -->
-
-An example is worth a thousand words.
-
-This section is dedicated to newcomers trying to figure out general idioms & conventions. If you're a beginner who's got a good idea for an example, please suggest an edit!
-
-## Use the [`option` type](null-undefined-option.md)
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let possiblyNullValue1 = None
-let possiblyNullValue2 = Some("Hello")
-
-switch possiblyNullValue2 {
-| None => Console.log("Nothing to see here.")
-| Some(message) => Console.log(message)
-}
-```
-```js
-var possiblyNullValue1;
-var possiblyNullValue2 = "Hello";
-
-if (possiblyNullValue2 !== undefined) {
-  console.log(possiblyNullValue2);
-} else {
-  console.log("Nothing to see here.");
-}
-
-```
-
-</CodeTab>
-
-## Create a Parametrized Type
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type universityStudent = {gpa: float}
-
-type response<'studentType> = {
-  status: int,
-  student: 'studentType,
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Creating a JS Object
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let student1 = {
-  "name": "John",
-  "age": 30,
-}
-```
-```js
-var student1 = {
-  name: "John",
-  age: 30,
-};
-```
-
-</CodeTab>
-
-Or using [record](record.md):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type payload = {
-  name: string,
-  age: int,
-}
-
-let student1 = {
-  name: "John",
-  age: 30,
-}
-```
-```js
-var student1 = {
-  name: "John",
-  age: 30,
-};
-```
-
-</CodeTab>
-
-## Modeling a JS Module with Default Export
-
-See [here](import-from-export-to-js.md#import-a-javascript-module-itself-es6-module-format).
-
-## Checking for JS nullable types using the `option` type
-
-For a function whose argument is passed a JavaScript value that's potentially `null` or `undefined`, it's idiomatic to convert it to an `option`. The conversion is done through the helper functions in ReScript's [`Nullable`](api/core/nullable#value-toOption) module. In this case, `toOption`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let greetByName = (possiblyNullName) => {
-  let optionName = Nullable.toOption(possiblyNullName)
-  switch optionName {
-  | None => "Hi"
-  | Some(name) => "Hello " ++ name
-  }
-}
-```
-```js
-function greetByName(possiblyNullName) {
-  if (possiblyNullName == null) {
-    return "Hi";
-  } else {
-    return "Hello " + possiblyNullName;
-  }
-}
-```
-
-</CodeTab>
-
-This check compiles to `possiblyNullName == null` in JS, so checks for the presence of `null` or `undefined`.
diff --git a/pages/docs/manual/v11.0.0/null-undefined-option.mdx b/pages/docs/manual/v11.0.0/null-undefined-option.mdx
deleted file mode 100644
index fc7bb5dbd..000000000
--- a/pages/docs/manual/v11.0.0/null-undefined-option.mdx
+++ /dev/null
@@ -1,203 +0,0 @@
----
-title: "Null, Undefined and Option"
-description: "JS interop with nullable and optional values in ReScript"
-canonical: "/docs/manual/v11.0.0/null-undefined-option"
----
-
-# Null, Undefined and Option
-
-ReScript itself doesn't have the notion of `null` or `undefined`. This is a _great_ thing, as it wipes out an entire category of bugs. No more `undefined is not a function`, and `cannot access someAttribute of undefined`!
-
-However, the **concept** of a potentially nonexistent value is still useful, and safely exists in our language.
-
-We represent the existence and nonexistence of a value by wrapping it with the `option` type. Here's its definition from the standard library:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type option<'a> = None | Some('a)
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-It means "a value of type option is either None (representing nothing) or that actual value wrapped in a Some".
-
-**Note** how the `option` type is just a regular [variant](variant.md).
-
-## Example
-
-Here's a normal value:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let licenseNumber = 5
-```
-```js
-var licenseNumber = 5;
-```
-
-</CodeTab>
-
-To represent the concept of "maybe null", you'd turn this into an `option` type by wrapping it. For the sake of a more illustrative example, we'll put a condition around it:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let licenseNumber =
-  if personHasACar {
-    Some(5)
-  } else {
-    None
-  }
-```
-```js
-var licenseNumber = personHasACar ? 5 : undefined;
-```
-
-</CodeTab>
-
-Later on, when another piece of code receives such value, it'd be forced to handle both cases through [pattern matching](pattern-matching-destructuring.md):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-switch licenseNumber {
-| None =>
-  Console.log("The person doesn't have a car")
-| Some(number) =>
-  Console.log("The person's license number is " ++ Int.toString(number))
-}
-```
-```js
-var number = licenseNumber;
-
-if (number !== undefined) {
-  console.log("The person's license number is " + number.toString());
-} else {
-  console.log("The person doesn't have a car");
-}
-```
-
-</CodeTab>
-
-By turning your ordinary number into an `option` type, and by forcing you to handle the `None` case, the language effectively removed the possibility for you to mishandle, or forget to handle, a conceptual `null` value! **A pure ReScript program doesn't have null errors**.
-
-## Interoperate with JavaScript `undefined` and `null`
-
-The `option` type is common enough that we special-case it when compiling to JavaScript:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let x = Some(5)
-```
-```js
-var x = 5;
-```
-
-</CodeTab>
-
-simply compiles down to `5`, and
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let x = None
-```
-```js
-var x;
-```
-
-</CodeTab>
-
-compiles to `undefined`! If you've got e.g. a string in JavaScript that you know might be `undefined`, type it as `option<string>` and you're done! Likewise, you can send a `Some(5)` or `None` to the JS side and expect it to be interpreted correctly =)
-
-### Caveat 1
-
-The option-to-undefined translation isn't perfect, because on our side, `option` values can be composed:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let x = Some(Some(Some(5)))
-```
-```js
-var x = 5;
-```
-
-</CodeTab>
-
-This still compiles to `5`, but this gets troublesome:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let x = Some(None)
-```
-```js
-var Caml_option = require("./stdlib/caml_option.js");
-
-var x = Caml_option.some(undefined);
-```
-
-(See output tab).
-
-</CodeTab>
-
-What's this `Caml_option.some` thing? Why can't this compile to `undefined`? Long story short, when dealing with a polymorphic `option` type (aka `option<'a>`, for any `'a`), many operations become tricky if we don't mark the value with some special annotation. If this doesn't make sense, don't worry; just remember the following rule:
-
-- **Never, EVER, pass a nested `option` value (e.g. `Some(Some(Some(5)))`) into the JS side.**
-- **Never, EVER, annotate a value coming from JS as `option<'a>`. Always give the concrete, non-polymorphic type.**
-
-### Caveat 2
-
-Unfortunately, lots of times, your JavaScript value might be _both_ `null` or `undefined`. In that case, you unfortunately can't type such value as e.g. `option<int>`, since our `option` type only checks for `undefined` and not `null` when dealing with a `None`.
-
-#### Solution: More Sophisticated `undefined` & `null` Interop
-
-To solve this, we provide access to more elaborate `null` and `undefined` helpers through the [`Nullable`](api/core/nullable) module. This somewhat works like an `option` type, but is different from it.
-
-#### Examples
-
-To create a JS `null`, use the value `Nullable.null`. To create a JS `undefined`, use `Nullable.undefined` (you can naturally use `None` too, but that's not the point here; the `Nullable.*` helpers wouldn't work with it).
-
-If you're receiving, for example, a JS string that can be `null` and `undefined`, type it as:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("MyConstant") external myId: Nullable.t<string> = "myId"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-To create such a nullable string from our side (presumably to pass it to the JS side, for interop purpose), do:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("MyIdValidator") external validate: Nullable.t<string> => bool = "validate"
-let personId: Nullable.t<string> = Nullable.make("abc123")
-
-let result = validate(personId)
-```
-```js
-var MyIdValidator = require("MyIdValidator");
-var personId = "abc123";
-var result = MyIdValidator.validate(personId);
-```
-
-</CodeTab>
-
-The `return` part "wraps" a string into a nullable string, to make the type system understand and track the fact that, as you pass this value around, it's not just a string, but a string that can be `null` or `undefined`.
-
-#### Convert to/from `option`
-
-`Nullable.fromOption` converts from a `option` to `Nullable.t`. `Nullable.toOption` does the opposite.
diff --git a/pages/docs/manual/v11.0.0/object.mdx b/pages/docs/manual/v11.0.0/object.mdx
deleted file mode 100644
index 6a16984ab..000000000
--- a/pages/docs/manual/v11.0.0/object.mdx
+++ /dev/null
@@ -1,195 +0,0 @@
----
-title: "Object"
-description: "Interoping with JS objects in ReScript"
-canonical: "/docs/manual/v11.0.0/object"
----
-
-# Object
-
-ReScript objects are like [records](record.md), but:
-
-- No type declaration needed.
-- Structural and more polymorphic, [unlike records](record.md#record-types-are-found-by-field-name).
-- Doesn't support updates unless the object comes from the JS side.
-- Doesn't support [pattern matching](pattern-matching-destructuring).
-
-<!-- TODO: support update man -->
-
-Although ReScript records compile to clean JavaScript objects, ReScript objects are a better candidate for emulating/binding to JS objects, as you'll see.
-
-## Type Declaration
-
-**Optional**, unlike for records. The type of an object is inferred from the value, so you never really need to write down its type definition. Nevertheless, here's its type declaration syntax:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type person = {
-  "age": int,
-  "name": string
-};
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Visually similar to record type's syntax, with the field names quoted.
-
-<!-- TODO: document {.} and {..} -->
-
-## Creation
-
-To create a new object:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let me = {
-  "age": 5,
-  "name": "Big ReScript"
-}
-```
-```js
-var me = {
-  "age": 5,
-  "name": "Big ReScript"
-};
-```
-
-</CodeTab>
-
-**Note**: as said above, unlike for record, this `me` value does **not** try to find a conforming type declaration with the field `"age"` and `"name"`; rather, the type of `me` is inferred as `{"age": int, "name": string}`. This is convenient, but also means this code passes type checking without errors:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type person = {
-  "age": int
-};
-
-let me = {
-  "age": "hello!" // age is a string. No error.
-}
-```
-```js
-var me = {
-  "age": "hello!"
-};
-```
-
-</CodeTab>
-
-Since the type checker doesn't try to match `me` with the type `person`. If you ever want to force an object value to be of a predeclared object type, just annotate the value:
-
-```res
-let me: person = {
-  "age": "hello!"
-}
-```
-
-Now the type system will error properly.
-
-## Access
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let age = me["age"]
-```
-```js
-var age = me["age"];
-```
-
-</CodeTab>
-
-## Update
-
-Disallowed unless the object is a binding that comes from the JavaScript side. In that case, use `=`
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type student = {
-  @set "age": int,
-  @set "name": string,
-}
-@module("MyJSFile") external student1: student = "student1"
-
-student1["name"] = "Mary"
-```
-```js
-var MyJSFile = require("MyJSFile");
-MyJSFile.student1.name = "Mary";
-```
-
-</CodeTab>
-
-## Combine Types
-
-You can spread one object type definition into another using `...`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type point2d = {
-  "x": float,
-  "y": float,
-}
-type point3d = {
-  ...point2d,
-  "z": float,
-}
-
-let myPoint: point3d = {
-  "x": 1.0,
-  "y": 2.0,
-  "z": 3.0,
-}
-```
-```js
-var myPoint = {
-  x: 1.0,
-  y: 2.0,
-  z: 3.0
-};
-```
-
-</CodeTab>
-
-This only works with object types, not object values!
-
-## Tips & Tricks
-
-Since objects don't require type declarations, and since ReScript infers all the types for you, you get to very quickly and easily (and dangerously) bind to any JavaScript API. Check the JS output tab:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// The type of document is just some random type 'a
-// that we won't bother to specify
-@val external document: 'a = "document"
-
-// call a method
-document["addEventListener"]("mouseup", _event => {
-  Console.log("clicked!")
-})
-
-// get a property
-let loc = document["location"]
-
-// set a property
-document["location"]["href"] = "rescript-lang.org"
-```
-```js
-document.addEventListener("mouseup", function(_event) {
-  console.log("clicked!");
-});
-var loc = document.location;
-document.location.href = "rescript-lang.org";
-```
-
-</CodeTab>
-
-The `external` feature and the usage of this trick are also documented in the [external](external#tips--tricks) section later. It's an excellent way to start writing some ReScript code without worrying about whether bindings to a particular library exists.
diff --git a/pages/docs/manual/v11.0.0/overview.mdx b/pages/docs/manual/v11.0.0/overview.mdx
deleted file mode 100644
index 53f8a7cfa..000000000
--- a/pages/docs/manual/v11.0.0/overview.mdx
+++ /dev/null
@@ -1,255 +0,0 @@
----
-title: "Overview"
-metaTitle: "Language Features Overview"
-description: "A quick overview on ReScript's syntax"
-canonical: "/docs/manual/v11.0.0/overview"
----
-
-# Overview
-
-## Comparison to JS
-
-### Semicolon
-
-| JavaScript                         | ReScript             |
-| ---------------------------------- | -------------------- |
-| Rules enforced by linter/formatter | No semicolon needed! |
-
-### Comments
-
-| JavaScript           | ReScript                         |
-| -------------------- | -------------------------------- |
-| `// Line comment`    | Same                             |
-| `/* Comment */`      | Same                             |
-| `/** Doc Comment */` | `/** Before Types/Values */`     |
-|                      | `/*** Standalone Doc Comment */` |
-
-### Variable
-
-| JavaScript              | ReScript                              |
-| ----------------------- | ------------------------------------- |
-| `const x = 5;`          | `let x = 5`                           |
-| `var x = y;`            | No equivalent (thankfully)            |
-| `let x = 5; x = x + 1;` | `let x = ref(5); x := x.contents + 1` |
-
-### String & Character
-
-| JavaScript                   | ReScript              |
-| ---------------------------- | --------------------- |
-| `"Hello world!"`             | Same                  |
-| `'Hello world!'`             | Strings must use `"`  |
-| `"hello " + "world"`         | `"hello " ++ "world"` |
-| `` `hello ${message}` ``     | Same                  |
-| `` sql`select ${fnName};` `` | Same                  |
-
-### Boolean
-
-| JavaScript                           | ReScript                                       |
-| ------------------------------------ | ---------------------------------------------- |
-| `true`, `false`                      | Same                                           |
-| `!true`                              | Same                                           |
-| `\|\|`, `&&`, `<=`, `>=`, `<`, `>`   | Same                                           |
-| `a === b`, `a !== b`                 | Same                                           |
-| No deep equality (recursive compare) | `a == b`, `a != b`                             |
-| `a == b`                             | No equality with implicit casting (thankfully) |
-
-### Number
-
-| JavaScript  | ReScript     |
-| ----------- | ------------ |
-| `3`         | Same \*      |
-| `3.1415`    | Same         |
-| `3 + 4`     | Same         |
-| `3.0 + 4.5` | `3.0 +. 4.5` |
-| `5 % 3`     | `mod(5, 3)`  |
-
-\* JS has no distinction between integer and float.
-
-### Object/Record
-
-| JavaScript          | ReScript                                |
-| ------------------- | --------------------------------------- |
-| no types            | `type point = {x: int, mutable y: int}` |
-| `{x: 30, y: 20}`    | Same                                    |
-| `point.x`           | Same                                    |
-| `point.y = 30;`     | Same                                    |
-| `{...point, x: 30}` | Same                                    |
-
-### Array
-
-| JavaScript         | ReScript              |
-| ------------------ | --------------------- |
-| `[1, 2, 3]`        | Same                  |
-| `myArray[1] = 10`  | Same                  |
-| `[1, "Bob", true]` | `(1, "Bob", true)` \* |
-
-\* ReScript does not have heterogenous arrays. Use tuples or [Untagged Variants](variant#untagged-variants) instead.
-
-### Null
-
-| JavaScript          | ReScript  |
-| ------------------- | --------- |
-| `null`, `undefined` | `None` \* |
-
-\* Again, only a spiritual equivalent; we don't have nulls, nor null bugs! But we do have an `option` type for when you actually need nullability.
-
-### Function
-
-| JavaScript                      | ReScript                     |
-| ------------------------------- | ---------------------------- |
-| `arg => retVal`                 | Same                         |
-| `function named(arg) {...}`     | `let named = (arg) => {...}` |
-| `const f = function(arg) {...}` | `let f = (arg) => {...}`     |
-| `add(4, add(5, 6))`             | Same                         |
-
-### Async Function / Await
-
-| JavaScript                              | ReScript                                              |
-| --------------------------------------- | ----------------------------------------------------- |
-| `async (arg) => {...}`                  | Same                                                  |
-| `async function named(arg) {...}`       | `let named = async (arg) => {...}`                    |
-| `await somePromise`                     | Same                                                  |
-| `async (arg): Promise<string> => {...}` | `async (arg): string => {...}` (note the return type) |
-
-### Blocks
-
-<table>
-  <thead>
-    <tr>
-      <th>JavaScript</th>
-      <th>ReScript</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>
-      ```
-      const myFun = (x, y) => {
-        const doubleX = x + x;
-        const doubleY = y + y;
-        return doubleX + doubleY;
-      };
-      ```
-      </td>
-      <td>
-      ```
-      let myFun = (x, y) => {
-        let doubleX = x + x
-        let doubleY = y + y
-        doubleX + doubleY
-      }
-      ```
-      </td>
-    </tr>
-  </tbody>
-</table>
-
-### If-else
-
-| JavaScript            | ReScript                                                                          |
-| --------------------- | --------------------------------------------------------------------------------- |
-| `if (a) {b} else {c}` | `if a {b} else {c}` \*                                                            |
-| `a ? b : c`           | Same                                                                              |
-| `switch`              | `switch` but [super-powered pattern matching!](pattern-matching-destructuring.md) |
-
-\* Our conditionals are always expressions! You can write `let result = if a {"hello"} else {"bye"}`
-
-### Destructuring
-
-| JavaScript                    | ReScript                    |
-| ----------------------------- | --------------------------- |
-| `const {a, b} = data`         | `let {a, b} = data`         |
-| `const [a, b] = data`         | `let [a, b] = data` \*      |
-| `const {a: aa, b: bb} = data` | `let {a: aa, b: bb} = data` |
-
-\* Gives good compiler warning that `data` might not be of length 2.
-
-### Loop
-
-| JavaScript                            | ReScript                     |
-| ------------------------------------- | ---------------------------- |
-| `for (let i = 0; i <= 10; i++) {...}` | `for i in 0 to 10 {...}`     |
-| `for (let i = 10; i >= 0; i--) {...}` | `for i in 10 downto 0 {...}` |
-| `while (true) {...}`                  | `while true {...}`           |
-
-### JSX
-
-| JavaScript                                | ReScript                   |
-| ----------------------------------------- | -------------------------- |
-| `<Comp message="hi" onClick={handler} />` | Same                       |
-| `<Comp message={message} />`              | `<Comp message />` \*      |
-| `<input checked />`                       | `<input checked=true />`   |
-| No children spread                        | `<Comp>...children</Comp>` |
-
-\* Argument punning!
-
-### Exception
-
-| JavaScript                                | ReScript                                     |
-| ----------------------------------------- | -------------------------------------------- |
-| `throw new SomeError(...)`                | `raise(SomeError(...))`                      |
-| `try {a} catch (err) {...} finally {...}` | `try a catch { \| SomeError(err) => ...}` \* |
-
-\* No finally.
-
-### Blocks
-
-The last expression of a block delimited by `{}` implicitly returns (including function body). In JavaScript, this can only be simulated via an immediately-invoked function expression (since function bodies have their own local scope).
-
-<table>
-  <thead>
-    <tr>
-      <th>JavaScript</th>
-      <th>ReScript</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>
-      ```
-      let result = (function() {
-        const x = 23;
-        const y = 34;
-        return x + y;
-      })();
-      ```
-      </td>
-      <td>
-      ```
-      let result = {
-        let x = 23
-        let y = 34
-        x + y
-      }
-      ```
-      </td>
-    </tr>
-  </tbody>
-</table>
-
-## Common Features' JS Output
-
-| Feature                         | Example                              | JavaScript Output                          |
-| ------------------------------- | ------------------------------------ | ------------------------------------------ |
-| String                          | `"Hello"`                            | `"Hello"`                                  |
-| String Interpolation            | `` `Hello ${message}` ``             | `"Hello " + message`                       |
-| Character (disrecommended)      | `'x'`                                | `120` (char code)                          |
-| Integer                         | `23`, `-23`                          | `23`, `-23`                                |
-| Float                           | `23.0`, `-23.0`                      | `23.0`, `-23.0`                            |
-| Integer Addition                | `23 + 1`                             | `23 + 1`                                   |
-| Float Addition                  | `23.0 +. 1.0`                        | `23.0 + 1.0`                               |
-| Integer Division/Multiplication | `2 / 23 * 1`                         | `2 / 23 * 1`                               |
-| Float Division/Multiplication   | `2.0 /. 23.0 *. 1.0`                 | `2.0 / 23.0 * 1.0`                         |
-| Float Exponentiation            | `2.0 ** 3.0`                         | `Math.pow(2.0, 3.0)`                       |
-| String Concatenation            | `"Hello " ++ "World"`                | `"Hello " + "World"`                       |
-| Comparison                      | `>`, `<`, `>=`, `<=`                 | `>`, `<`, `>=`, `<=`                       |
-| Boolean operation               | `!`, `&&`, `\|\|`                    | `!`, `&&`, `\|\|`                          |
-| Shallow and deep Equality       | `===`, `==`                          | `===`, `==`                                |
-| List (disrecommended)           | `list{1, 2, 3}`                      | `{hd: 1, tl: {hd: 2, tl: {hd: 3, tl: 0}}}` |
-| List Prepend                    | `list{a1, a2, ...oldList}`           | `{hd: a1, tl: {hd: a2, tl: theRest}}`      |
-| Array                           | `[1, 2, 3]`                          | `[1, 2, 3]`                                |
-| Record                          | `type t = {b: int}; let a = {b: 10}` | `var a = {b: 10}`                          |
-| Multiline Comment               | `/* Comment here */`                 | Not in output                              |
-| Single line Comment             | `// Comment here`                    | Not in output                              |
-
-_Note that this is a cleaned-up comparison table; a few examples' JavaScript output are slightly different in reality._
diff --git a/pages/docs/manual/v11.0.0/pattern-matching-destructuring.mdx b/pages/docs/manual/v11.0.0/pattern-matching-destructuring.mdx
deleted file mode 100644
index 64e8a445c..000000000
--- a/pages/docs/manual/v11.0.0/pattern-matching-destructuring.mdx
+++ /dev/null
@@ -1,864 +0,0 @@
----
-title: "Pattern Matching / Destructuring"
-description: "Pattern matching and destructuring complex data structures in ReScript"
-canonical: "/docs/manual/v11.0.0/pattern-matching-destructuring"
----
-
-# Pattern Matching / Destructuring
-
-One of ReScript's **best** feature is our pattern matching. Pattern matching combines 3 brilliant features into one:
-
-- Destructuring.
-- `switch` based on shape of data.
-- Exhaustiveness check.
-
-We'll dive into each aspect below.
-
-## Destructuring
-
-Even JavaScript has destructuring, which is "opening up" a data structure to extract the parts we want and assign variable names to them:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let coordinates = (10, 20, 30)
-let (x, _, _) = coordinates
-Console.log(x) // 10
-```
-```js
-var coordinates = [10, 20, 30];
-var x = 10;
-console.log(10);
-```
-
-</CodeTab>
-
-Destructuring works with most built-in data structures:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Record
-type student = {name: string, age: int}
-let student1 = {name: "John", age: 10}
-let {name} = student1 // "John" assigned to `name`
-
-// Variant
-type result =
-  | Success(string)
-let myResult = Success("You did it!")
-let Success(message) = myResult // "You did it!" assigned to `message`
-```
-```js
-var student1 = {
-  name: "John",
-  age: 10
-};
-var name = "John";
-
-var myResult = /* Success */{
-  _0: "You did it!"
-};
-var message = "You did it!"
-
-var myArray = [1, 2, 3];
-if (myArray.length !== 2) {
-  throw {
-    RE_EXN_ID: "Match_failure",
-    _1: [
-      "playground.res",
-      14,
-      4
-    ],
-    Error: new Error()
-  };
-}
-var item1 = myArray[0];
-var item2 = myArray[1];
-
-var myList = {
-  hd: 1,
-  tl: {
-    hd: 2,
-    tl: {
-      hd: 3,
-      tl: /* [] */0
-    }
-  }
-};
-// ...
-```
-
-</CodeTab>
-
-You can also use destructuring anywhere you'd usually put a binding:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type result =
-  | Success(string)
-let displayMessage = (Success(m)) => {
-  // we've directly extracted the success message
-  // string by destructuring the parameter
-  Console.log(m)
-}
-displayMessage(Success("You did it!"))
-```
-```js
-function displayMessage(m) {
-  console.log(m._0);
-}
-
-displayMessage(/* Success */{
-  _0: "You did it!"
-});
-```
-
-</CodeTab>
-
-For a record, you can rename the field while destructuring:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let {name: n} = student1 // "John" assigned to `n`
-```
-```js
-var n = "John";
-```
-
-</CodeTab>
-
-You _can_ in theory destructure array and list at the top level too:
-
-```res
-let myArray = [1, 2, 3]
-let [item1, item2, _] = myArray
-// 1 assigned to `item1`, 2 assigned to `item2`, 3rd item ignored
-
-let myList = list{1, 2, 3}
-let list{head, ...tail} = myList
-// 1 assigned to `head`, `list{2, 3}` assigned to tail
-```
-
-But the array example is **highly disrecommended** (use tuple instead) and the list example will error on you. They're only there for completeness' sake. As you'll see below, the proper way of using destructuring array and list is using `switch`.
-
-## `switch` Based on Shape of Data
-
-While the destructuring aspect of pattern matching is nice, it doesn't really change the way you think about structuring your code. One paradigm-changing way of thinking about your code is to execute some code based on the shape of the data.
-
-Consider a variant:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type payload =
-  | BadResult(int)
-  | GoodResult(string)
-  | NoResult
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-We'd like to handle each of the 3 cases differently. For example, print a success message if the value is `GoodResult(...)`, do something else when the value is `NoResult`, etc.
-
-In other languages, you'd end up with a series of if-elses that are hard to read and error-prone. In ReScript, you can instead use the supercharged `switch` pattern matching facility to destructure the value while calling the right code based on what you destructured:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let data = GoodResult("Product shipped!")
-switch data {
-| GoodResult(theMessage) =>
-  Console.log("Success! " ++ theMessage)
-| BadResult(errorCode) =>
-  Console.log("Something's wrong. The error code is: " ++ Int.toString(errorCode))
-| NoResult =>
-  Console.log("Bah.")
-}
-```
-```js
-var data = {
-  TAG: "GoodResult",
-  _0: "Product shipped!"
-};
-
-if (typeof data !== "object") {
-  console.log("Bah.");
-} else if (data.TAG === "BadResult") {
-  console.log("Something's wrong. The error code is: " + "Product shipped!".toString());
-} else {
-  console.log("Success! Product shipped!");
-}
-```
-
-</CodeTab>
-
-In this case, `message` will have the value `"Success! Product shipped!"`.
-
-Suddenly, your if-elses that messily checks some structure of the value got turned into a clean, compiler-verified, linear list of code to execute based on exactly the shape of the value.
-
-### Complex Examples
-
-Here's a real-world scenario that'd be a headache to code in other languages. Given this data structure:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type status = Vacations(int) | Sabbatical(int) | Sick | Present
-type reportCard = {passing: bool, gpa: float}
-type student = {name: string, status: status, reportCard: reportCard}
-type person =
-  | Teacher({name: string, age: int})
-  | Student(student)
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Imagine this requirement:
-
-- Informally greet a person who's a teacher and if his name is Mary or Joe.
-- Greet other teachers formally.
-- If the person's a student, congratulate him/her score if they passed the semester.
-- If the student has a gpa of 0 and is on vacations or sabbatical, display a different message.
-- A catch-all message for a student.
-
-ReScript can do this easily!
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let person1 = Teacher({name: "Jane", age: 35})
-
-let message = switch person1 {
-| Teacher({name: "Mary" | "Joe"}) =>
-  `Hey, still going to the party on Saturday?`
-| Teacher({name}) =>
-  // this is matched only if `name` isn't "Mary" or "Joe"
-  `Hello ${name}.`
-| Student({name, reportCard: {passing: true, gpa}}) =>
-  `Congrats ${name}, nice GPA of ${Float.toString(gpa)} you got there!`
-| Student({
-    reportCard: {gpa: 0.0},
-    status: Vacations(daysLeft) | Sabbatical(daysLeft)
-  }) =>
-  `Come back in ${Int.toString(daysLeft)} days!`
-| Student({status: Sick}) =>
-  `How are you feeling?`
-| Student({name}) =>
-  `Good luck next semester ${name}!`
-}
-```
-```js
-var person1 = {
-  TAG: "Teacher",
-  name: "Jane",
-  age: 35
-};
-
-var message;
-
-if (person1.TAG === "Teacher") {
-  message = "Hello Jane.";
-} else {
-  var match = "Jane";
-  var match$1 = match.status;
-  var name = match.name;
-  var match$2 = match.reportCard;
-  if (match$2.passing) {
-    message = "Congrats " + name + ", nice GPA of " + match$2.gpa.toString() + " you got there!";
-  } else {
-    var exit = 0;
-    if (typeof match$1 !== "object") {
-      message = match$1 === "Sick" ? "How are you feeling?" : "Good luck next semester " + name + "!";
-    } else {
-      exit = 1;
-    }
-    if (exit === 1) {
-      message = match.reportCard.gpa !== 0.0 ? "Good luck next semester " + name + "!" : "Come back in " + match$1._0.toString() + " days!";
-    }
-    
-  }
-}
-```
-
-</CodeTab>
-
-**Note** how we've:
-- drilled deep down into the value concisely
-- using a **nested pattern check** `"Mary" | "Joe"` and `Vacations | Sabbatical`
-- while extracting the `daysLeft` number from the latter case
-- and assigned the greeting to the binding `message`.
-
-Here's another example of pattern matching, this time on an inline tuple.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type animal = Dog | Cat | Bird
-let categoryId = switch (isBig, myAnimal) {
-| (true, Dog) => 1
-| (true, Cat) => 2
-| (true, Bird) => 3
-| (false, Dog | Cat) => 4
-| (false, Bird) => 5
-}
-```
-```js
-var categoryId = isBig ? (myAnimal + 1) | 0 : myAnimal >= 2 ? 5 : 4;
-```
-
-</CodeTab>
-
-**Note** how pattern matching on a tuple is equivalent to a 2D table:
-
-isBig \ myAnimal | Dog | Cat | Bird
------------------|-----|-----|------
-true             |  1  |  2  |  3
-false            |  4  |  4  |  5
-
-### Fall-Through Patterns
-
-The nested pattern check, demonstrated in the earlier `person` example, also works at the top level of a `switch`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let myStatus = Vacations(10)
-
-switch myStatus {
-| Vacations(days)
-| Sabbatical(days) => Console.log(`Come back in ${Int.toString(days)} days!`)
-| Sick
-| Present => Console.log("Hey! How are you?")
-}
-```
-```js
-var myStatus = {
-  TAG: /* Vacations */0,
-  _0: 10
-};
-
-if (typeof myStatus === "number") {
-  console.log("Hey! How are you?");
-} else {
-  console.log("Come back in " + (10).toString() + " days!");
-}
-```
-
-</CodeTab>
-
-Having multiple cases fall into the same handling can clean up certain types of logic.
-
-### Ignore Part of a Value
-
-If you have a value like `Teacher(payload)` where you just want to pattern match on the `Teacher` part and ignore the `payload` completely, you can use the `_` wildcard like this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch person1 {
-| Teacher(_) => Console.log("Hi teacher")
-| Student(_) => Console.log("Hey student")
-}
-```
-```js
-if (person1.TAG === "Teacher") {
-  console.log("Hi teacher");
-} else {
-  console.log("Hey student");
-}
-```
-
-</CodeTab>
-
-`_` also works at the top level of the `switch`, serving as a catch-all condition:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch myStatus {
-| Vacations(_) => Console.log("Have fun!")
-| _ => Console.log("Ok.")
-}
-```
-```js
-if (typeof myStatus !== "object" || myStatus.TAG !== "Vacations") {
-  console.log("Ok.");
-} else {
-  console.log("Have fun!");
-}
-```
-
-</CodeTab>
-
-**Do not** abuse a top-level catch-all condition. Instead, prefer writing out all the cases:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch myStatus {
-| Vacations(_) => Console.log("Have fun!")
-| Sabbatical(_) | Sick | Present => Console.log("Ok.")
-}
-```
-```js
-if (typeof myStatus !== "object" || myStatus.TAG !== "Vacations") {
-  console.log("Ok.");
-} else {
-  console.log("Have fun!");
-}
-```
-
-</CodeTab>
-
-Slightly more verbose, but a one-time writing effort. This helps when you add a new variant case e.g. `Quarantined` to the `status` type and need to update the places that pattern match on it. A top-level wildcard here would have accidentally and silently continued working, potentially causing bugs.
-
-### If Clause
-
-Sometime, you want to check more than the shape of a value. You want to also run some arbitrary check on it. You might be tempted to write this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch person1 {
-| Teacher(_) => () // do nothing
-| Student({reportCard: {gpa}}) =>
-  if gpa < 0.5 {
-    Console.log("What's happening")
-  } else {
-    Console.log("Heyo")
-  }
-}
-```
-```js
-if (person1.TAG !== "Teacher") {
-  if ("Jane".reportCard.gpa < 0.5) {
-    console.log("What's happening");
-  } else {
-    console.log("Heyo");
-  }
-}
-```
-
-</CodeTab>
-
-`switch` patterns support a shortcut for the arbitrary `if` check, to keep your pattern linear-looking:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch person1 {
-| Teacher(_) => () // do nothing
-| Student({reportCard: {gpa}}) if gpa < 0.5 =>
-  Console.log("What's happening")
-| Student(_) =>
-  // fall-through, catch-all case
-  Console.log("Heyo")
-}
-```
-```js
-if (person1.TAG) {
-  if (person1.reportCard.gpa < 0.5) {
-    console.log("What's happening");
-  } else {
-    console.log("Heyo");
-  }
-}
-```
-
-</CodeTab>
-
-**Note:** Rescript versions < 9.0 had a `when` clause, not an `if` clause.  Rescript 9.0 changed `when` to `if`.  (`when` may still work, but is deprecated.)
-
-### Match on Exceptions
-
-If the function throws an exception (covered later), you can also match on _that_, in addition to the function's normally returned values.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-switch List.find(i => i === theItem, myItems) {
-| item => Console.log(item)
-| exception Not_found => Console.log("No such item found!")
-}
-```
-```js
-var exit = 0;
-
-var item;
-
-try {
-  item = List.find(function(i) {
-    return i === theItem;
-  }, myItems);
-  exit = 1;
-}
-catch (raw_exn){
-  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-  if (exn.RE_EXN_ID === "Not_found") {
-    console.log("No such item found!");
-  } else {
-    throw exn;
-  }
-}
-
-if (exit === 1) {
-  console.log(item);
-}
-```
-
-</CodeTab>
-
-### Match on Array
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let students = ["Jane", "Harvey", "Patrick"]
-switch students {
-| [] => Console.log("There are no students")
-| [student1] =>
-  Console.log("There's a single student here: " ++ student1)
-| manyStudents =>
-  // display the array of names
-  Console.log2("The students are: ", manyStudents)
-}
-```
-```js
-var students = ["Jane", "Harvey", "Patrick"];
-
-var len = students.length;
-
-if (len !== 1) {
-  if (len !== 0) {
-    console.log("The students are: ", students);
-  } else {
-    console.log("There are no students");
-  }
-} else {
-  var student1 = students[0];
-  console.log("There's a single student here: " + student1);
-}
-```
-
-</CodeTab>
-
-### Match on List
-
-Pattern matching on list is similar to array, but with the extra feature of extracting the tail of a list (all elements except the first one):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let rec printStudents = (students) => {
-  switch students {
-  | list{} => () // done
-  | list{student} => Console.log("Last student: " ++ student)
-  | list{student1, ...otherStudents} =>
-    Console.log(student1)
-    printStudents(otherStudents)
-  }
-}
-printStudents(list{"Jane", "Harvey", "Patrick"})
-```
-```js
-function printStudents(_students) {
-  while(true) {
-    var students = _students;
-    if (!students) {
-      return;
-    }
-    var otherStudents = students.tl;
-    var student = students.hd;
-    if (otherStudents) {
-      console.log(student);
-      _students = otherStudents;
-      continue;
-    }
-    console.log("Last student: " + student);
-    return;
-  };
-}
-
-printStudents({
-  hd: "Jane",
-  tl: {
-    hd: "Harvey",
-    tl: {
-      hd: "Patrick",
-      tl: /* [] */0
-    }
-  }
-});
-```
-
-</CodeTab>
-
-
-### Small Pitfall
-
-**Note**: you can only pass literals (i.e. concrete values) as a pattern, not let-binding names or other things. The following doesn't work as expected:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let coordinates = (10, 20, 30)
-let centerY = 20
-switch coordinates {
-| (x, _centerY, _) => Console.log(x)
-}
-```
-```js
-var coordinates = [10, 20, 30];
-var centerY = 20;
-
-console.log(10);
-```
-
-</CodeTab>
-
-A first time ReScript user might accidentally write that code, assuming that it's matching on `coordinates` when the second value is of the same value as `centerY`. In reality, this is interpreted as matching on coordinates and assigning the second value of the tuple to the name `centerY`, which isn't what's intended.
-
-## Exhaustiveness Check
-
-As if the above features aren't enough, ReScript also provides arguably the most important pattern matching feature: **compile-time check of missing patterns**.
-
-Let's revisit one of the above examples:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let message = switch person1 {
-| Teacher({name: "Mary" | "Joe"}) =>
-  `Hey, still going to the party on Saturday?`
-| Student({name, reportCard: {passing: true, gpa}}) =>
-  `Congrats ${name}, nice GPA of ${Float.toString(gpa)} you got there!`
-| Student({
-    reportCard: {gpa: 0.0},
-    status: Vacations(daysLeft) | Sabbatical(daysLeft)
-  }) =>
-  `Come back in ${Int.toString(daysLeft)} days!`
-| Student({status: Sick}) =>
-  `How are you feeling?`
-| Student({name}) =>
-  `Good luck next semester ${name}!`
-}
-```
-```js
-if (person1.TAG) {
-  var match$1 = person1.status;
-  var name = person1.name;
-  var match$2 = person1.reportCard;
-  if (match$2.passing) {
-    "Congrats " + name + ", nice GPA of " + match$2.gpa.toString() + " you got there!";
-  } else if (typeof match$1 === "number") {
-    if (match$1 !== 0) {
-      "Good luck next semester " + name + "!";
-    } else {
-      "How are you feeling?";
-    }
-  } else if (person1.reportCard.gpa !== 0.0) {
-    "Good luck next semester " + name + "!";
-  } else {
-    "Come back in " + match$1._0.toString() + " days!";
-  }
-} else {
-  switch (person1.name) {
-    case "Joe":
-    case "Mary":
-      break;
-    default:
-      throw {
-        RE_EXN_ID: "Match_failure",
-        _1: [
-          "playground.res",
-          13,
-          0
-        ],
-        Error: new Error()
-      };
-  }
-}
-```
-
-</CodeTab>
-
-Did you see what we removed? This time, we've omitted the handling of the case where `person1` is `Teacher({name})` when `name` isn't Mary or Joe.
-
-Failing to handle every scenario of a value likely constitutes the majority of program bugs out there. This happens very often when you refactor a piece of code someone else wrote. Fortunately for ReScript, the compiler will tell you so:
-
-```
-Warning 8: this pattern-matching is not exhaustive.
-Here is an example of a value that is not matched:
-Some({name: ""})
-```
-
-**BAM**! You've just erased an entire category of important bugs before you even ran the code. In fact, this is how most of nullable values is handled:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myNullableValue = Some(5)
-
-switch myNullableValue {
-| Some(_v) => Console.log("value is present")
-| None => Console.log("value is absent")
-}
-```
-```js
-var myNullableValue = 5;
-
-if (myNullableValue !== undefined) {
-  console.log("value is present");
-} else {
-  console.log("value is absent");
-}
-```
-
-</CodeTab>
-
-If you don't handle the `None` case, the compiler warns. No more `undefined` bugs in your code!
-
-## Conclusion & Tips & Tricks
-
-Hopefully you can see how pattern matching is a game changer for writing correct code, through the concise destructuring syntax, the proper conditions handling of `switch`, and the static exhaustiveness check.
-
-Below is some advice:
-
-Avoid using the wildcard `_` unnecessarily.  Using the wildcard `_` will bypass the compiler's exhaustiveness check.  Consequently, the compiler will not be able to notify you of probable errors when you add a new case to a variant. Try only using `_` against infinite possibilities, e.g. string, int, etc.
-
-Use the `if` clause sparingly.
-
-**Flatten your pattern-match whenever you can**. This is a real bug remover. Here's a series of examples, from worst to best:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let optionBoolToBool = opt => {
-  if opt == None {
-    false
-  } else if opt === Some(true) {
-    true
-  } else {
-    false
-  }
-}
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt === undefined) {
-    return false;
-  } else {
-    return opt === true;
-  }
-}
-```
-
-</CodeTab>
-
-Now that's just silly =). Let's turn it into pattern-matching:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let optionBoolToBool = opt => {
-  switch opt {
-  | None => false
-  | Some(a) => a ? true : false
-  }
-}
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt !== undefined && opt) {
-    return true;
-  } else {
-    return false;
-  }
-}
-```
-
-</CodeTab>
-
-Slightly better, but still nested. Pattern-matching allows you to do this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let optionBoolToBool = opt => {
-  switch opt {
-  | None => false
-  | Some(true) => true
-  | Some(false) => false
-  }
-}
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt !== undefined && opt) {
-    return true;
-  } else {
-    return false;
-  }
-}
-```
-
-</CodeTab>
-
-Much more linear-looking! Now, you might be tempted to do this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let optionBoolToBool = opt => {
-  switch opt {
-  | Some(true) => true
-  | _ => false
-  }
-}
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt !== undefined && opt) {
-    return true;
-  } else {
-    return false;
-  }
-}
-```
-
-</CodeTab>
-
-Which is much more concise, but kills the exhaustiveness check mentioned above; refrain from using that. This is the best:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let optionBoolToBool = opt => {
-  switch opt {
-  | Some(trueOrFalse) => trueOrFalse
-  | None => false
-  }
-}
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt !== undefined) {
-    return opt;
-  } else {
-    return false;
-  }
-}
-```
-
-</CodeTab>
-
-Pretty darn hard to make a mistake in this code at this point! Whenever you'd like to use an if-else with many branches, prefer pattern matching instead. It's more concise and [performant](variant#design-decisions) too.
diff --git a/pages/docs/manual/v11.0.0/pipe.mdx b/pages/docs/manual/v11.0.0/pipe.mdx
deleted file mode 100644
index 86826e7de..000000000
--- a/pages/docs/manual/v11.0.0/pipe.mdx
+++ /dev/null
@@ -1,244 +0,0 @@
----
-title: "Pipe"
-description: "The Pipe operator (->)"
-canonical: "/docs/manual/v11.0.0/pipe"
----
-
-# Pipe
-
-ReScript provides a tiny but surprisingly useful operator `->`, called the "pipe", that allows you to "flip" your code inside-out. `a(b)` becomes `b->a`. It's a simple piece of syntax that doesn't have any runtime cost.
-
-Why would you use it? Imagine you have the following:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-validateAge(getAge(parseData(person)))
-```
-```js
-validateAge(getAge(parseData(person)));
-```
-
-</CodeTab>
-
-This is slightly hard to read, since you need to read the code from the innermost part, to the outer parts. Use pipe to streamline it:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-person
-  ->parseData
-  ->getAge
-  ->validateAge
-```
-```js
-validateAge(getAge(parseData(person)));
-```
-
-</CodeTab>
-
-Basically, `parseData(person)` is transformed into `person->parseData`, and `getAge(person->parseData)` is transformed into `person->parseData->getAge`, etc.
-
-**This works when the function takes more than one argument too**.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-a(one, two, three)
-```
-```js
-a(one, two, three);
-```
-
-</CodeTab>
-
-is the same as
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-one->a(two, three)
-```
-```js
-a(one, two, three);
-```
-
-</CodeTab>
-
-This also works with labeled arguments.
-
-Pipes are used to emulate object-oriented programming. For example, `myStudent.getName` in other languages like Java would be `myStudent->getName` in ReScript (equivalent to `getName(myStudent)`). This allows us to have the readability of OOP without the downside of dragging in a huge class system just to call a function on a piece of data.
-
-## Tips & Tricks
-
-Do **not** abuse pipes; they're a means to an end. Inexperienced engineers sometimes shape a library's API to take advantage of the pipe. This is backwards.
-
-## JS Method Chaining
-
-_This section requires understanding of [our binding API](bind-to-js-function.md#object-method)_.
-
-JavaScript's APIs are often attached to objects, and are often chainable, like so:
-
-```js
-const result = [1, 2, 3].map(a => a + 1).filter(a => a % 2 === 0);
-
-asyncRequest()
-  .setWaitDuration(4000)
-  .send();
-```
-
-Assuming we don't need the chaining behavior above, we'd bind to each case of this using [`@send`](/syntax-lookup#send-decorator) from the aforementioned binding API page:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type request
-@val external asyncRequest: unit => request = "asyncRequest"
-@send external setWaitDuration: (request, int) => request = "setWaitDuration"
-@send external send: request => unit = "send"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-You'd use them like this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let result = Array.filter(
-  Array.map([1, 2, 3], a => a + 1),
-  a => mod(a, 2) == 0
-)
-
-send(setWaitDuration(asyncRequest(), 4000))
-```
-```js
-var result = [1, 2, 3].map(function(a) {
-  return a + 1 | 0;
-}).filter(function(a) {
-  return a % 2 === 0;
-});
-
-asyncRequest().setWaitDuration(4000).send();
-```
-
-</CodeTab>
-
-This looks much worse than the JS counterpart! Clean it up visually with pipe:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let result = [1, 2, 3]
-  ->Array.map(a => a + 1)
-  ->Array.filter(a => mod(a, 2) == 0)
-
-asyncRequest()->setWaitDuration(4000)->send
-```
-```js
-var result = [1, 2, 3].map(function(a) {
-  return a + 1 | 0;
-}).filter(function(a) {
-  return a % 2 === 0;
-});
-
-asyncRequest().setWaitDuration(4000).send();
-```
-
-</CodeTab>
-
-## Pipe Into Variants
-
-You can pipe into a variant's constructor as if it was a function:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result = name->preprocess->Some
-```
-```js
-var result = preprocess(name);
-```
-
-</CodeTab>
-
-We turn this into:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result = Some(preprocess(name))
-```
-```js
-var result = preprocess(name);
-```
-
-</CodeTab>
-
-**Note** that using a variant constructor as a function wouldn't work anywhere else beside here.
-
-## Pipe Placeholders
-
-A placeholder is written as an underscore and it tells ReScript that you want to fill in an argument of a function later. These two have equivalent meaning:
-
-```res
-let addTo7 = (x) => add3(3, x, 4)
-let addTo7 = add3(3, _, 4)
-```
-
-Sometimes you don't want to pipe the value you have into the first position. In these cases you can mark a placeholder value to show which argument you would like to pipe into.
-
-Let's say you have a function `namePerson`, which takes a `person` then a `name` argument. If you are transforming a person then pipe will work as-is:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-makePerson(~age=47)
-  ->namePerson("Jane")
-```
-```js
-namePerson(makePerson(47), "Jane");
-```
-
-</CodeTab>
-
-If you have a name that you want to apply to a person object, you can use a placeholder:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-getName(input)
-  ->namePerson(personDetails, _)
-```
-```js
-var __x = getName(input);
-namePerson(personDetails, __x);
-```
-
-</CodeTab>
-
-This allows you to pipe into any positional argument. It also works for named arguments:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-getName(input)
-  ->namePerson(~person=personDetails, ~name=_)
-```
-```js
-var __x = getName(input);
-namePerson(personDetails, __x);
-```
-
-</CodeTab>
-
-## Triangle Pipe (Deprecated)
-
-You might see usages of another pipe, `|>`, in some codebases. These are deprecated.
-
-Unlike `->` pipe, the `|>` pipe puts the subject as the last (not first) argument of the function. `a |> f(b)` turns into `f(b, a)`.
-
-For a more thorough discussion on the rationale and differences between the two operators, please refer to the [Data-first and Data-last comparison by Javier Chávarri](https://www.javierchavarri.com/data-first-and-data-last-a-comparison/)
diff --git a/pages/docs/manual/v11.0.0/polymorphic-variant.mdx b/pages/docs/manual/v11.0.0/polymorphic-variant.mdx
deleted file mode 100644
index 66bf22ec5..000000000
--- a/pages/docs/manual/v11.0.0/polymorphic-variant.mdx
+++ /dev/null
@@ -1,433 +0,0 @@
----
-title: "Polymorphic Variant"
-description: "The Polymorphic Variant data structure in ReScript"
-canonical: "/docs/manual/v11.0.0/polymorphic-variant"
----
-
-# Polymorphic Variant
-
-Polymorphic variants (or poly variant) are a cousin of [variant](variant). With these differences:
-
-- They start with a `#` and the constructor name doesn't need to be capitalized.
-- They don't require an explicit type definition. The type is inferred from usage.
-- Values of different poly variant types can share the constructors they have in common (aka, poly variants are "structurally" typed, as opposed to ["nominally" typed](variant#variant-types-are-found-by-field-name)).
-
-They're a convenient and useful alternative to regular variants, but should **not** be abused. See the drawbacks at the end of this page.
-
-## Creation
-
-We provide 3 syntaxes for a poly variant's constructor:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let myColor = #red
-let myLabel = #"aria-hidden"
-let myNumber = #7
-```
-
-```js
-var myColor = "red";
-var myLabel = "aria-hidden";
-var myNumber = 7;
-```
-
-</CodeTab>
-
-**Take a look at the output**. Poly variants are _great_ for JavaScript interop. For example, you can use it to model JavaScript string and number enums like TypeScript, but without confusing their accidental usage with regular strings and numbers.
-
-`myColor` uses the common syntax. The second and third syntaxes are to support expressing strings and numbers more conveniently. We allow the second one because otherwise it'd be invalid syntax since symbols like `-` and others are usually reserved.
-
-## Type Declaration
-
-Although **optional**, you can still pre-declare a poly variant type:
-
-```res
-// Note the surrounding square brackets, and # for constructors
-type color = [#red | #green | #blue]
-```
-
-These types can also be inlined, unlike for regular variant:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let render = (myColor: [#red | #green | #blue]) => {
-  switch myColor {
-  | #blue => Console.log("Hello blue!")
-  | #red
-  | #green => Console.log("Hello other colors")
-  }
-}
-```
-
-```js
-function render(myColor) {
-  if (myColor === "green" || myColor === "red") {
-    console.log("Hello other colors");
-  } else {
-    console.log("Hello blue!");
-  }
-}
-```
-
-</CodeTab>
-
-**Note**: because a poly variant value's type definition is **inferred** and not searched in the scope, the following snippet won't error:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type color = [#red | #green | #blue]
-
-let render = myColor => {
-  switch myColor {
-  | #blue => Console.log("Hello blue!")
-  | #green => Console.log("Hello green!")
-  // works!
-  | #yellow => Console.log("Hello yellow!")
-  }
-}
-```
-
-```js
-function render(myColor) {
-  if (myColor === "yellow") {
-    console.log("Hello yellow!");
-  } else if (myColor === "green") {
-    console.log("Hello green!");
-  } else {
-    console.log("Hello blue!");
-  }
-}
-```
-
-</CodeTab>
-
-That `myColor` parameter's type is inferred to be `#red`, `#green` or `#yellow`, and is unrelated to the `color` type. If you intended `myColor` to be of type `color`, annotate it as `myColor: color` in any of the places.
-
-## Constructor Arguments
-
-This is similar to a regular variant's [constructor arguments](variant#constructor-arguments):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type account = [
-  | #Anonymous
-  | #Instagram(string)
-  | #Facebook(string, int)
-]
-
-let me: account = #Instagram("Jenny")
-let him: account = #Facebook("Josh", 26)
-```
-
-```js
-var me = {
-  NAME: "Instagram",
-  VAL: "Jenny"
-};
-
-var him = {
-  NAME: "Facebook",
-  VAL: [
-    "Josh",
-    26
-  ]
-};
-```
-
-</CodeTab>
-
-### Combine Types and Pattern Match
-
-You can use poly variant types within other poly variant types to create a sum of all constructors:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type red = [#Ruby | #Redwood | #Rust]
-type blue = [#Sapphire | #Neon | #Navy]
-
-// Contains all constructors of red and blue.
-// Also adds #Papayawhip
-type color = [red | blue | #Papayawhip]
-
-let myColor: color = #Ruby
-```
-
-```js
-var myColor = "Ruby";
-```
-
-</CodeTab>
-
-There's also some special [pattern matching](./pattern-matching-destructuring) syntax to match on constructors defined in a specific poly variant type:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Continuing the previous example above...
-
-switch myColor {
-| #...blue => Console.log("This blue-ish")
-| #...red => Console.log("This red-ish")
-| other => Console.log2("Other color than red and blue: ", other)
-}
-```
-
-```js
-var other = myColor;
-
-if (other === "Neon" || other === "Navy" || other === "Sapphire") {
-  console.log("This is blue-ish");
-} else if (other === "Rust" || other === "Ruby" || other === "Redwood") {
-  console.log("This is red-ish");
-} else {
-  console.log("Other color than red and blue: ", other);
-}
-```
-
-</CodeTab>
-
-This is a shorter version of:
-
-```res
-switch myColor {
-| #Sapphire | #Neon | #Navy => Console.log("This is blue-ish")
-| #Ruby | #Redwood | #Rust => Console.log("This is red-ish")
-| other => Console.log2("Other color than red and blue: ", other)
-}
-```
-
-## Structural Sharing
-
-Since poly variants value don't have a source of truth for their type, you can write such code:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type preferredColors = [#white | #blue]
-
-let myColor: preferredColors = #blue
-
-let displayColor = v => {
-  switch v {
-  | #red => "Hello red"
-  | #green => "Hello green"
-  | #white => "Hey white!"
-  | #blue => "Hey blue!"
-  }
-}
-
-Console.log(displayColor(myColor))
-```
-
-```js
-var myColor = "blue";
-
-function displayColor(v) {
-  if (v === "white") {
-    return "Hey white!";
-  } else if (v === "red") {
-    return "Hello red";
-  } else if (v === "green") {
-    return "Hello green";
-  } else {
-    return "Hey blue!";
-  }
-}
-
-console.log(displayColor("blue"));
-```
-
-</CodeTab>
-
-With a regular variant, the line `displayColor(myColor)` would fail, since it'd complain that the type of `myColor` doesn't match the type of `v`. No problem with poly variant.
-
-## JavaScript Output
-
-Poly variants are great for JavaScript interop! You can share their values to JS code, or model incoming JS values as poly variants.
-
-- `#red` and `#"I am red 😃"` compile to JavaScipt `"red"` and `"I am red 😃"`.
-- `#1` compiles to JavaScript `1`.
-- Poly variant constructor with 1 argument, like `Instagram("Jenny")` compile to a straightforward `{NAME: "Instagram", VAL: "Jenny"}`. 2 or more arguments like `#Facebook("Josh", 26)` compile to a similar object, but with `VAL` being an array of the arguments.
-
-### Bind to Functions
-
-For example, let's assume we want to bind to `Intl.NumberFormat` and want to make sure that our users only pass valid locales, we could define an external binding like this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type t
-
-@scope("Intl") @val
-external makeNumberFormat: ([#"de-DE" | #"en-GB" | #"en-US"]) => t = "NumberFormat"
-
-let intl = makeNumberFormat(#"de-DE")
-```
-
-```js
-var intl = Intl.NumberFormat("de-DE");
-```
-
-</CodeTab>
-
-The JS output is identical to handwritten JS, but we also get to enjoy type errors if we accidentally write `makeNumberFormat(#"de-DR")`.
-
-More advanced usage examples for poly variant interop can be found in [Bind to JS Function](bind-to-js-function#constrain-arguments-better).
-
-### Bind to String Enums
-
-Let's assume we have a TypeScript module that expresses following enum export:
-
-```js
-// direction.js
-enum Direction {
-  Up = "UP",
-  Down = "DOWN",
-  Left = "LEFT",
-  Right = "RIGHT",
-}
-
-export const myDirection = Direction.Up
-```
-
-For this particular example, we can also inline poly variant type definitions to design the type for the imported `myDirection` value:
-
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type direction = [ #UP | #DOWN | #LEFT | #RIGHT ]
-@module("./direction.js") external myDirection: direction = "myDirection"
-```
-
-```js
-var DirectionJs = require("./direction.js");
-
-var myDirection = DirectionJs.myDirection;
-```
-
-</CodeTab>
-
-Again: since we were using poly variants, the JS Output is practically zero-cost and doesn't add any extra code!
-
-## Extra Constraints on Types
-
-The previous poly variant type annotations we've looked at are the regular "closed" kind. However, there's a way to express "I want at least these constructors" (lower bound) and "I want at most these constructors" (upper bound):
-
-```res
-// Only #Red allowed. Closed.
-let basic: [#Red] = #Red
-
-// May contain #Red, or any other value. Open
-// here, foreground will actually be inferred as [> #Red | #Green]
-let foreground: [> #Red] = #Green
-
-// The value must be, at most, one of #Red or #Blue
-// Only #Red and #Blue are valid values
-let background: [< #Red | #Blue] = #Red
-```
-
-**Note:** We added this info for educational purposes. In most cases you will not want to use any of this stuff, since it makes your APIs pretty unreadable / hard to use.
-
-### Closed `[`
-
-This is the simplest poly variant definition, and also the most practical one. Like a common variant type, this one defines an exact set of constructors.
-
-```res
-type rgb = [ #Red | #Green | #Blue ]
-
-let color: rgb = #Green
-```
-
-In the example above, `color` will only allow one of the three constructors that are defined in the `rgb` type. This is usually the way how poly variants should be defined.
-
-In case you want to define a type that is extensible, you'll need to use the lower / upper bound syntax.
-
-### Lower Bound `[>`
-
-A lower bound defines the minimum set of constructors a poly variant type is aware of. It is also considered an "open poly variant type", because it doesn't restrict any additional values.
-
-Here is an example on how to make a minimum set of `basicBlueTones` extensible for a new `color` type:
-
-```res
-type basicBlueTone<'a> = [> #Blue | #DeepBlue | #LightBlue ] as 'a
-type color = basicBlueTone<[#Blue | #DeepBlue | #LightBlue | #Purple]>
-
-let color: color = #Purple
-
-// This will fail due to missing minimum constructors:
-type notWorking = basicBlueTone<[#Purple]>
-```
-
-Here, the compiler will enforce the user to define `#Blue | #DeepBlue | #LightBlue` as the minimum set of constructors when trying to extend `basicBlueTone<'a>`.
-
-**Note:** Since we want to define an extensible poly variant, we need to provide a type placeholder `<'a>`, and also add `as 'a` after the poly variant declaration, which essentially means: "Given type `'a` is constraint to the minimum set of constructors (`#Blue | #DeepBlue | #LightBlue`) defined in `basicBlueTone`".
-
-### Upper Bound `[<`
-
-The upper bound works in the opposite way than a lower bound: the extending type may only use constructors that are stated in the upper bound constraint.
-
-Here another example, but with red colors:
-
-```res
-type validRed<'a> = [< #Fire | #Crimson | #Ash] as 'a
-type myReds = validRed<[#Ash]>
-
-// This will fail due to unlisted constructor not defined by the lower bound
-type notWorking = validRed<[#Purple]>
-```
-
-## Coercion
-
-You can convert a poly variant to a `string` or `int` at no cost:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type company = [#Apple | #Facebook]
-let theCompany: company = #Apple
-
-let message = "Hello " ++ (theCompany :> string)
-```
-
-```js
-var theCompany = "Apple";
-var message = "Hello " + theCompany;
-```
-
-</CodeTab>
-
-**Note**: for the coercion to work, the poly variant type needs to be closed; you'd need to annotate it, since otherwise, `theCompany` would be inferred as `[> #Apple]`.
-
-## Tips & Tricks
-
-### Variant vs Polymorphic Variant
-
-One might think that polymorphic variants are superior to regular [variants](./variant). As always, there are trade-offs:
-
-- Due to their "structural" nature, poly variant's type errors might be more confusing. If you accidentally write `#blur` instead of `#blue`, ReScript will still error but can't indicate the correct source as easily. Regular variants' source of truth is the type definition, so the error can't go wrong.
-- It's also harder to refactor poly variants. Consider this:
-  ```res
-  let myFruit = #Apple
-  let mySecondFruit = #Apple
-  let myCompany = #Apple
-  ```
-  Refactoring the first one to `#Orange` doesn't mean we should refactor the third one. Therefore, the editor plugin can't touch the second one either. Regular variant doesn't have such problem, as these 2 values presumably come from different variant type definitions.
-
-- You might lose some nice pattern match checks from the compiler:
-  ```res
-  let myColor = #red
-
-  switch myColor {
-  | #red => Console.log("Hello red!")
-  | #blue => Console.log("Hello blue!")
-  }
-  ```
-  Because there's no poly variant definition, it's hard to know whether the `#blue` case can be safely removed.
-
-In most scenarios, we'd recommend to use regular variants over polymorphic variants, especially when you are writing plain ReScript code. In case you want to write zero-cost interop bindings or generate clean JS output, poly variants are oftentimes a better option.
diff --git a/pages/docs/manual/v11.0.0/primitive-types.mdx b/pages/docs/manual/v11.0.0/primitive-types.mdx
deleted file mode 100644
index 8aba14b77..000000000
--- a/pages/docs/manual/v11.0.0/primitive-types.mdx
+++ /dev/null
@@ -1,272 +0,0 @@
----
-title: "Primitive Types"
-description: "Primitive Data Types in ReScript"
-canonical: "/docs/manual/v11.0.0/primitive-types"
----
-
-# Primitive Types
-
-ReScript comes with the familiar primitive types like `string`, `int`, `float`, etc.
-
-<!-- TODO: doc unit -->
-
-## String
-
-ReScript `string`s are delimited using **double** quotes (single quotes are reserved for the character type below).
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let greeting = "Hello world!"
-let multilineGreeting = "Hello
- world!"
-```
-```js
-var greeting = "Hello world!";
-var multilineGreeting = "Hello\n world!";
-```
-
-</CodeTab>
-
-To concatenate strings, use `++`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let greetings = "Hello " ++ "world!"
-```
-```js
-var greetings = "Hello world!";
-```
-
-</CodeTab>
-
-### String Interpolation
-
-There's a special syntax for string that allows
-
-- multiline string just like before
-- no special character escaping
-- Interpolation
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let name = "Joe"
-
-let greeting = `Hello
-World
-👋
-${name}
-`
-```
-```js
-var name = "Joe";
-
-var greeting = "Hello\nWorld\n👋\n" + name + "\n";
-```
-
-</CodeTab>
-
-This is just like JavaScript's backtick string interpolation, except without needing to escape special characters.
-
-### Usage
-
-See the familiar `String` API in the [API docs](api/core/string). Since a ReScript string maps to a JavaScript string, you can mix & match the string operations in all standard libraries.
-
-### Tips & Tricks
-
-**You have a good type system now!** In an untyped language, you'd often overload the meaning of string by using it as:
-
-- a unique id: `var BLUE_COLOR = "blue"`
-- an identifier into a data structure: `var BLUE = "blue" var RED = "red" var colors = [BLUE, RED]`
-- the name of an object field: `person["age"] = 24`
-- an enum: `if (audio.canPlayType() === 'probably') {...}` [(ಠ_ಠ)](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/canPlayType#Return_value)
-- other crazy patterns you'll soon find horrible, after getting used to ReScript's alternatives.
-
-The more you overload the poor string type, the less the type system (or a teammate) can help you! ReScript provides concise, fast and maintainable types & data structures alternatives to the use-cases above (e.g. variants, in a later section).
-
-## Char
-
-ReScript has a type for a string with a single letter:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let firstLetterOfAlphabet = 'a'
-```
-```js
-var firstLetterOfAlphabet = /* "a" */97;
-```
-
-</CodeTab>
-
-**Note**: Char doesn't support Unicode or UTF-8 and is therefore not recommended.
-
-To convert a String to a Char, use `OCamlCompat.String.get("a", 0)`. To convert a Char to a String, use `OCamlCompat.String.make(0, 'a')` or `String.fromCharCode('a' :> int)`.
-
-## Regular Expression
-
-ReScript regular expressions compile cleanly to their JavaScript counterpart:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let r = %re("/b/g")
-```
-```js
-var r = /b/g;
-```
-
-</CodeTab>
-
-A regular expression like the above has the type `Re.t`. The [RegExp](api/core/regexp) module contains the regular expression helpers you have seen in JS.
-
-## Boolean
-
-A ReScript boolean has the type `bool` and can be either `true` or `false`. Common operations:
-
-- `&&`: logical and.
-- `||`: logical or.
-- `!`: logical not.
-- `<=`, `>=`, `<`, `>`
-- `==`: structural equal, compares data structures deeply. `(1, 2) == (1, 2)` is `true`. Convenient, but use with caution.
-- `===`: referential equal, compares shallowly. `(1, 2) === (1, 2)` is `false`. `let myTuple = (1, 2); myTuple === myTuple` is `true`.
-- `!=`: structural unequal.
-- `!==`: referential unequal.
-
-ReScript's `true/false` compiles into a JavaScript `true/false`.
-
-## Integers
-
-32-bits, truncated when necessary. We provide the usual operations on them: `+`, `-`, `*`, `/`, etc. See [Int](api/core/int) for helper functions.
-
-**Be careful when you bind to JavaScript numbers!** Since ReScript integers have a much smaller range than JavaScript numbers, data might get lost when dealing with large numbers. In those cases it’s much safer to bind the numbers as **float**. Be extra mindful of this when binding to JavaScript Dates and their epoch time.
-
-To improve readability, you may place underscores in the middle of numeric literals such as `1_000_000`. Note that underscores can be placed anywhere within a number, not just every three digits.
-
-## Floats
-
-Float requires other operators: `+.`, `-.`, `*.`, `/.`, etc. Like `0.5 +. 0.6`. See [Float](api/core/float) for helper functions.
-
-As with integers, you may use underscores within literals to improve readability.
-
-### Int-to-Float Coercion
-
-`int` values can be coerced to `float` with the `:>` (type coercion) operator.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let result = (1 :> float) +. 2.
-```
-```js
-var result = 1 + 2;
-```
-
-</CodeTab>
-
-## Big Integers (experimental)
-
-**Since 11.1**
-
-For values which are too large to be represented by Int or Float, there is the `bigint` primitive type.
-We provide the usual operations on them: `+`, `-`, `*`, `/`, etc. See [BigInt](api/core/bigint) for helper functions.
-
-A `bigint` number is denoted by a trailing `n` like so: `42n`.
-
-As `bigint` is a different data type than `int`, it's necessary to open the corresponding module to overload the operators.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-open! BigInt
-
-let a = 9007199254740991n + 9007199254740991n
-let b = 2n ** 2n
-```
-```js
-var a = 9007199254740991n + 9007199254740991n;
-
-var p = 2n ** 2n;
-```
-
-</CodeTab>
-
-It also supports all the bitwise operations, except unsigned shift right (`>>>`), which is not supported by JS itself for `bigint`s.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-open! BigInt
-
-let a = land(1n, 1n)
-let b = lor(1n, 1n)
-let c = lxor(1n, 1n)
-let d = lnot(1n)
-let e = lsl(1n, 1n)
-let f = asr(1n, 1n)
-```
-```js
-var Js_bigint = require("./stdlib/js_bigint.js");
-
-var a = 1n & 1n;
-
-var b = 1n | 1n;
-
-var c = 1n ^ 1n;
-
-var d = Js_bigint.lnot(1n);
-
-var e = (1n << 1n);
-
-var f = (1n >> 1n);
-```
-
-</CodeTab>
-
-It can also be pattern-matched.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let bigintValue = 1n
-
-switch bigintValue {
-| 1n => Console.log("Small bigint")
-| 100n => Console.log("Larger bigint")
-| _ => Console.log("Other bigint")
-}
-```
-```js
-if (1n !== 1n) {
-  if (1n !== 100n) {
-    console.log("Other bigint");
-  } else {
-    console.log("Larger bigint");
-  }
-} else {
-  console.log("Small bigint");
-}
-
-var bigintValue = 1n;
-```
-
-</CodeTab>
-
-
-## Unit
-
-The `unit` type indicates the absence of a specific value. It has only a single value, `()`, which acts as a placeholder when no other value exists or is needed. It compiles to JavaScript's `undefined` and resembles the `void` type in languages such as C++. What's the point of such a type?
-
-Consider the `Math.random` function. Its type signature is `unit => float`, which means it receives a `unit` as input and calculates a random `float` as output. You use the function like this - `let x = Math.random()`. Notice `()` as the first and only function argument.
-
-Imagine a simplified `Console.log` function that prints a message. Its type signature is `string => unit` and you'd use it like this `Console.log("Hello!")`. It takes a string as input, prints it, and then returns nothing useful. When `unit` is the output of a function it means the function performs some kind of side-effect. 
-
-## Unknown
-
-The `unknown` type represents values with contents that are a mystery or are not 100% guaranteed to be what you think they are. It provides type-safety when interacting with data received from an untrusted source. For example, suppose an external function is supposed to return a `string`. It might. But if the documentation is not accurate or the code has bugs, the function could return `null`, an `array`, or something else you weren't expecting.
-
-The ReScript type system helps you avoid run-time crashes and unpredicatable behavior by preventing you from using `unknown` in places that expect a `string` or `int` or some other type. The ReScript core libraries also provide utility functions to help you inspect `unknown` values and access their contents. In some cases you may need a JSON parsing library to convert `unknown` values to types you can safely use.   
-
-Consider using `unknown` when receiving data from [external JavaScript functions](/docs/manual/latest/bind-to-js-function)
diff --git a/pages/docs/manual/v11.0.0/project-structure.mdx b/pages/docs/manual/v11.0.0/project-structure.mdx
deleted file mode 100644
index 0e1ee94c6..000000000
--- a/pages/docs/manual/v11.0.0/project-structure.mdx
+++ /dev/null
@@ -1,57 +0,0 @@
----
-title: "Project Structure"
-description: "Notes on project structure and other rough ReScript guidelines"
-canonical: "/docs/manual/v11.0.0/project-structure"
----
-
-# Project Structure
-
-These are the existing, non-codified community practices that are currently propagated through informal agreement. We might remove some of them at one point, and enforce some others. Right now, they're just recommendations for ease of newcomers.
-
-## File Casing
-
-Capitalized file names (aka first letter upper-cased).
-
-**Justification**: Module names can only be capitalized. Newcomers often ask how a file maps to a module, and why `draw.res` maps to the module `Draw`, and sometimes try to refer to a module through uncapitalized identifiers. Using `Draw.res` makes this mapping more straightforward. It also helps certain file names that'd be awkward in uncapitalized form: `uRI.res`.
-
-## Ignore `.merlin` File
-
-This is generated by the build system and you should not have to manually edit it. Don't check it into the repo.
-
-**Justification**: `.merlin` is for editor tooling. The file contains absolute paths, which are also not cross-platform (e.g. Windows paths are different).
-
-## Folders
-
-Try not to have too many nested folders. Keep your project flat, and have fewer files (reminder: you can use nested modules).
-
-**Justification**: The file system is a _tree_, but your code's dependencies are a _graph_. Because of that, any file & folder organization is usually imperfect. While it's still valuable to group related files together in a folder, the time wasted debating & getting decision paralysis over these far outweight their benefits. We'll always recommend you to Get Work Done instead of debating about these issues.
-
-## Third-party Dependencies
-
-Keep them to a minimum.
-
-**Justification**: A compiled, statically typed language cannot model its dependencies easily by muddling along like in a dynamic language, especially when we're still piggy-backing on NPM/Yarn (to reduce learning overhead in the medium-term). Keeping dependencies simple & lean helps reduce possibility of conflicts (e.g. two diamond dependencies, or clashing interfaces).
-
-## Documentation
-
-Have them. Spend more effort making them great (examples, pitfalls) and professional rather than _just_ fancy-looking. Do use examples, and avoid using names such as `foo` and `bar`. There's always more concrete names (it's an example, no need to be abstract/generalized just yet. The API docs will do this plentily). For blog posts, don't repeat the docs themselves, describe the _transition_ from old to new, and why (e.g. "it was a component, now it's a function, because ...").
-
-**Justification**: It's hard for newcomers to distinguish between a simple/decent library and one that's fancy-looking. For the sake of the community, don't try too hard to one-up each other's libraries. Do spread the words, but use your judgement too.
-
-## PPX & Other Meta-tools
-
-Keep them to a minimum. PPX, unless used in renown cases (printer, accessors and serializer/deserializer generation), can cause big learning churn for newcomers; on top of the syntax, semantics, types, build tool & FFI that they already have to learn, learning per-library custom transformations of the code is an extra step. More invasive macros makes the code itself less semantically meaningful too, since the essence would be hiding somewhere else.
-
-## Paradigm
-
-Don't abuse overly fancy features. Do leave some breathing room for future APIs but don't over-architect things.
-
-**Justification**: Simple code helps newcomers understand and potentially contribute to your code. Contributing is the best way for them to learn. The extra help you receive might also surpass the gain of using a slightly more clever language trick. But do try new language tricks in some of more casual projects! You might discover new ways of architecting code.
-
-## Publishing
-
-If it's a wrapper for a JS library, don't publish the JS artifacts. If it's a legit library, publish the artifacts in lib/js if you think JS consumers might use it. This is especially the case when you gradually convert a JS lib to ReScript while not breaking existing JS consumers.
-
-Do put the keywords `"rescript"` in your package.json `keywords` field. This allows us to find the library much more easily for future purposes.
-
-**Justification**: Be nice to JS consumers of your library. They're your future ReScripters.
diff --git a/pages/docs/manual/v11.0.0/promise.mdx b/pages/docs/manual/v11.0.0/promise.mdx
deleted file mode 100644
index 6aa9c5b76..000000000
--- a/pages/docs/manual/v11.0.0/promise.mdx
+++ /dev/null
@@ -1,182 +0,0 @@
----
-title: "Promises"
-description: "JS Promise handling in ReScript"
-canonical: "/docs/manual/v11.0.0/promise"
----
-
-# Promise
-
-> **Note:** Starting from ReScript 10.1 and above, we recommend using [async / await](./async-await) when interacting with Promises.
-
-## `promise` type
-
-**Since 10.1**
-
-In ReScript, every JS promise is represented with the globally available `promise<'a>` type. For ReScript versions < 10.1, use its original alias `Js.Promise.t<'a>` instead.
-
-Here's a usage example in a function signature:
-
-```resi
-// User.resi file
-
-type user = {name: string}
-
-let fetchUser: string => promise<user>
-```
-
-To work with promise values (instead of using `async` / `await`) you may want to use the built-in `Promise` module. 
-
-## Promise
-
-A builtin module to create, chain and manipulate promises.
-
-### Creating a promise
-
-```res
-let p1 = Promise.make((resolve, reject) => {
-  // We use uncurried functions for resolve / reject
-  // for cleaner JS output without unintended curry calls
-  resolve("hello world")
-})
-
-let p2 = Promise.resolve("some value")
-
-// You can only reject `exn` values for streamlined catch handling
-exception MyOwnError(string)
-let p3 = Promise.reject(MyOwnError("some rejection"))
-```
-
-### Access the contents and transform a promise
-
-```res
-let logAsyncMessage = () => {
-  open Promise
-  Promise.resolve("hello world")
-  ->then(msg => {
-    // then callbacks require the result to be resolved explicitly
-    resolve("Message: " ++ msg)
-  })
-  ->then(msg => {
-    Console.log(msg)
-
-    // Even if there is no result, we need to use resolve() to return a promise
-    resolve()
-  })
-  ->ignore // Requires ignoring due to unhandled return value
-}
-```
-
-For comparison, the `async` / `await` version of the same code would look like this:
-
-```res
-let logAsyncMessage = async () => {
-  let msg = await Promise.resolve("hello world")
-  Console.log(`Message: ${msg}`)
-}
-```
-
-Needless to say, the async / await version offers better ergonomics and less opportunities to run into type issues.
-
-### Handling Rejected Promises
-
-You can handle a rejected promise using the [`Promise.catch()`](./api/core/promise#value-catch) method, which allows you to catch and manage errors effectively.
-
-### Run multiple promises in parallel
-
-In case you want to launch multiple promises in parallel, use `Promise.all`:
-
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@val
-external fetchMessage: string => promise<string> = "global.fetchMessage"
-
-let logAsyncMessage = async () => {
-  let messages = await Promise.all([fetchMessage("message1"), fetchMessage("message2")])
-
-  Console.log(messages->Array.joinWith(", "))
-}
-```
-
-```js
-async function logAsyncMessage(param) {
-  var messages = await Promise.all([
-        global.fetchMessage("message1"),
-        global.fetchMessage("message2")
-      ]);
-  console.log(messages.join(", "));
-}
-
-export {
-  logAsyncMessage ,
-}
-```
-
-</CodeTab>
-
-## Js.Promise module (legacy - do not use)
-
-> **Note:** The `Js.Promise` bindings are following the outdated data-last convention from a few years ago. We kept those APIs for backwards compatibility. Either use [`Promise`](api/core/promise) or a third-party promise binding instead.
-
-ReScript has built-in support for [JavaScript promises](api/js/promise). The 3 functions you generally need are:
-
-- `Js.Promise.resolve: 'a => Js.Promise.t<'a>`
-- `Js.Promise.then_: ('a => Js.Promise.t<'b>, Js.Promise.t<'a>) => Js.Promise.t<'b>`
-- `Js.Promise.catch: (Js.Promise.error => Js.Promise.t<'a>, Js.Promise.t<'a>) => Js.Promise.t<'a>`
-
-Additionally, here's the type signature for creating a promise on the ReScript side:
-
-```res
-Js.Promise.make: (
-  (
-    ~resolve: (. 'a) => unit,
-    ~reject: (. exn) => unit
-  ) => unit
-) => Js.Promise.t<'a>
-```
-
-This type signature means that `make` takes a callback that takes 2 named arguments, `resolve` and `reject`. Both arguments are themselves [uncurried callbacks](
-function.md#uncurried-function) (with a dot). `make` returns the created promise.
-
-### Usage
-
-Using the [pipe operator](pipe.md):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myPromise = Js.Promise.make((~resolve, ~reject) => resolve(. 2))
-
-myPromise->Js.Promise.then_(value => {
-  Console.log(value)
-  Js.Promise.resolve(value + 2)
-}, _)->Js.Promise.then_(value => {
-  Console.log(value)
-  Js.Promise.resolve(value + 3)
-}, _)->Js.Promise.catch(err => {
-  Console.log2("Failure!!", err)
-  Js.Promise.resolve(-2)
-}, _)
-```
-```js
-var myPromise = new Promise(function (resolve, reject) {
-  return resolve(2);
-});
-
-myPromise
-  .then(function (value) {
-    console.log(value);
-    return Promise.resolve((value + 2) | 0);
-  })
-  .then(function (value) {
-    console.log(value);
-    return Promise.resolve((value + 3) | 0);
-  })
-  .catch(function (err) {
-    console.log("Failure!!", err);
-    return Promise.resolve(-2);
-  });
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v11.0.0/record.mdx b/pages/docs/manual/v11.0.0/record.mdx
deleted file mode 100644
index c95afb258..000000000
--- a/pages/docs/manual/v11.0.0/record.mdx
+++ /dev/null
@@ -1,557 +0,0 @@
----
-title: "Record"
-description: "Record types in ReScript"
-canonical: "/docs/manual/v11.0.0/record"
----
-
-# Record
-
-Records are like JavaScript objects but:
-
-- are immutable by default
-- have fixed fields (not extensible)
-
-## Type Declaration
-
-A record needs a mandatory type declaration:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type person = {
-  age: int,
-  name: string,
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Creation
-
-To create a `person` record (declared above):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let me = {
-  age: 5,
-  name: "Big ReScript"
-}
-```
-```js
-var me = {
-  age: 5,
-  name: "Big ReScript"
-};
-```
-
-</CodeTab>
-
-When you create a new record value, ReScript tries to find a record type declaration that conforms to the shape of the value. So the `me` value here is inferred as of type `person`.
-
-The type is found by looking above the `me` value. **Note**: if the type instead resides in another file or module, you need to explicitly indicate which file or module it is:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// School.res
-type person = {age: int, name: string}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Example.res
-
-let me: School.person = {age: 20, name: "Big ReScript"}
-/* or */
-let me2 = {School.age: 20, name: "Big ReScript"}
-```
-```js
-var me = {
-  age: 20,
-  name: "Big ReScript"
-};
-var me2 = {
-  age: 20,
-  name: "Big ReScript"
-};
-```
-
-</CodeTab>
-
-In both `me` and `me2` the record definition from `School` is found. The first one, `me` with the regular type annotation, is preferred.
-
-## Access
-
-Use the familiar dot notation:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let name = me.name
-```
-```js
-var name = "Big ReScript";
-```
-
-</CodeTab>
-
-## Immutable Update
-
-New records can be created from old records with the `...` spread operator. The original record isn't mutated.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let meNextYear = {...me, age: me.age + 1}
-```
-```js
-var meNextYear = {
-  age: 21,
-  name: "Big ReScript"
-};
-```
-
-</CodeTab>
-
-**Note**: spread cannot add new fields to the record value, as a record's shape is fixed by its type.
-
-## Mutable Update
-
-Record fields can optionally be mutable. This allows you to efficiently update those fields in-place with the `=` operator.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type person = {
-  name: string,
-  mutable age: int
-}
-
-let baby = {name: "Baby ReScript", age: 5}
-baby.age = baby.age + 1 // `baby.age` is now 6. Happy birthday!
-```
-```js
-var baby = {
-  name: "Baby ReScript",
-  age: 5
-};
-
-baby.age = baby.age + 1 | 0;
-```
-
-</CodeTab>
-
-Fields not marked with `mutable` in the type declaration cannot be mutated.
-
-## JavaScript Output
-
-ReScript records compile to straightforward JavaScript objects; see the various JS output tabs above.
-
-## Optional Record Fields
-ReScript [`v10`](/blog/release-10-0-0#experimental-optional-record-fields) introduced optional record fields. This means that you can define fields that can be omitted when creating the record. It looks like this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type person = {
-  age: int,
-  name?: string
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Notice how `name` has a suffixed `?`. That means that the field itself is _optional_.
-
-### Creation
-You can omit any optional fields when creating a record. Not setting an optional field will default the field's value to `None`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type person = {
-  age: int,
-  name?: string
-}
-
-let me = {
-  age: 5,
-  name: "Big ReScript"
-}
-
-let friend = {
-  age: 7
-}
-```
-```js
-var me = {
-  age: 5,
-  name: "Big ReScript"
-};
-
-var friend = {
-  age: 7
-};
-```
-
-</CodeTab>
-
-This has consequences for pattern matching, which we'll expand a bit on soon.
-
-## Immutable Update
-Updating an optional field via an immutable update above lets you set that field value without needing to care whether it's optional or not.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type person = {
-  age: int,
-  name?: string
-}
-
-let me = {
-  age: 123,
-  name: "Hello"
-}
-
-let withoutName = {
-  ...me,
-  name: "New Name"
-}
-```
-```js
-import * as Caml_obj from "./stdlib/caml_obj.js";
-
-var me = {
-  age: 123,
-  name: "Hello"
-};
-
-var newrecord = Caml_obj.obj_dup(me);
-
-newrecord.name = "New Name";
-
-var withoutName = newrecord;
-```
-
-</CodeTab>
-
-
-However, if you want to set the field to an optional value, you prefix that value with `?`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type person = {
-  age: int,
-  name?: string
-}
-
-let me = {
-  age: 123,
-  name: "Hello"
-}
-
-let maybeName = Some("My Name")
-
-let withoutName = {
-  ...me,
-  name: ?maybeName
-}
-```
-```js
-import * as Caml_obj from "./stdlib/caml_obj.js";
-
-var me = {
-  age: 123,
-  name: "Hello"
-};
-
-var maybeName = "My Name";
-
-var newrecord = Caml_obj.obj_dup(me);
-
-newrecord.name = maybeName;
-
-var withoutName = newrecord;
-```
-
-</CodeTab>
-
-You can unset an optional field's value via that same mechanism by setting it to `?None`.
-
-### Pattern Matching on Optional Fields
-[Pattern matching](pattern-matching-destructuring), one of ReScript's most important features, has two caveats when you deal with optional fields.
-
-When matching on the value directly, it's an `option`. Example:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type person = {
-  age: int,
-  name?: string,
-}
-
-let me = {
-  age: 123,
-  name: "Hello",
-}
-
-let isRescript = switch me.name {
-| Some("ReScript") => true
-| Some(_) | None => false
-}
-```
-```js
-var isRescript;
-
-isRescript = "Hello" === "ReScript" ? true : false;
-
-var me = {
-  age: 123,
-  name: "Hello"
-};
-```
-
-</CodeTab>
-
-But, when matching on the field as part of the general record structure, it's treated as the underlying, non-optional value:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type person = {
-  age: int,
-  name?: string,
-}
-
-let me = {
-  age: 123,
-  name: "Hello",
-}
-
-let isRescript = switch me {
-| {name: "ReScript"} => true
-| _ => false
-}
-
-```
-```js
-var isRescript;
-
-isRescript = "Hello" === "ReScript" ? true : false;
-
-var me = {
-  age: 123,
-  name: "Hello"
-};
-```
-
-</CodeTab>
-
-Sometimes you _do_ want to know whether the field was set or not. You can tell the pattern matching engine about that by prefixing your option match with `?`, like this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type person = {
-  age: int,
-  name?: string,
-}
-
-let me = {
-  age: 123,
-  name: "Hello",
-}
-
-let nameWasSet = switch me {
-| {name: ?None} => false
-| {name: ?Some(_)} => true
-}
-```
-```js
-var nameWasSet = true;
-
-var me = {
-  age: 123,
-  name: "Hello"
-};
-```
-
-</CodeTab>
-
-## Record Type Spread
-
-In ReScript v11, you can now spread one or more record types into a new record type. It looks like this:
-
-```rescript
-type a = {
-  id: string,
-  name: string,
-}
-
-type b = {
-  age: int
-}
-
-type c = {
-  ...a,
-  ...b,
-  active: bool
-}
-```
-
-`type c` will now be:
-
-```rescript
-type c = {
-  id: string,
-  name: string,
-  age: int,
-  active: bool,
-}
-```
-
-Record type spreads act as a 'copy-paste' mechanism for fields from one or more records into a new record. This operation inlines the fields from the spread records directly into the new record definition, while preserving their original properties, such as whether they are optional or mandatory. It's important to note that duplicate field names are not allowed across the records being spread, even if the fields have the same type.
-
-## Record Type Coercion
-
-Record type coercion gives us more flexibility when passing around records in our application code. In other words, we can now coerce a record `a` to be treated as a record `b` at the type level, as long as the original record `a` contains the same set of fields in `b`. Here's an example:
-
-```rescript
-type a = {
-  name: string,
-  age: int,
-}
-
-type b = {
-  name: string,
-  age: int,
-}
-
-let nameFromB = (b: b) => b.name
-
-let a: a = {
-  name: "Name",
-  age: 35,
-}
-
-let name = nameFromB(a :> b)
-```
-
-Notice how we _coerced_ the value `a` to type `b` using the coercion operator `:>`. This works because they have the same record fields. This is purely at the type level, and does not involve any runtime operations.
-
-Additionally, we can also coerce records from `a` to `b` whenever `a` is a super-set of `b` (i.e. `a` containing all the fields of `b`, and more). The same example as above, slightly altered:
-
-```rescript
-type a = {
-  id: string,
-  name: string,
-  age: int,
-  active: bool,
-}
-
-type b = {
-  name: string,
-  age: int,
-}
-
-let nameFromB = (b: b) => b.name
-
-let a: a = {
-  id: "1",
-  name: "Name",
-  age: 35,
-  active: true,
-}
-
-let name = nameFromB(a :> b)
-```
-
-Notice how `a` now has more fields than `b`, but we can still coerce `a` to `b` because `b` has a subset of the fields of `a`.
-
-In combination with [optional record fields](/docs/manual/latest/record#optional-record-fields), one may coerce a mandatory field of an `option` type to an optional field:
-
-```rescript
-type a = {
-  name: string,
-
-  // mandatory, but explicitly typed as option<int>
-  age: option<int>,
-}
-
-type b = {
-  name: string,
-  // optional field
-  age?: int,
-}
-
-let nameFromB = (b: b) => b.name
-
-let a: a = {
-  name: "Name",
-  age: Some(35),
-}
-
-let name = nameFromB(a :> b)
-```
-
-## Tips & Tricks
-
-### Record Types Are Found By Field Name
-With records, you **cannot** say "I'd like this function to take any record type, as long as they have the field `age`". The following **won't work as intended**:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type person = {age: int, name: string}
-type monster = {age: int, hasTentacles: bool}
-
-let getAge = (entity) => entity.age
-```
-```js
-function getAge(entity) {
-  return entity.age;
-}
-```
-
-</CodeTab>
-
-Instead, `getAge` will infer that the parameter `entity` must be of type `monster`, the closest record type with the field `age`. The following code's last line fails:
-
-```res
-let kraken = {age: 9999, hasTentacles: true}
-let me = {age: 5, name: "Baby ReScript"}
-
-getAge(kraken)
-getAge(me) // type error!
-```
-
-The type system will complain that `me` is a `person`, and that `getAge` only works on `monster`. If you need such capability, use ReScript objects, described [here](object.md).
-
-### Optional Fields in Records Can Be Useful for Bindings
-Many JavaScript APIs tend to have large configuration objects that can be a bit annoying to model as records, since you previously always needed to specify all record fields when creating a record. 
-
-Optional record fields, introduced in [`v10`](/blog/release-10-0-0#experimental-optional-record-fields), is intended to help with this. Optional fields will let you avoid having to specify all fields, and let you just specify the one's you care about. A significant improvement in ergonomics for bindings and other APIs with for example large configuration objects.
-
-## Design Decisions
-
-After reading the constraints in the previous sections, and if you're coming from a dynamic language background, you might be wondering why one would bother with record in the first place instead of straight using object, since the former needs explicit typing and doesn't allow different records with the same field name to be passed to the same function, etc.
-
-1. The truth is that most of the times in your app, your data's shape is actually fixed, and if it's not, it can potentially be better represented as a combination of variant (introduced next) + record instead.
-2. Since a record type is resolved through finding that single explicit type declaration (we call this "nominal typing"), the type error messages end up better than the counterpart ("structural typing", like for tuples). This makes refactoring easier; changing a record type's fields naturally allows the compiler to know that it's still the same record, just misused in some places. Otherwise, under structural typing, it might get hard to tell whether the definition site or the usage site is wrong.
-
diff --git a/pages/docs/manual/v11.0.0/reserved-keywords.mdx b/pages/docs/manual/v11.0.0/reserved-keywords.mdx
deleted file mode 100644
index 3426a8c32..000000000
--- a/pages/docs/manual/v11.0.0/reserved-keywords.mdx
+++ /dev/null
@@ -1,80 +0,0 @@
----
-title: "Reserved Keywords"
-description: "All reserved keywords in ReScript"
-canonical: "/docs/manual/v11.0.0/reserved-keywords"
----
-
-# Reserved Keywords
-
-> **Note**: Some of these words are reserved purely for backward compatibility.
->
-> If you _need_ to use one of these names as binding and/or field name, see [Use Illegal Identifier Names](use-illegal-identifier-names.md).
-
-- `and`
-- `as`
-- `assert`
-
-<!-- - `begin` -->
-
-<!-- - `class` -->
-
-- `constraint`
-
-<!-- - `do` -->
-<!-- - `done` -->
-
-- `else`
-  <!-- - `end` -->
-  <!-- - `esfun` -->
-- `exception`
-- `external`
-
-* `false`
-* `for`
-  <!-- - `fun` -->
-  <!-- - `function` -->
-  <!-- - `functor` -->
-
-- `if`
-- `in`
-- `include`
-  <!-- - `inherit` -->
-  <!-- - `initializer` -->
-
-* `lazy`
-* `let`
-
-- `module`
-- `mutable`
-
-<!-- - `new` -->
-<!-- - `nonrec` -->
-
-<!-- - `object` -->
-
-- `of`
-- `open`
-  <!-- - `or` -->
-
-<!-- - `pri` -->
-<!-- - `pub` -->
-
-- `rec`
-
-<!-- - `sig` -->
-<!-- - `struct` -->
-
-- `switch`
-
-<!-- - `then` -->
-
-- `true`
-- `try`
-- `type`
-
-<!-- - `val` -->
-<!-- - `virtual` -->
-
-- `when`
-- `while`
-- `with`
diff --git a/pages/docs/manual/v11.0.0/scoped-polymorphic-types.mdx b/pages/docs/manual/v11.0.0/scoped-polymorphic-types.mdx
deleted file mode 100644
index 822f34f95..000000000
--- a/pages/docs/manual/v11.0.0/scoped-polymorphic-types.mdx
+++ /dev/null
@@ -1,100 +0,0 @@
----
-title: "Scoped Polymorphic Types"
-description: "Scoped Polymorphic Types in ReScript"
-canonical: "/docs/manual/v11.0.0/scoped-polymorphic-types"
----
-
-# Scoped Polymorphic Types
-
-Scoped Polymorphic Types in ReScript are functions with the capability to handle arguments of any type within a specific scope. This feature is particularly valuable when working with JavaScript APIs, as it allows your functions to accommodate diverse data types while preserving ReScript's strong type checking.
-
-## Definition and Usage
-
-Scoped polymorphic types in ReScript offer a flexible and type-safe way to handle diverse data types within specific scopes. This documentation provides an example to illustrate their usage in a JavaScript context.
-
-### Example: Logging API
-
-Consider a logging example within a JavaScript context that processes various data types:
-
-```js
-const logger = {
-  log: (data) => {
-    if (typeof data === "string") {
-      /* handle string */
-    } else if (typeof data === "number") {
-      /* handle number */
-    } else {
-      /* handle other types */
-    }
-  },
-};
-```
-
-In ReScript, we can bind to this function as a record with a scoped polymorphic function type:
-
-```res prelude
-type logger = { log: 'a. 'a => unit }
-
-@module("jsAPI") external getLogger: unit => logger = "getLogger"
-```
-
-The `logger` type represents a record with a single field `log`, which is a scoped polymorphic function type `'a. 'a => unit`. The `'a` indicates a type variable that can be any type within the scope of the `log` function.
-
-Now, we can utilize the function obtained from `getLogger`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myLogger = getLogger()
-
-myLogger.log("Hello, ReScript!")
-myLogger.log(42)
-```
-
-```js
-var myLogger = JsAPI.getLogger();
-
-myLogger.log("Hello, ReScript!");
-myLogger.log(42);
-```
-
-</CodeTab>
-
-In this example, we create an instance of the logger by calling `getLogger()`, and then we can use the `log` function on the `myLogger` object to handle different data types.
-
-## Limitations of Normal Polymorphic Types
-
-Let's consider the same logging example in ReScript, but this time using normal polymorphic types:
-
-```res
-type logger<'a> = { log: 'a => unit}
-
-@module("jsAPI") external getLogger: unit => logger<'a> = "getLogger"
-```
-
-In this case, the `logger` type is a simple polymorphic function type `'a => unit`. However, when we attempt to use this type in the same way as before, we encounter an issue:
-
-```res
-let myLogger = getLogger()
-
-myLogger.log("Hello, ReScript!")
-myLogger.log(42) // Type error!
-```
-
-The problem arises because the type inference in ReScript assigns a concrete type to the `logger` function based on the first usage. In this example, after the first call to `myLogger`, the compiler infers the type `logger<string>` for `myLogger`. Consequently, when we attempt to pass an argument of type `number` in the next line, a type error occurs because it conflicts with the inferred type `logger<string>`.
-
-In contrast, scoped polymorphic types, such as `'a. 'a => unit`, overcome this limitation by allowing type variables within the scope of the function. They ensure that the type of the argument is preserved consistently within that scope, regardless of the specific value used in the first invocation.
-
-## Limitations of Scoped Polymorphic Types
-
-Scoped polymorphic types work only when they are directly applied to let-bindings or record fields (as demonstrated in the logger example above). They can neither be applied to function bodies, nor to separate type definitions:
-
-```res
-exception Abort
-
-let testExn: 'a. unit => 'a = () => raise(Abort) // Works!
-
-let testExn2 = (): 'a. 'a = raise(Abort) // Syntax error!
-type fn = 'a. 'a => unit // Syntax error!
-```
-
diff --git a/pages/docs/manual/v11.0.0/shared-data-types.mdx b/pages/docs/manual/v11.0.0/shared-data-types.mdx
deleted file mode 100644
index 59e2919d3..000000000
--- a/pages/docs/manual/v11.0.0/shared-data-types.mdx
+++ /dev/null
@@ -1,46 +0,0 @@
----
-title: "Shared Data Types"
-description: "Data types that share runtime presentation between JS and ReScript"
-canonical: "/docs/manual/v11.0.0/shared-data-types"
----
-
-# Shared Data Types
-
-ReScript's built-in values of type `string`, `float`, `array` and a few others have a rather interesting property: they compile to the exact same value in JavaScript!
-
-This means that if you're passing e.g. a ReScript string to the JavaScript side, the JS side can directly use it as a native JS string. It also means that you can import a JS string and pretend it's a native ReScript string.
-
-Unlike most compiled-to-js languages, in ReScript, **you don't need to write data converters back and forth for most of our values**!
-
-**Shared, bidirectionally usable types**:
-
-- String. ReScript strings are JavaScript strings, vice-versa. (Caveat: only our backtick string `` `hello 👋 ${personName}` `` supports unicode and interpolation).
-- Float. ReScript floats are JS numbers, vice-versa.
-- Array. In addition to the [Array API](api/core/array), we provide our own [Belt.Array](api/belt/array#set) API too.
-- Tuple. Compiles to a JS array. You can treat a fixed-sized, heterogenous JS array as ReScript tuple too.
-- Boolean.
-- Record. Record compiles to JS object. Therefore you can also treat JS objects as records. If they're too dynamic, consider modeling them on the ReScript side as a hashmap/dictionary [`Dict`](api/core/dict) or a ReScript object.
-- Object. ReScript objects are JavaScript objects, vice-versa.
-- Function. They compile to clean JS functions.
-- Module. ReScript files are considered top-level modules, and are compiled to JS files 1 to 1. Nested modules are compiled to JavaScript objects.
-- Polymorphic variants.
-- Unit. The `unit` type, which has a single value `()`, compiles to `undefined` too. Likewise, you can treat an incoming JS `undefined` as `()` if that's the only value it'll ever be.
-
-**Types that are slightly different than JS, but that you can still use from JS**:
-
-- Int. **Ints are 32-bits**! Be careful, you can potentially treat them as JS numbers and vice-versa, but if the number's large, then you better treat JS numbers as floats. For example, we bind to `Date` using `float`s.
-- Option. The `option` type's `None` value compiles into JS `undefined`. The `Some` value, e.g. `Some(5)`, compiles to `5`. Likewise, you can treat an incoming JS `undefined` as `None`. **JS `null` isn't handled here**. If your JS value can be `null`, use [Nullable](api/core/nullable) helpers.
-- Exception.
-- Variant. Check the compiled JavaScript output of variant to see its shape. We don't recommend exporting a ReScript variant for pure JS usage, since they're harder to read as plain JS code, but you can do it.
-- List, which is just a regular variant.
-
-**Non-shared types (aka internal types)**:
-
-- Character.
-- Int64.
-- Lazy values.
-- Everything else.
-
-Many of these are stable, which means that you can still serialize/deserialize them as-is without manual conversions. But we discourage actively peeking into their structure otherwise.
-
-These types require manual conversions if you want to export them for JS consumption. For a seamless JS/TypeScript integration experience, you might want to use [genType](https://github.com/cristianoc/gentype) instead of doing conversions by hand.
diff --git a/pages/docs/manual/v11.0.0/tagged-templates.mdx b/pages/docs/manual/v11.0.0/tagged-templates.mdx
deleted file mode 100644
index a3d3e0ac1..000000000
--- a/pages/docs/manual/v11.0.0/tagged-templates.mdx
+++ /dev/null
@@ -1,124 +0,0 @@
----
-title: "Tagged templates"
-description: "Using tagged templates in ReScript"
-canonical: "/docs/manual/v11.0.0/tagged-templates"
----
-
-# Tagged templates
-
-**Since 11.1**
-
-Tagged templates provide a special form of string interpolation, enabling the creation of template literals 
-where placeholders aren't restricted to strings. Moreover, the resulting output isn't confined solely to 
-strings either. You can take a look at the [JS documentation 
-about tagged templates](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#tagged_templates)
-to learn more about them.
-
-## Define a tag function
-
-Tag functions in ReScript have the following signature:
-```res 
-let myTagFunction : (array<string>, array<'param>) => 'output
-```
-As you can see, you can have any type you want both for the placeholder array and for the output.
-
-Given how string interpolation works, you'll always have the following invariant:
-```res
-Array.length(strings) == Array.length(placeholder) + 1
-```
-
-Let's say you want to interpolate strings with all kind of builtin types and make it work inside React components,
-you can define the following tag function:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type params =
-  | I(int)
-  | F(float)
-  | S(string)
-  | Bool(bool)
-
-let s = (strings, parameters) => {
-  let text = Array.reduceWithIndex(parameters, Array.getUnsafe(strings, 0), (
-    acc,
-    param,
-    i,
-  ) => {
-    let s = Array.getUnsafe(strings, i + 1)
-    let p = switch param {
-    | I(i) => Int.toString(i)
-    | F(f) => Float.toString(f)
-    | S(s) => s
-    | Bool(true) => "true"
-    | Bool(false) => "false"
-    }
-    acc ++ p ++ s
-  })
-  React.string(text)
-}
-```
-```js
-import * as Core__Array from "./stdlib/core__Array.js";
-
-function s(strings, parameters) {
-  return Core__Array.reduceWithIndex(parameters, strings[0], (function (acc, param, i) {
-                var s = strings[i + 1 | 0];
-                var p;
-                switch (param.TAG) {
-                  case "I" :
-                  case "F" :
-                      p = param._0.toString();
-                      break;
-                  case "S" :
-                      p = param._0;
-                      break;
-                  case "Bool" :
-                      p = param._0 ? "true" : "false";
-                      break;
-                  
-                }
-                return acc + p + s;
-              }));
-}
-```
-
-</CodeTab>
-
-## Write tagged template literals
-
-Now that you have defined your tag function, you can use it this way:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module Greetings = {
-  @react.component
-  let make = (~name, ~age) => {
-    <div> {s`hello ${S(name)} you're ${I(age)} year old!`} </div>
-  }
-}
-```
-```js
-function Greetings(props) {
-  return React.createElement("div", undefined, s([
-                  "hello ",
-                  " you're ",
-                  " year old!"
-                ], [
-                  {
-                    TAG: "S",
-                    _0: props.name
-                  },
-                  {
-                    TAG: "I",
-                    _0: props.age
-                  }
-                ]));
-}
-```
-
-</CodeTab>
-
-Pretty neat, isn't it? As you can see, it looks like any regular template literal but it accepts placeholders that are not strings 
-and it outputs something that is not a string either, a `React.element` in this case.
\ No newline at end of file
diff --git a/pages/docs/manual/v11.0.0/try.mdx b/pages/docs/manual/v11.0.0/try.mdx
deleted file mode 100644
index 8969401a3..000000000
--- a/pages/docs/manual/v11.0.0/try.mdx
+++ /dev/null
@@ -1,9 +0,0 @@
----
-title: "Try"
-description: "Try ReScript via Command Line"
-canonical: "/docs/manual/v11.0.0/try"
----
-
-## Try Online
-
-Our [Playground](/try) lets you try ReScript online, and comes with the [ReScript React bindings](/docs/react/latest/introduction) and the new [ReScript Core](https://github.com/rescript-lang/rescript-core) standard library preinstalled.
diff --git a/pages/docs/manual/v11.0.0/tuple.mdx b/pages/docs/manual/v11.0.0/tuple.mdx
deleted file mode 100644
index 13a5e1483..000000000
--- a/pages/docs/manual/v11.0.0/tuple.mdx
+++ /dev/null
@@ -1,104 +0,0 @@
----
-title: "Tuple"
-description: "Tuple types and values in ReScript"
-canonical: "/docs/manual/v11.0.0/tuple"
----
-
-# Tuple
-
-Tuples are a ReScript-specific data structure that don't exist in JavaScript. They are:
-
-- immutable
-- ordered
-- fix-sized at creation time
-- heterogeneous (can contain different types of values)
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let ageAndName = (24, "Lil' ReScript")
-let my3dCoordinates = (20.0, 30.5, 100.0)
-```
-```js
-var ageAndName = [24, "Lil' ReScript"];
-var my3dCoordinates = [20.0, 30.5, 100.0];
-```
-
-</CodeTab>
-
-Tuples' types can be used in type annotations as well. Tuple types visually resemble tuples values.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let ageAndName: (int, string) = (24, "Lil' ReScript")
-// a tuple type alias
-type coord3d = (float, float, float)
-let my3dCoordinates: coord3d = (20.0, 30.5, 100.0)
-```
-```js
-var ageAndName = [24, "Lil' ReScript"];
-var my3dCoordinates = [20.0, 30.5, 100.0];
-```
-</CodeTab>
-
-**Note**: there's no tuple of size 1. You'd just use the value itself.
-
-## Usage
-
-To get a specific member of a tuple, destructure it:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let (_, y, _) = my3dCoordinates // now you've retrieved y
-```
-```js
-var y = 30.5;
-```
-
-</CodeTab>
-
-The `_` means you're ignoring the indicated members of the tuple.
-
-Tuples aren't meant to be updated mutatively. You'd create new ones by destructuring the old ones:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let coordinates1 = (10, 20, 30)
-let (c1x, _, _) = coordinates1
-let coordinates2 = (c1x + 50, 20, 30)
-```
-```js
-var coordinates1 = [10, 20, 30];
-var c1x = 10;
-var coordinates2 = [60, 20, 30];
-```
-
-</CodeTab>
-
-## Tips & Tricks
-
-You'd use tuples in handy situations that pass around multiple values without too much ceremony. For example, to return many values:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let getCenterCoordinates = () => {
-  let x = doSomeOperationsHere()
-  let y = doSomeMoreOperationsHere()
-  (x, y)
-}
-```
-```js
-function getCenterCoordinates(param) {
-  var x = doSomeOperationsHere(undefined);
-  var y = doSomeMoreOperationsHere(undefined);
-  return [x, y];
-}
-```
-
-</CodeTab>
-
-Try to keep the usage of tuple **local**. For data structures that are long-living and passed around often, prefer a **record**, which has named fields.
diff --git a/pages/docs/manual/v11.0.0/type.mdx b/pages/docs/manual/v11.0.0/type.mdx
deleted file mode 100644
index cc0548173..000000000
--- a/pages/docs/manual/v11.0.0/type.mdx
+++ /dev/null
@@ -1,278 +0,0 @@
----
-title: "Type"
-description: "Types and type definitions in ReScript"
-canonical: "/docs/manual/v11.0.0/type"
----
-
-# Type
-
-Types are the highlight of ReScript! They are:
-- **Strong**. A type can't change into another type. In JavaScript, your variable's type might change when the code runs (aka at runtime). E.g. a `number` variable might change into a `string` sometimes. This is an anti-feature; it makes the code much harder to understand when reading or debugging.
-- **Static**. ReScript types are erased after compilation and don't exist at runtime. Never worry about your types dragging down performance. You don't need type info during runtime; we report all the information (especially all the type errors) during compile time. Catch the bugs earlier!
-- **Sound**. This is our biggest differentiator versus many other typed languages that compile to JavaScript. Our type system is guaranteed to **never** be wrong. Most type systems make a guess at the type of a value and show you a type in your editor that's sometime incorrect. We don't do that. We believe that a type system that is sometime incorrect can end up being dangerous due to expectation mismatches.
-- **Fast**. Many developers underestimate how much of their project's build time goes into type checking. Our type checker is one of the fastest around.
-- **Inferred**. You don't have to write down the types! ReScript can deduce them from their values. Yes, it might seem magical that we can deduce all of your program's types, without incorrectness, without your manual annotation, and do so quickly. Welcome to ReScript =).
-
-The following sections explore more of our type system.
-
-## Inference
-
-This let-binding doesn't contain any written type:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let score = 10
-let add = (a, b) => a + b
-```
-```js
-var score = 10;
-function add(a, b) {
-  return a + b | 0;
-}
-```
-
-</CodeTab>
-
-ReScript knows that `score` is an `int`, judging by the value `10`. This is called **inference**. Likewise, it also knows that the `add` function takes 2 `int`s and returns an `int`, judging from the `+` operator, which works on ints.
-
-## Type Annotation
-
-But you can also optionally write down the type, aka annotate your value:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let score: int = 10
-```
-```js
-var score = 10;
-```
-
-</CodeTab>
-
-If the type annotation for `score` doesn't correspond to our inferred type for it, we'll show you an error during compilation time. We **won't** silently assume your type annotation is correct, unlike many other languages.
-
-You can also wrap any expression in parentheses and annotate it:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let myInt = 5
-let myInt: int = 5
-let myInt = (5: int) + (4: int)
-let add = (x: int, y: int) : int => x + y
-let drawCircle = (~radius as r: int): circleType => /* code here */
-```
-```js
-var myInt = 9;
-function add(x, y) {
-  return x + y | 0;
-}
-function drawCircle(r) {
-  /* code here */
-}
-```
-
-</CodeTab>
-
-Note: in the last line, `(~radius as r: int)` is a labeled argument. More on this in the [function](function.md) page.
-
-## Type Alias
-
-You can refer to a type by a different name. They'll be equivalent:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type scoreType = int
-let x: scoreType = 10
-```
-```js
-var x = 10;
-```
-
-</CodeTab>
-
-## Type Parameter (Aka Generic)
-
-Types can accept parameters, akin to generics in other languages. The parameters' names **need** to start with `'`.
-
-The use-case of a parameterized type is to kill duplications. Before:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// this is a tuple of 3 items, explained next
-type intCoordinates = (int, int, int)
-type floatCoordinates = (float, float, float)
-
-let a: intCoordinates = (10, 20, 20)
-let b: floatCoordinates = (10.5, 20.5, 20.5)
-```
-```js
-var a = [10, 20, 20];
-var b = [10.5, 20.5, 20.5];
-```
-
-</CodeTab>
-
-After:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type coordinates<'a> = ('a, 'a, 'a)
-
-let a: coordinates<int> = (10, 20, 20)
-let b: coordinates<float> = (10.5, 20.5, 20.5)
-```
-```js
-var a = [10, 20, 20];
-var b = [10.5, 20.5, 20.5];
-```
-
-</CodeTab>
-
-Note that the above codes are just contrived examples for illustration purposes. Since the types are inferred, you could have just written:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let buddy = (10, 20, 20)
-```
-```js
-var buddy = [10, 20, 20];
-```
-
-</CodeTab>
-
-The type system infers that it's a `(int, int, int)`. Nothing else needed to be written down.
-
-Type arguments appear in many places. Our `array<'a>` type is such a type that requires a type parameter.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// inferred as `array<string>`
-let greetings = ["hello", "world", "how are you"]
-```
-```js
-// inferred as `array<string>`
-var greetings = ["hello", "world", "how are you"];
-```
-
-</CodeTab>
-
-If types didn't accept parameters, the standard library would need to define the types `arrayOfString`, `arrayOfInt`, `arrayOfTuplesOfInt`, etc. That'd be tedious.
-
-Types can receive many arguments, and be composable.
-
-<!-- TODO: too early for this example -->
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type result<'a, 'b> =
-  | Ok('a)
-  | Error('b)
-
-type myPayload = {data: string}
-
-type myPayloadResults<'errorType> = array<result<myPayload, 'errorType>>
-
-let payloadResults: myPayloadResults<string> = [
-  Ok({data: "hi"}),
-  Ok({data: "bye"}),
-  Error("Something wrong happened!")
-]
-```
-```js
-var payloadResults = [
-  {
-    TAG: /* Ok */0,
-    _0: {data: "hi"}
-  },
-  {
-    TAG: /* Ok */0,
-    _0: {data: "bye"}
-  },
-  {
-    TAG: /* Error */1,
-    _0: "Something wrong happened!"
-  }
-];
-```
-
-</CodeTab>
-
-## Recursive Types
-
-Just like a function, a type can reference itself within itself using `rec`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type rec person = {
-  name: string,
-  friends: array<person>
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Mutually Recursive Types
-
-Types can also be _mutually_ recursive through `and`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type rec student = {taughtBy: teacher}
-and teacher = {students: array<student>}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Type Escape Hatch
-
-ReScript's type system is robust and does not allow dangerous, unsafe stuff like implicit type casting, randomly guessing a value's type, etc. However, out of pragmatism, we expose a single escape hatch for you to "lie" to the type system:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-external myShadyConversion: myType1 => myType2 = "%identity"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-This declaration converts a `myType1` of your choice to `myType2` of your choice. You can use it like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-external convertToFloat : int => float = "%identity"
-let age = 10
-let gpa = 2.1 +. convertToFloat(age)
-```
-```js
-var age = 10;
-var gpa = 2.1 + 10;
-```
-
-</CodeTab>
-
-Obviously, do **not** abuse this feature. Use it tastefully when you're working with existing, overly dynamic JS code, for example.
-
-More on externals [here](external.md).
-
-**Note**: this particular `external` is the only one that isn't preceded by a `@` [attribute](attribute.md).
diff --git a/pages/docs/manual/v11.0.0/typescript-integration.mdx b/pages/docs/manual/v11.0.0/typescript-integration.mdx
deleted file mode 100644
index 8a96548a0..000000000
--- a/pages/docs/manual/v11.0.0/typescript-integration.mdx
+++ /dev/null
@@ -1,283 +0,0 @@
----
-title: "TypeScript"
-description: "GenType - Interoperability between ReScript and TypeScript"
-canonical: "/docs/manual/v11.0.0/typescript-integration"
----
-
-# ReScript & TypeScript
-
-The ReScript compiler includes a code generation tool that lets you export ReScript values and types to use in TypeScript, and import TypeScript values and types into ReScript. It is called "genType".
-
-The implementation of genType performs a type-directed transformation of ReScript programs after compilation. The transformed programs operate on data types idiomatic to TypeScript.
-
-For example, a ReScript variant (which is represented as custom objects with tags at runtime):
-
-```res
-@genType
-type t = | A(int) | B(string)
-```
-
-is exported to a TypeScript type:
-
-```ts
-type t = { TAG: "A"; _0: number } | { TAG: "B"; _0: string };
-```
-
-## A Quick Example
-
-Let's assume we are working on a TypeScript codebase and we want to integrate a single ReScript function.
-
-We want to be able to import the function like any other one in our existing TypeScript code, but we also want to preserve all the ReScript types in the TypeScript type system.
-
-**That's exactly what genType was made for!**
-
-First we'll set up a function:
-
-```res
-// src/Color.res
-
-@genType
-type color =
-  | Red
-  | Blue
-
-@genType
-let printColorMessage = (~color, ~message) => {
-  let prefix = switch color {
-  | Red => "\x1b[91m"
-  | Blue => "\x1b[94m"
-  }
-  let reset = "\x1b[0m"
-
-  Console.log(prefix ++ message ++ reset)
-}
-
-```
-
-On a successful compile, `genType` will convert `src/Color.res` to a TypeScript file called `src/Color.gen.tsx` which will look something like this:
-
-```ts
-// src/Color.gen.tsx
-
-/* TypeScript file generated from Color.res by genType. */
-
-/* eslint-disable */
-/* tslint:disable */
-
-import * as ColorJS from "./Color.res.js";
-
-export type color = "Red" | "Blue";
-
-export const printColorMessage: (
-  color: color
-) => void = ColorJS.printColorMessage as any;
-```
-
-genType automatically maps the `color` variant to TS via a string union type `"Red" | "Blue"`.
-
-Within our TypeScript application, we can now import and use the function in the following manner:
-
-```ts
-// src/app.ts
-
-import { printColorMessage } from "./Color.gen.tsx";
-
-printColorMessage("Red", "Hello, genType!");
-```
-
-## Exporting an entire module
-
-_Since ReScript `11.0.0`_ modules can be annotated with `@genType` as well. In that case, all types and values of the module will be converted to TS types. Example: 
-
-<CodeTab labels={["ReScript", "TypeScript Output"]}>
-
-```res example
-@genType
-module Size = {
-  type t =
-    | Small
-    | Medium
-    | Large
-
-  let getNum = (size: t) =>
-    switch size {
-    | Small => 1.
-    | Medium => 5.
-    | Large => 10.
-    }
-}
-```
-
-```ts
-import * as MyCompBS__Es6Import from './MyComp.res';
-const MyCompBS: any = MyCompBS__Es6Import;
-
-export type Size_t = "Small" | "Medium" | "Large";
-
-export const Size_getNum: (size:Size_t) => number = MyCompBS.Size.getNum;
-
-export const Size: { getNum: (size:Size_t) => number } = MyCompBS.Size
-```
-</CodeTab>
-
-
-## Setup
-
-Add a `gentypeconfig` section to your `rescript.json` (See [Configuration](/docs/manual/latest/build-configuration#gentypeconfig) for details).
-
-Every `genType` powered project requires a configuration item `"gentypeconfig"` at top level in the project's `rescript.json`.
-
-The minimal configuration of genType is following:
-
-```json
-{
-  "gentypeconfig": {
-    "module": "esmodule",
-    "moduleResolution": "node",
-    "generatedFileExtension": ".gen.tsx"
-  }
-}
-```
-
-And don't forget to make sure `allowJs` is set to `true` in the project's `tsconfig.json`:
-
-```json
-{
-  "compilerOptions": {
-    "allowJs": true
-  }
-}
-```
-
-### TypeScript Module Resolutions
-
-Make sure to set the same `moduleResolution` value in both `rescript.json` and `tsconfig.json`, so that the output of genType is done with the preferred module resolution.
-
-For example if the TypeScript project uses JavaScript modules with `Node16` / `NodeNext` module resolution:
-
-```json
-// tsconfig.json
-{
-  "compilerOptions": {
-    "moduleResolution": "node16"
-  }
-}
-```
-
-Then `moduleResolution` in `gentypeconfig` should be same value:
-
-```json
-// rescript.json
-{
-  "gentypeconfig": {
-    "moduleResolution": "node16"
-  }
-}
-```
-
-In case of the TypeScript project using `Bundler` module resolution, `allowImportingTsExtensions` should also be `true`:
-
-```json
-// tsconfig.json
-{
-  "compilerOptions": {
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true
-  }
-}
-```
-
-```json
-// rescript.json
-{
-  "gentypeconfig": {
-    "moduleResolution": "bundler"
-  }
-}
-```
-
-## Testing the Whole Setup
-
-Open any relevant `*.res` file and add `@genType` annotations to any bindings / values / functions to be used from JavaScript. If an annotated value uses a type, the type must be annotated too. See e.g. [Hooks.res](https://github.com/rescript-lang/rescript/blob/master/tests/gentype_tests/typescript-react-example/src/Hooks.res).
-
-Save the file and rebuild the project via `npm run res:build` or similar. You should now see a `*.gen.tsx` file with the same name (e.g. `MyComponent.res` -> `MyComponent.gen.tsx`).
-
-Any values exported from `MyComponent.res` can then be imported from TypeScript. For example:
-
-```js
-import MyComponent from "./components/MyComponent.gen.tsx";
-```
-
-## Experimental features
-
-These features are for experimentation only. They could be changed/removed any time, and not be considered breaking changes.
-
-- Export object and record types as interfaces. To activate, add `"exportInterfaces": true` to the configuration. The types are also renamed from `name` to `Iname`.
-
-
-## Shims
-
-A shim is a TS file that provides user-provided definitions for library types.
-
-Required only if one needs to export certain basic ReScript data types to JS when one cannot modify the sources to add annotations (e.g. exporting ReScript lists), and if the types are not first-classed in genType.
-  - Example: `Array<string>` with format: `"RescriptModule=JavaScriptModule"`
-
-Configure your shim files within `"gentypeconfig"` in your [`rescript.json`]:
-
-```json
-{
-  "gentypeconfig": {
-    "shims": {
-      "Js": "Js",
-      "ReactEvent": "ReactEvent",
-      "RescriptPervasives": "RescriptPervasives",
-      "ReasonReact": "ReactShim"
-    },
-  },
-}
-```
-
-and add relevant `.shim.ts` files in a directory which is visible by ReScript e.g. 
-
-```
-├── rescript.json
-├── src
-│   ├── shims
-│   │   ├── Js.shim.ts
-│   │   ├── ReactEvent.shim.ts
-│   │   └── RescriptPervasives.shim.ts
-```
-
-Here are some examples:
-
-```ts
-// Excerpt from https://github.com/rescript-lang/rescript/blob/master/tests/gentype_tests/typescript-react-example/src/shims/Js.shim.ts
-export type Json_t = unknown;
-export type t = unknown;
-```
-
-```ts
-// Excerpt from https://github.com/rescript-lang/rescript/tree/master/tests/gentype_tests/typescript-react-example/src/shims/JsxEvent.shim.ts
-export type inputFocusEvent = React.FocusEvent<HTMLInputElement>;
-```
-
-More complete example shims can be found [here](https://github.com/rescript-lang/rescript/blob/master/tests/gentype_tests/typescript-react-example/src/shims/).
-
-## Deprecated features
-
-Features related to generating runtimes were deprecated since v11 and should no longer be used.
-
-- **`@genType("alias")`** and **`@genType.as("alias")`**
-- **`@genType.opaque`**
-- **`@genType.import`**
-- TypeScript Shims
-
-genType does not generate anything runtime-related, and in the near future it generates definition files (`*.d.ts`) directly (See the [roadmap](https://github.com/rescript-lang/rescript/issues/6196)).
-
-If any runtime code is required for interoperability with JavaScript / TypeScript projects, it can be written by hand, or request a relevant features (e.g. `@deriving`) to the compiler.
-
-## Limitations
-
-- **in-source = true**. Currently only supports ReScript projects with [in-source generation](/docs/manual/latest/build-configuration#package-specs) and file suffixes that end on `.js`, like `.res.js` or `.bs.js`.
-
-- **Limited namespace support**. Currently there's limited [namespace](/docs/manual/latest/build-configuration#name-namespace) support, and only `namespace:true` is possible, not e.g. `namespace:"custom"`.
diff --git a/pages/docs/manual/v11.0.0/use-illegal-identifier-names.mdx b/pages/docs/manual/v11.0.0/use-illegal-identifier-names.mdx
deleted file mode 100644
index f1ced4ca1..000000000
--- a/pages/docs/manual/v11.0.0/use-illegal-identifier-names.mdx
+++ /dev/null
@@ -1,51 +0,0 @@
----
-title: "Use Illegal Identifier Names"
-description: "Handling (JS) naming collisions in ReScript"
-canonical: "/docs/manual/v11.0.0/use-illegal-identifier-names"
----
-
-# Use Illegal Identifier Names
-
-Sometime, for e.g. a let binding or a record field, you might want to use:
-- A capitalized name.
-- A name that contains illegal characters (e.g. emojis, hyphen, space).
-- A name that's one of ReScript's reserved keywords.
-
-We provide an escape hatch syntax for these cases:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let \"my-🍎" = 10
-
-type element = {
-  \"aria-label": string
-}
-
-let myElement = {
-  \"aria-label": "close"
-}
-
-let label = myElement.\"aria-label"
-
-let calculate = (~\"Props") => {
-  \"Props" + 1
-}
-```
-```js
-var my$$unknown$unknown$unknown$unknown = 10;
-
-var myElement = {
-  "aria-label": "close"
-};
-
-var label = myElement["aria-label"];
-
-function calculate(Props) {
-  return Props + 1 | 0;
-}
-```
-
-</CodeTab>
-
-See the output. **Use them only when necessary**, for interop with JavaScript. This is a last-resort feature. If you abuse this, many of the compiler guarantees will go away.
diff --git a/pages/docs/manual/v11.0.0/variant.mdx b/pages/docs/manual/v11.0.0/variant.mdx
deleted file mode 100644
index ff9599e3e..000000000
--- a/pages/docs/manual/v11.0.0/variant.mdx
+++ /dev/null
@@ -1,798 +0,0 @@
----
-title: "Variant"
-description: "Variant data structures in ReScript"
-canonical: "/docs/manual/v11.0.0/variant"
----
-
-# Variant
-
-So far, most of ReScript's data structures might look familiar to you. This section introduces an extremely important, and perhaps unfamiliar, data structure: variant.
-
-Most data structures in most languages are about "this **and** that". A variant allows us to express "this **or** that".
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type myResponse =
-  | Yes
-  | No
-  | PrettyMuch
-
-let areYouCrushingIt = Yes
-```
-```js
-var areYouCrushingIt = "Yes";
-```
-
-</CodeTab>
-
-`myResponse` is a variant type with the cases `Yes`, `No` and `PrettyMuch`, which are called "variant constructors" (or "variant tag"). The `|` bar separates each constructor.
-
-**Note**: a variant's constructors need to be capitalized.
-
-## Variant Needs an Explicit Definition
-
-If the variant you're using is in a different file, bring it into scope like you'd do [for a record](record.md#record-needs-an-explicit-definition):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// Zoo.res
-type animal = Dog | Cat | Bird
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Example.res
-let pet: Zoo.animal = Dog // preferred
-// or
-let pet2 = Zoo.Dog
-```
-```js
-var pet = "Dog";
-var pet2 = "Dog";
-```
-
-</CodeTab>
-
-## Constructor Arguments
-
-A variant's constructors can hold extra data separated by comma.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type account =
-  | None
-  | Instagram(string)
-  | Facebook(string, int)
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Here, `Instagram` holds a `string`, and `Facebook` holds a `string` and an `int`. Usage:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myAccount = Facebook("Josh", 26)
-let friendAccount = Instagram("Jenny")
-```
-```js
-var myAccount = {
-  TAG: "Facebook",
-  _0: "Josh",
-  _1: 26
-};
-var friendAccount = {
-  TAG: "Instagram",
-  _0: "Jenny"
-};
-```
-
-</CodeTab>
-
-### Labeled Variant Payloads (Inline Record)
-
-If a variant payload has multiple fields, you can use a record-like syntax to label them for better readability:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type user =
-  | Number(int)
-  | Id({name: string, password: string})
-
-let me = Id({name: "Joe", password: "123"})
-```
-```js
-var me = {
-  TAG: "Id",
-  name: "Joe",
-  password: "123"
-};
-```
-
-</CodeTab>
-
-This is technically called an "inline record", and only allowed within a variant constructor. You cannot inline a record type declaration anywhere else in ReScript.
-
-Of course, you can just put a regular record type in a variant too:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type u = {name: string, password: string}
-type user =
-  | Number(int)
-  | Id(u)
-
-let me = Id({name: "Joe", password: "123"})
-```
-```js
-var me = {
-  TAG: "Id",
-  _0: {
-    name: "Joe",
-    password: "123"
-  }
-};
-```
-
-</CodeTab>
-
-The output is slightly uglier and less performant than the former.
-
-## Variant Type Spreads
-Just like [with records](record#record-type-spread), it's possible to use type spreads to create new variants from other variants:
-
-```rescript
-type a = One | Two | Three
-type b = | ...a | Four | Five
-```
-
-Type `b` is now:
-```rescript
-type b = One | Two | Three | Four | Five
-```
-
-Type spreads act as a 'copy-paste', meaning all constructors are copied as-is from `a` to `b`. Here are the rules for spreads to work:
-- You can't overwrite constructors, so the same constructor name can exist in only one place as you spread. This is true even if the constructors are identical.
-- All variants and constructors must share the same runtime configuration - `@unboxed`, `@tag`, `@as` and so on.
-- You can't spread types in recursive definitions.
-
-Note that you need a leading `|` if you want to use a spread in the first position of a variant definition.
-
-### Pattern Matching On Variant
-
-See the [Pattern Matching/Destructuring](pattern-matching-destructuring) section later.
-
-## JavaScript Output
-
-A variant value compiles to 3 possible JavaScript outputs depending on its type declaration:
-
-- If the variant value is a constructor with no payload, it compiles to a string of the constructor name. Example: `Yes` compiles to `"Yes"`.
-- If it's a constructor with a payload, it compiles to an object with the field `TAG` and the field `_0` for the first payload, `_1` for the second payload, etc. The value of `TAG` is the constructor name as string by default, but note that the name of the `TAG` field as well as the string value used for each constructor name [can be customized](#tagged-variants).
-- Labeled variant payloads (the inline record trick earlier) compile to an object with the label names instead of `_0`, `_1`, etc. The object will have the `TAG` field as per the previous rule.
-
-Check the output in these examples:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type greeting = Hello | Goodbye
-let g1 = Hello
-let g2 = Goodbye
-
-type outcome = Good | Error(string)
-let o1 = Good
-let o2 = Error("oops!")
-
-type family = Child | Mom(int, string) | Dad (int)
-let f1 = Child
-let f2 = Mom(30, "Jane")
-let f3 = Dad(32)
-
-type person = Teacher | Student({gpa: float})
-let p1 = Teacher
-let p2 = Student({gpa: 99.5})
-
-type s = {score: float}
-type adventurer = Warrior(s) | Wizard(string)
-let a1 = Warrior({score: 10.5})
-let a2 = Wizard("Joe")
-```
-```js
-var g1 = "Hello";
-
-var g2 = "Goodbye";
-
-var o1 = "Good";
-
-var o2 = {
-  TAG: "Error",
-  _0: "oops!"
-};
-
-var f1 = "Child";
-
-var f2 = {
-  TAG: "Mom",
-  _0: 30,
-  _1: "Jane"
-};
-
-var f3 = {
-  TAG: "Dad",
-  _0: 32
-};
-
-var p1 = "Teacher";
-
-var p2 = {
-  TAG: "Student",
-  gpa: 99.5
-};
-
-var a1 = {
-  TAG: "Warrior",
-  _0: {
-    score: 10.5
-  }
-};
-
-var a2 = {
-  TAG: "Wizard",
-  _0: "Joe"
-};
-```
-
-</CodeTab>
-
-## Tagged variants
-
-- The `@tag` attribute lets you customize the discriminator (default: `TAG`).
-- `@as` attributes control what each variant case is discriminated on (default: the variant case name as string).
-
-### Example: Binding to TypeScript enums
-
-```typescript
-// direction.ts
-/** Direction of the action. */
-enum Direction {
-  /** The direction is up. */
-  Up = "UP",
-
-  /** The direction is down. */
-  Down = "DOWN",
-
-  /** The direction is left. */
-  Left = "LEFT",
-
-  /** The direction is right. */
-  Right = "RIGHT",
-}
-
-export const myDirection = Direction.Up;
-```
-
-You can bind to the above enums like so:
-
-```rescript
-/** Direction of the action. */
-type direction =
-  | /** The direction is up. */
-  @as("UP")
-  Up
-
-  | /** The direction is down. */
-  @as("DOWN")
-  Down
-
-  | /** The direction is left. */
-  @as("LEFT")
-  Left
-
-  | /** The direction is right. */
-  @as("RIGHT")
-  Right
-
-@module("./direction.js") external myDirection: direction = "myDirection"
-```
-
-Now, this maps 100% to the TypeScript code, including letting us bring over the documentation strings so we get a nice editor experience.
-
-### String literals
-
-The same logic is easily applied to string literals from TypeScript, only here the benefit is even larger, because string literals have the same limitations in TypeScript that polymorphic variants have in ReScript:
-
-```typescript
-// direction.ts
-type direction = "UP" | "DOWN" | "LEFT" | "RIGHT";
-```
-
-There's no way to attach documentation strings to string literals in TypeScript, and you only get the actual value to interact with.
-
-### Valid `@as` payloads
-Here's a list of everything you can put in the `@as` tag of a variant constructor:
-- A string literal: `@as("success")`
-- An int: `@as(5)`
-- A float: `@as(1.5)`
-- True/false: `@as(true)` and `@as(false)`
-- Null: `@as(null)`
-- Undefined: `@as(undefined)`
-
-## Untagged variants
-
-With _untagged variants_ it is possible to mix types together that normally can't be mixed in the ReScript type system, as long as there's a way to discriminate them at runtime. For example, with untagged variants you can represent a heterogenous array:
-
-```rescript
-@unboxed type listItemValue = String(string) | Boolean(bool) | Number(float)
-
-let myArray = [String("Hello"), Boolean(true), Boolean(false), Number(13.37)]
-```
-
-Here, each value will be _unboxed_ at runtime. That means that the variant payload will be all that's left, the variant case name wrapping the payload itself will be stripped out and the payload will be all that remains.
-
-It, therefore, compiles to this JS:
-
-```javascript
-var myArray = ["hello", true, false, 13.37];
-```
-
-In the above example, reaching back into the values is as simple as pattern matching on them.
-
-### Advanced: Unboxing rules
-#### No overlap in constructors
-A variant can be unboxed if no constructors have overlap in their runtime representation. 
-
-For example, you can't have `String1(string) | String2(string)` in the same unboxed variant, because there's no way for ReScript to know at runtime which of `String1` or `String2` that `string` belongs to, as it could belong to both.
-The same goes for two records - even if they have fully different shapes, they're still JavaScript `object` at runtime.
-
-Don't worry - the compiler will guide you and ensure there's no overlap.
-
-#### What you can unbox
-Here's a list of all possible things you can unbox:
-- `string`: `String(string)`
-- `float`: `Float(float)`. Note you can only have one of `float` or `int` because JavaScript only has `number` (not actually `int` and `float` like in ReScript) so we can't disambiguate between `float` and `int` at runtime.
-- `int`: `Int(int)`. See note above on `float`.
-- `bigint`: `BigInt(int)`. **Since 11.1** This is a distinct type from JavaScript's `number` type so you can use it beside either `float` or `int`.
-- `bool`: `Boolean(bool)`
-- `array<'value>`: `List(array<string>)`
-- `('a, 'b, 'c)`: `Tuple((string, int, bool))`. Any size of tuples works, but you can have only one case of array or tuple in a variant. 
-- `promise<'value>`: `Promise(promise<string>)`
-- `Dict.t`: `Object(Dict.t<string>)`
-- `Date.t`: `Date(Date.t)`. A JavaScript date.
-- `Blob.t`: `Blob(Blob.t)`. A JavaScript blob.
-- `File.t`: `File(File.t)`. A JavaScript file.
-- `RegExp.t`: `RegExp(RegExp.t)`. A JavaScript regexp instance.
-
-Again notice that the constructor names can be anything, what matters is what's in the payload.
-
-> **Under the hood**: Untagged variants uses a combination of JavaScript `typeof` and `instanceof` checks to discern between unboxed constructors at runtime. This means that we could add more things to the list above detailing what can be unboxed, if there are useful enough use cases.
-
-### Pattern matching on unboxed variants
-Pattern matching works the same on unboxed variants as it does on regular variants. In fact, in the perspective of ReScript's type system there's no difference between untagged and tagged variants. You can do virtually the same things with both. That's the beauty of untagged variants - they're just variants to you as a developer.
-
-Here's an example of pattern matching on an unboxed nullable value that illustrates the above:
-
-```rescript
-module Null = {
-  @unboxed type t<'a> = Present('a) | @as(null) Null
-}
-
-type userAge = {ageNum: Null.t<int>}
-
-type rec user = {
-  name: string,
-  age: Null.t<userAge>,
-  bestFriend: Null.t<user>,
-}
-
-let getBestFriendsAge = user =>
-  switch user.bestFriend {
-  | Present({age: Present({ageNum: Present(ageNum)})}) => Some(ageNum)
-  | _ => None
-  }
-```
-No difference to how you'd do with a regular variant. But, the runtime representation is different to a regular variant.
-
-> Notice how `@as` allows us to say that an untagged variant case should map to a specific underlying _primitive_. `Present` has a type variable, so it can hold any type. And since it's an unboxed type, only the payloads `'a` or `null` will be kept at runtime. That's where the magic comes from.
-
-### Decoding and encoding JSON idiomatically
-
-With untagged variants, we have everything we need to define a native JSON type:
-
-```rescript
-@unboxed
-type rec json =
-  | @as(null) Null
-  | Boolean(bool)
-  | String(string)
-  | Number(float)
-  | Object(Dict.t<json>)
-  | Array(array<json>)
-
-let myValidJsonValue = Array([String("Hi"), Number(123.)])
-```
-
-Here's an example of how you could write your own JSON decoders easily using the above, leveraging pattern matching:
-
-```rescript
-@unboxed
-type rec json =
-  | @as(null) Null
-  | Boolean(bool)
-  | String(string)
-  | Number(float)
-  | Object(Dict.t<json>)
-  | Array(array<json>)
-
-type rec user = {
-  name: string,
-  age: int,
-  bestFriend: option<user>,
-}
-
-let rec decodeUser = json =>
-  switch json {
-  | Object(userDict) =>
-    switch (
-      userDict->Dict.get("name"),
-      userDict->Dict.get("age"),
-      userDict->Dict.get("bestFriend"),
-    ) {
-    | (Some(String(name)), Some(Number(age)), Some(maybeBestFriend)) =>
-      Some({
-        name,
-        age: age->Float.toInt,
-        bestFriend: maybeBestFriend->decodeUser,
-      })
-    | _ => None
-    }
-  | _ => None
-  }
-
-let decodeUsers = json =>
-  switch json {
-  | Array(array) => array->Array.map(decodeUser)->Array.keepSome
-  | _ => []
-  }
-```
-
-Encoding that same structure back into JSON is also easy:
-
-```rescript
-let rec userToJson = user => Object(
-  Dict.fromArray([
-    ("name", String(user.name)),
-    ("age", Number(user.age->Int.toFloat)),
-    (
-      "bestFriend",
-      switch user.bestFriend {
-      | None => Null
-      | Some(friend) => userToJson(friend)
-      },
-    ),
-  ]),
-)
-
-let usersToJson = users => Array(users->Array.map(userToJson))
-```
-
-This can be extrapolated to many more cases.
-
-### Advanced: Catch-all Constructors
-With untagged variants comes a rather interesting capability - catch-all cases are now possible to encode directly into a variant. 
-
-Let's look at how it works. Imagine you're using a third party API that returns a list of available animals. You could of course model it as a regular `string`, but given that variants can be used as "typed strings", using a variant would give you much more benefit:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-```rescript
-type animal = Dog | Cat | Bird
-
-type apiResponse = {
-  animal: animal
-}
-
-let greetAnimal = (animal: animal) =>
-  switch animal {
-  | Dog => "Wof"
-  | Cat => "Meow"
-  | Bird => "Kashiiin"
-  }
-```
-```javascript
-```
-</CodeTab>
-
-
-This is all fine and good as long as the API returns `"Dog"`, `"Cat"` or `"Bird"` for `animal`. 
-However, what if the API changes before you have a chance to deploy new code, and can now return `"Turtle"` as well? Your code would break down because the variant `animal` doesn't cover `"Turtle"`.
-
-So, we'll need to go back to `string`, loosing all of the goodies of using a variant, and then do manual conversion into the `animal` variant from `string`, right?
-Well, this used to be the case before, but not anymore! We can leverage untagged variants to bake in handling of unknown values into the variant itself.
-
-Let's update our type definition first:
-```rescript
-@unboxed
-type animal = Dog | Cat | Bird | UnknownAnimal(string)
-```
-
-Notice we've added `@unboxed` and the constructor `UnknownAnimal(string)`. Remember how untagged variants work? You remove the constructors and just leave the payloads. This means that the variant above at runtime translates to this (made up) JavaScript type:
-```
-type animal = "Dog" | "Cat" | "Bird" | string
-```
-So, any string not mapping directly to one of the payloadless constructors will now map to the general `string` case.
-
-As soon as we've added this, the compiler complains that we now need to handle this additional case in our pattern match as well. Let's fix that:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-```rescript
-@unboxed
-type animal = Dog | Cat | Bird | UnknownAnimal(string)
-
-type apiResponse = {
-  animal: animal
-}
-
-let greetAnimal = (animal: animal) =>
-  switch animal {
-  | Dog => "Wof"
-  | Cat => "Meow"
-  | Bird => "Kashiiin"
-  | UnknownAnimal(otherAnimal) =>
-    `I don't know how to greet animal ${otherAnimal}`
-  }
-```
-```javascript
-function greetAnimal(animal) {
-  if (!(animal === "Cat" || animal === "Dog" || animal === "Bird")) {
-    return "I don't know how to greet animal " + animal;
-  }
-  switch (animal) {
-    case "Dog" :
-        return "Wof";
-    case "Cat" :
-        return "Meow";
-    case "Bird" :
-        return "Kashiiin";
-    
-  }
-}
-```
-</CodeTab>
-
-There! Now the external API can change as much as it wants, we'll be forced to write all code that interfaces with `animal` in a safe way that handles all possible cases. All of this baked into the variant definition itself, so no need for labor intensive manual conversion.
-
-This is useful in any scenario when you use something enum-style that's external and might change. Additionally, it's also useful when something external has a large number of possible values that are known, but where you only care about a subset of them. With a catch-all case you don't need to bind to all of them just because they can happen, you can safely just bind to the ones you care about and let the catch-all case handle the rest.
-
-## Coercion
-In certain situations, variants can be coerced to other variants, or to and from primitives. Coercion is always zero cost.
-
-### Coercing Variants to Other Variants
-You can coerce a variant to another variant if they're identical in runtime representation, and additionally if the variant you're coercing can be represented as the variant you're coercing to.
-
-Here's an example using [variant type spreads](#variant-type-spreads):
-```rescript
-type a = One | Two | Three
-type b = | ...a | Four | Five
-
-let one: a = One
-let four: b = Four
-
-// This works because type `b` can always represent type `a` since all of type `a`'s constructors are spread into type `b` 
-let oneAsTypeB = (one :> b)
-```
-
-### Coercing Variants to Primitives
-Variants that are guaranteed to always be represented by a single primitive at runtime can be coerced to that primitive.
-
-It works with strings, the default runtime representation of payloadless constructors:
-```rescript
-// Constructors without payloads are represented as `string` by default
-type a = One | Two | Three
-
-let one: a = One
-
-// All constructors are strings at runtime, so you can safely coerce it to a string
-let oneAsString = (one :> string)
-```
-
-If you were to configure all of your construtors to be represented as `int` or `float`, you could coerce to those too:
-```rescript
-type asInt = | @as(1) One | @as(2) Two | @as(3) Three
-
-let oneInt: asInt = One
-let toInt = (oneInt :> int)
-```
-
-### Advanced: Coercing `string` to Variant
-In certain situtations it's possible to coerce a `string` to a variant. This is an advanced technique that you're unlikely to need much, but when you do it's really useful.
-
-You can coerce a `string` to a variant when:
-- Your variant is `@unboxed`
-- Your variant has a "catch-all" `string` case
-
-Let's look at an example:
-```rescript
-@unboxed
-type myEnum = One | Two | Other(string)
-
-// Other("Other thing")
-let asMyEnum = ("Other thing" :> myEnum)
-
-// One
-let asMyEnum = ("One" :> myEnum)
-```
-
-This works because the variant is unboxed **and** has a catch-all case. So, if you throw a string at this variant that's not representable by the payloadless constructors, like `"One"` or `"Two"`, it'll _always_ end up in `Other(string)`, since that case can represent any `string`.
-
-## Tips & Tricks
-
-**Be careful** not to confuse a constructor carrying 2 arguments with a constructor carrying a single tuple argument:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type account =
-  | Facebook(string, int) // 2 arguments
-type account2 =
-  | Instagram((string, int)) // 1 argument - happens to be a 2-tuple
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-### Variants Must Have Constructors
-
-If you come from an untyped language, you might be tempted to try `type myType = int | string`. This isn't possible in ReScript; you'd have to give each branch a constructor: `type myType = Int(int) | String(string)`. The former looks nice, but causes lots of trouble down the line.
-
-### Interop with JavaScript
-
-_This section assumes knowledge about our JavaScript interop. Skip this if you haven't felt the itch to use variants for wrapping JS functions yet_.
-
-Quite a few JS libraries use functions that can accept many types of arguments. In these cases, it's very tempting to model them as variants. For example, suppose there's a `myLibrary.draw` JS function that takes in either a `number` or a `string`. You might be tempted to bind it like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// reserved for internal usage
-@module("myLibrary") external draw : 'a => unit = "draw"
-
-type animal =
-  | MyFloat(float)
-  | MyString(string)
-
-let betterDraw = (animal) =>
-  switch animal {
-  | MyFloat(f) => draw(f)
-  | MyString(s) => draw(s)
-  }
-
-betterDraw(MyFloat(1.5))
-```
-```js
-var MyLibrary = require("myLibrary");
-
-function betterDraw(animal) {
-  MyLibrary.draw(animal._0);
-}
-
-betterDraw({
-      TAG: "MyFloat",
-      _0: 1.5
-    });
-```
-
-</CodeTab>
-
-**Try not to do that**, as this generates extra noisy output. Instead, use the `@unboxed` attribute to guide ReScript to generate more efficient code:
-
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// reserved for internal usage
-@module("myLibrary") external draw : 'a => unit = "draw"
-
-@unboxed
-type animal =
-  | MyFloat(float)
-  | MyString(string)
-
-let betterDraw = (animal) =>
-  switch animal {
-  | MyFloat(f) => draw(f)
-  | MyString(s) => draw(s)
-  }
-
-betterDraw(MyFloat(1.5))
-```
-```js
-var MyLibrary = require("myLibrary");
-
-function betterDraw(animal) {
-  MyLibrary.draw(animal);
-}
-
-MyLibrary.draw(1.5);
-```
-
-</CodeTab>
-
-Alternatively, define two `external`s that both compile to the same JS call:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("myLibrary") external drawFloat: float => unit = "draw"
-@module("myLibrary") external drawString: string => unit = "draw"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-ReScript also provides [a few other ways](bind-to-js-function.md#modeling-polymorphic-function) to do this.
-
-### Variant Types Are Found By Field Name
-
-Please refer to this [record section](record#tips--tricks). Variants are the same: a function can't accept an arbitrary constructor shared by two different variants. Again, such feature exists; it's called a polymorphic variant. We'll talk about this in the future =).
-
-## Design Decisions
-
-Variants, in their many forms (polymorphic variant, open variant, GADT, etc.), are likely _the_ feature of a type system such as ReScript's. The aforementioned `option` variant, for example, obliterates the need for nullable types, a major source of bugs in other languages. Philosophically speaking, a problem is composed of many possible branches/conditions. Mishandling these conditions is the majority of what we call bugs. **A type system doesn't magically eliminate bugs; it points out the unhandled conditions and asks you to cover them**\*. The ability to model "this or that" correctly is crucial.
-
-For example, some folks wonder how the type system can safely eliminate badly formatted JSON data from propagating into their program. They don't, not by themselves! But if the parser returns the `option` type `None | Some(actualData)`, then you'd have to handle the `None` case explicitly in later call sites. That's all there is.
-
-Performance-wise, a variant can potentially tremendously speed up your program's logic. Here's a piece of JavaScript:
-
-```js
-let data = 'dog'
-if (data === 'dog') {
-  ...
-} else if (data === 'cat') {
-  ...
-} else if (data === 'bird') {
-  ...
-}
-```
-
-There's a linear amount of branch checking here (`O(n)`). Compare this to using a ReScript variant:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type animal = Dog | Cat | Bird
-let data = Dog
-switch data {
-| Dog => Console.log("Wof")
-| Cat => Console.log("Meow")
-| Bird => Console.log("Kashiiin")
-}
-```
-```js
-console.log("Wof");
-
-var data = "Dog";
-```
-
-</CodeTab>
-
-The compiler sees the variant, then
-
-1. conceptually turns them into `type animal = "Dog" | "Cat" | "Bird"`
-2. compiles `switch` to a constant-time jump table (`O(1)`).
diff --git a/pages/docs/manual/v11.0.0/warning-numbers.mdx b/pages/docs/manual/v11.0.0/warning-numbers.mdx
deleted file mode 100644
index 55eb1f04b..000000000
--- a/pages/docs/manual/v11.0.0/warning-numbers.mdx
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: "Warning Numbers"
-description: "Available compiler warning numbers in ReScript"
-canonical: "/docs/manual/v11.0.0/warning-numbers"
----
-
-import { make as WarningTable } from "src/components/WarningTable.mjs";
-
-# Warning Numbers
-
-You can configure which warnings the ReScript compiler generates
-[in the build configuration](/docs/manual/latest/build-configuration#warnings) or
-using the [`@warning()`](/syntax-lookup#expression-warning-decorator) or the [`@@warning()`](/syntax-lookup#module-warning-decorator) decorator.
-
-<WarningTable />
diff --git a/pages/docs/manual/v8.0.0/api.mdx b/pages/docs/manual/v8.0.0/api.mdx
deleted file mode 100644
index 14dbdfb09..000000000
--- a/pages/docs/manual/v8.0.0/api.mdx
+++ /dev/null
@@ -1,15 +0,0 @@
-# Introduction
-
-We ship 3 modules in our standard library.
-
-- [Js](api/js): bindings for all your familiar JavaScript APIs.
-- [Belt](api/belt): extra collections and helpers not available in JavaScript.
-- [Dom](api/dom): Dom related types and modules.
-
-Usage heuristics:
-
-- Default to using the `Js` module. Most of the APIs in it are runtime-free and compile down to clean, readable JavaScript, which is our priority.
-- For other APIs that aren't available in regular JavaScript (and thus don't exist in our `Js` bindings), use Belt. For example, prefer `Js.Array2` over `Belt.Array`.
-- The `Dom` module contains our standardized types used by various userland DOM bindings. Due to the complexity of DOM, we don't mind that you ignore this module and build your application-specific DOM bindings.
-
-**Note**: we do not recommend other userland standard library alternatives (unless it's DOM bindings). These cause confusion and split points for the community.
diff --git a/pages/docs/manual/v8.0.0/api/belt.mdx b/pages/docs/manual/v8.0.0/api/belt.mdx
deleted file mode 100644
index 657b1b643..000000000
--- a/pages/docs/manual/v8.0.0/api/belt.mdx
+++ /dev/null
@@ -1,225 +0,0 @@
-# Belt
-
-The preferred standard library for Reason when targeting JavaScript
-(browser, node, React Native).
-
-It is recommended to use the modules from Belt rather than from the
-OCaml standard library or from the [Js](./js) namespace, e.g. use
-[Belt.List](./belt/list) instead of `List` or [Js.List](./js/list)
-and [Belt.Array](./belt/array) instead of `Array` or [Js.Array](./js/array).
-
-Belt is currently mostly covering collection types. It has no string or
-date functions yet, although Belt.String is in the works. (In the meantime,
-use [Js.String](./js/string) for string functions and [Js.Date](./js/date)
-for date functions.)
-
-## Motivation
-
-Belt aims to improve the user experience for Reason developers targeting
-JavaScript as well as for JavaScript developers learning Reason,
-since the original OCaml standard library was not written with JS in mind.
-
-To achieve this, Belt provides:
-
-- A consistent naming convention familiar to JS developers ([camelCase](https://en.wikipedia.org/wiki/Camel_case))
-- A consistent argument order familiar to JS Developers (see [Pipe First](#Pipe%20First))
-- Safety by default: A Belt function will never throw exceptions, unless it is
-  indicated explicitly in the function name (suffix "Exn").
-- Better performance and smaller code size running on the JS platform
-- Ready for [Tree Shaking](https://webpack.js.org/guides/tree-shaking/)
-
-## Usage
-
-To use modules from Belt, either refer to them by their fully qualified name
-(`Belt.List`, `Belt.Array` etc.) or open the `Belt` module by putting
-
-```
-open Belt;
-```
-
-at the top of your source files. After opening Belt this way,
-`Array` will refer to `Belt.Array`, `List` will refer to `Belt.List` etc.
-in the source code below.
-
-If you want to open Belt globally for all files in your project instead,
-you can put
-
-```
-  "bsc-flags": [ "-open Belt" ],
-```
-
-into your `bsconfig.json`.
-
-## Pipe First
-
-The argument order of Belt functions follows the "Data-First" convention.
-I.e. the object they act on (e.g. a list or an array) will always be
-the first argument.
-
-This way, the _pipe first operator_ `->` can be used nicely with the Belt APIs,
-giving a similar feel to method invocations in OOP languages and allowing
-easy chaining of Belt API calls.
-
-For more information about the data-first argument order and the
-trade-offs compared to data-last, see
-[this blog post](https://www.javierchavarri.com/data-first-and-data-last-a-comparison/).
-
-Example:
-
-```
-let someNumbers = [|1, 1, 4, 2, 3, 6, 3, 4, 2|];
-
-let greaterThan2UniqueAndSorted =
-  someNumbers
-  ->Belt.Array.keep(x => x > 2)
-  /* convert to and from set to make values unique */
-  ->Belt.Set.Int.fromArray
-  ->Belt.Set.Int.toArray; /* output is already sorted */
-
-Js.log2("result", greaterThan2UniqueAndSorted);
-```
-
-## Curried vs. Uncurried Callbacks
-
-For functions taking a callback parameter, there are usually two versions
-available:
-
-- curried (no suffix)
-- uncurried (suffixed with `U`)
-
-E.g.:
-
-```
-let forEach: (t('a), 'a => unit) => unit;
-
-let forEachU: (t('a), (. 'a) => unit) => unit;
-```
-
-The uncurried version will be faster in some cases, but for simplicity we
-recommend to stick with the curried version unless you know
-what you are doing and really need the optimization.
-
-The two versions can be invoked as follows:
-
-```
-["a", "b", "c"]->Belt.List.forEach(x => Js.log(x));
-
-["a", "b", "c"]->Belt.List.forEachU((. x) => Js.log(x));
-```
-
-## Specialized Collections
-
-For collections types like set or map, Belt provides both a generic module
-as well as specialized, more efficient implementations for string and int keys.
-
-For example, Belt has the following set modules:
-
-- [Belt.Set](./belt/set)
-- [Belt.Set.Int](./belt/set-int)
-- [Belt.Set.String](./belt/set-string)
-
-## Implementation Details
-
-### Array access runtime safety
-
-One common confusion comes from the way Belt handles array access. It differs from than the default standard library's.
-
-```reason
-let letters = [|"a", "b", "c"|];
-let a = letters[0]; /* a == "a" */
-let capitalA = Js.String.toUpperCase(a);
-let k = letters[10]; /* Raises an exception! The 10th index doesn't exist. */
-```
-
-Because Belt avoids exceptions and returns `options` instead, this code behaves differently:
-
-```reason
-open Belt;
-let letters = [|"a", "b", "c"|];
-let a = letters[0]; /* a == Some("a") */
-let captialA = Js.String.toUpperCase(a); /* Type error! This code will not compile. */
-let k = letters[10]; /* k == None */
-```
-
-Although we've fixed the problem where `k` raises an exception, we now have a type error when trying to capitalize `a`. There are a few things going on here:
-
-- Reason transforms array index access to the function `Array.get`. So `letters[0]` is the same as `Array.get(letters, 0)`. 
-- The compiler uses whichever `Array` module is in scope. If you `open Belt`, then it uses `Belt.Array`.
-- `Belt.Array.get` returns values wrapped in options, so `letters[0] == Some("a")`. 
-
-Fortunately, this is easy to fix:
-
-```reason example
-open Belt;
-let letters = [|"a", "b", "c"|];
-let a = letters[0];
-
-/* Use a switch statement: */
-let capitalA =
-  switch(a) {
-    | Some(a) => Some(Js.String.toUpperCase(a))
-    | None => None
-  };
-  
-/* Alternatively, use the Option module: */
-let capitalA = a->Option.map(Js.String.toUpperCase);
-
-let k = letters[10]; /* k == None */
-```
-
-With that little bit of tweaking, our code now compiles successfully and is 100% free of runtime errors!
-
-### A special encoding for collection safety
-
-When we create a collection library for a custom data type we need a way to
-provide a comparator function. Take Set for example, suppose its element type
-is a pair of ints, it needs a custom compare function that takes two tuples and
-returns their order. The Set could not just be typed as Set.t (int \* int) , its
-customized compare function needs to manifest itself in the signature,
-otherwise, if the user creates another customized compare function, the two
-collection could mix which would result in runtime error.
-
-The original OCaml stdlib solved the problem using functor which creates a big
-closure at runtime and makes dead code elimination much harder. We use a
-phantom type to solve the problem:
-
-```
-module Comparable1 =
-  Belt.Id.MakeComparable(
-    {
-      type t = (int, int);
-      let cmp = ((a0, a1), (b0, b1)) =>
-        switch (Pervasives.compare(a0, b0)) {
-        | 0 => Pervasives.compare(a1, b1)
-        | c => c
-        };
-    }
-  );
-
-let mySet1 = Belt.Set.make(~id=(module Comparable1));
-
-module Comparable2 =
-  Belt.Id.MakeComparable(
-    {
-      type t = (int, int);
-      let cmp = ((a0, a1), (b0, b1)) =>
-        switch (Pervasives.compare(a0, b0)) {
-        | 0 => Pervasives.compare(a1, b1)
-        | c => c
-        };
-    }
-  );
-
-let mySet2 = Belt.Set.make(~id=(module Comparable2));
-```
-
-Here, the compiler would infer mySet1 and mySet2 having different type, so e.g.
-a `merge` operation that tries to merge these two sets will correctly fail.
-
-```
-let mySet1: t((int, int), Comparable1.identity);
-let mySet2: t((int, int), Comparable2.identity);
-```
-
-`Comparable1.identity` and `Comparable2.identity` are not the same using our
-encoding scheme.
diff --git a/pages/docs/manual/v8.0.0/api/belt/array.mdx b/pages/docs/manual/v8.0.0/api/belt/array.mdx
deleted file mode 100644
index b65f1b601..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/array.mdx
+++ /dev/null
@@ -1,934 +0,0 @@
-# Array
-
-<Intro>
-
-Utililites for `Array` functions.
-
-</Intro>
-
-### Note about index syntax
-
-Code like `arr[0]` does *not* compile to JavaScript `arr[0]`. ReScript transforms the `[]` index syntax into a function: `Array.get(arr, 0)`. By default, this uses the default standard library's `Array.get` function, which may raise an exception if the index isn't found. If you `open Belt`, it will use the `Belt.Array.get` function which returns options instead of raising exceptions. [See this for more information](../belt.mdx#array-access-runtime-safety).
-
-## length
-
-```re sig
-let length: array('a) => int;
-```
-
-return the size of the array
-
-```re example
-/* Returns 1 */
-Belt.Array.length([|"test"|]);
-```
-
-## size
-
-```re sig
-let size: array('a) => int;
-```
-
-See Belt_Array.length
-
-## get
-
-```re sig
-let get: (array('a), int) => option('a);
-```
-
-If `i <= 0 <= length(arr)` returns `Some(value)` where `value` is the item at index `i`.
-If `i` is out of range returns `None`
-
-## getExn
-
-```re sig
-let getExn: (array('a), int) => 'a;
-```
-
-Raise an exception if `i` is out of range.
-Otherwise return the value at index `i` in `arr`.
-
-## getUnsafe
-
-```re sig
-let getUnsafe: (array('a), int) => 'a;
-```
-
-Unsafe
-
-no bounds checking; this would cause type error if `i` does not stay within range
-
-## getUndefined
-
-```re sig
-let getUndefined: (array('a), int) => Js.undefined('a);
-```
-
-It does the samething in the runtime as `Belt_Array.getUnsafe` it is type safe since the return type still track whether it is in range or not
-
-## set
-
-```re sig
-let set: (array('a), int, 'a) => bool;
-```
-
-`set(arr, n, x);` modifies `arr` in place; it replaces the nth element of `arr` with `x`.
-
-Returns false means not updated due to out of range.
-
-## setExn
-
-```re sig
-let setExn: (array('a), int, 'a) => unit;
-```
-
-`setExn(arr, i, x);` raise an exception if `i` is out of range.
-
-## setUnsafe
-
-```re sig
-let setUnsafe: (array('a), int, 'a) => unit;
-```
-
-## shuffleInPlace
-
-```re sig
-let shuffleInPlace: array('a) => unit;
-```
-
-`shuffleInPlace(arr)` randomly re-orders the items in `arr`
-
-## shuffle
-
-```re sig
-let shuffle: array('a) => array('a);
-```
-
-Returns a fresh array with items in original array randomly shuffled.
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: array('a) => unit;
-```
-
-`reverseInPlace(arr)` reverses items in `arr` in place.
-
-```re example
-let arr = [|10, 11, 12, 13, 14|];
-
-let () = Belt.Array.reverseInPlace(arr);
-
-arr == [|14, 13, 12, 11, 10|];
-```
-
-## reverse
-
-```re sig
-let reverse: array('a) => array('a);
-```
-
-`reverse(arr)` returns a fresh array with items in arr in reverse order.
-
-```re example
-Belt.Array.reverse([|10, 11, 12, 13, 14|]) == [|14, 13, 12, 11, 10|];
-```
-
-## makeUninitialized
-
-```re sig
-let makeUninitialized: int => array(Js.undefined('a));
-```
-
-`makeUninitialized(n)` creates an array of length `n` filled with the undefined value. You must specify the type of data that will eventually fill the array.
-
-```re example
-let arr: array(Js.undefined(string)) = Belt.Array.makeUninitialized(5);
-
-Belt.Array.getExn(arr, 0) == Js.undefined;
-```
-
-## makeUninitializedUnsafe
-
-```re sig
-let makeUninitializedUnsafe: int => array('a);
-```
-
-Unsafe
-
-```re example
-let arr = Belt.Array.makeUninitializedUnsafe(5);
-
-let () = Js.log(Belt.Array.getExn(arr, 0)); /* undefined */
-
-Belt.Array.setExn(arr, 0, "example");
-
-let () = Js.log(Belt.Array.getExn(arr, 0) == "example");
-```
-
-## make
-
-```re sig
-let make: (int, 'a) => array('a);
-```
-
-`make(n, e)` return an array of size `n` filled with value `e`.
-Returns an empty array when `n` is negative.
-
-## range
-
-```re sig
-let range: (int, int) => array(int);
-```
-
-`range(start, finish);` create an inclusive array.
-
-```re example
-Belt.Array.range(0, 3) == [|0, 1, 2, 3|];
-
-Belt.Array.range(3, 0) == [||];
-
-Belt.Array.range(3, 3) == [|3|];
-```
-
-## rangeBy
-
-```re sig
-let rangeBy: (int, int, ~step: int) => array(int);
-```
-
-`rangeBy(start, finish, ~step);`
-
-Returns empty array when step is 0 or negative. It also return an empty array when `start > finish`.
-
-```re example
-Belt.Array.rangeBy(0, 10, ~step=3) == [|0, 3, 6, 9|];
-
-Belt.Array.rangeBy(0, 12, ~step=3) == [|0, 3, 6, 9, 12|];
-
-Belt.Array.rangeBy(33, 0, ~step=1) == [||];
-
-Belt.Array.rangeBy(33, 0, ~step=-1) == [||];
-
-Belt.Array.rangeBy(3, 12, ~step=-1) == [||];
-
-Belt.Array.rangeBy(3, 3, ~step=0) == [||];
-
-Belt.Array.rangeBy(3, 3, ~step=1) == [|3|];
-```
-
-## makeByU
-
-```re sig
-let makeByU: (int, [@bs] (int => 'a)) => array('a);
-```
-
-## makeBy
-
-```re sig
-let makeBy: (int, int => 'a) => array('a);
-```
-
-`makeBy(n, f);`
-
-Return an empty array when n is negative return an array of size n populated by `f(i)` start from `0` to `n - 1`.
-
-```re example
-Belt.Array.makeBy(5, (i) => i) == [|0, 1, 2, 3, 4|];
-
-Belt.Array.makeBy(5, (i) => i * i) == [|0, 1, 4, 9, 16|];
-```
-
-## makeByAndShuffleU
-
-```re sig
-let makeByAndShuffleU: (int, [@bs] (int => 'a)) => array('a);
-```
-
-## makeByAndShuffle
-
-```re sig
-let makeByAndShuffle: (int, int => 'a) => array('a);
-```
-
-`makeByAndShuffle(n, f);`
-
-Equivalent to `shuffle(makeBy(n, f));`
-
-## zip
-
-```re sig
-let zip: (array('a), array('b)) => array(('a, 'b));
-```
-
-`zip(a, b);`
-
-Create an array of pairs from corresponding elements of a and b. Stop with the shorter array.
-
-```re example
-Belt.Array.zip([|1, 2|], [|3, 4, 5|]) == [|(1, 3), (2, 4)|]
-```
-
-## zipByU
-
-```re sig
-let zipByU: (array('a), array('b), [@bs] (('a, 'b) => 'c)) => array('c);
-```
-
-## zipBy
-
-```re sig
-let zipBy: (array('a), array('b), ('a, 'b) => 'c) => array('c);
-```
-
-`zipBy(xs, ys, f);`
-
-Create an array by applying `f` to corresponding elements of `xs` and `ys`. Stops with shorter array.
-
-Equivalent to `map(zip(xs, ys), ((a, b)) => f(a, b));`
-
-```re example
-Belt.Array.zipBy([|1, 2, 3|], [|4, 5|], (a, b) => 2 * a + b) == [|6, 9|];
-```
-
-## unzip
-
-```re sig
-let unzip: array(('a, 'b)) => (array('a), array('b));
-```
-
-`unzip(a);` takes an array of pairs and creates a pair of arrays. The first array contains all the first items of the pairs; the second array contains all the second items.
-
-```re example
-Belt.Array.unzip([|(1, 2), (3, 4)|]) == ([|1, 3|], [|2, 4|]);
-
-Belt.Array.unzip([|(1, 2), (3, 4), (5, 6), (7, 8)|]) == ([|1, 3, 5, 7|], [|2, 4, 6, 8|]);
-```
-
-## concat
-
-```re sig
-let concat: (array('a), array('a)) => array('a);
-```
-
-`concat(xs, ys);`
-
-Returns a fresh array containing the concatenation of the arrays `v1` and `v2`;so even if `v1` or `v2` is empty; it can not be shared
-
-```re example
-Belt.Array.concat([|1, 2, 3|], [|4, 5|]) == [|1, 2, 3, 4, 5|];
-
-Belt.Array.concat([||], [|"a", "b", "c"|]) == [|"a", "b", "c"|];
-```
-
-## concatMany
-
-```re sig
-let concatMany: array(array('a)) => array('a);
-```
-
-`concatMany(xss);`
-
-Returns a fresh array as the concatenation of `xss` (an array of arrays)
-
-```re example
-Belt.Array.concatMany([|[|1, 2, 3|], [|4, 5, 6|], [|7, 8|]|]) == [|1, 2, 3, 4, 5, 6, 7, 8|];
-```
-
-## slice
-
-```re sig
-let slice: (array('a), ~offset: int, ~len: int) => array('a);
-```
-
-`slice(xs, offset, len);` creates a new array with the len elements of `xs`
-starting at `offset` for `offset` can be negative;and is evaluated as
-`length(xs) - offset(slice, xs) - 1(1);` means get the last element as a
-singleton array `slice(xs, ~-len, len);` will return a copy of the array if the
-array does not have enough data; `slice` extracts through the end of sequence.
-
-if `len` is negative; returns the empty array.
-
-```re example
-Belt.Array.slice([|10, 11, 12, 13, 14, 15, 16|], ~offset=2, ~len=3) == [|12, 13, 14|];
-
-Belt.Array.slice([|10, 11, 12, 13, 14, 15, 16|], ~offset=-4, ~len=3) == [|13, 14, 15|];
-
-Belt.Array.slice([|10, 11, 12, 13, 14, 15, 16|], ~offset=4, ~len=9) == [|14, 15, 16|];
-```
-
-## sliceToEnd
-
-```re sig
-let sliceToEnd: (array('a), int) => array('a);
-```
-
-`sliceToEnd(xs, offset);` creates a new array with the elements of `xs` starting at `offset`
-
-`offset` can be negative; and is evaluated as `length(xs) - offset(sliceToEnd, xs) - 1;` means get the last element as a singleton array
-
-`sliceToEnd(xs, 0);` will return a copy of the array
-
-```re example
-Belt.Array.sliceToEnd([|10, 11, 12, 13, 14, 15, 16|], 2) == [|12, 13, 14, 15, 16|];
-
-Belt.Array.sliceToEnd([|10, 11, 12, 13, 14, 15, 16|], -4) == [|13, 14, 15, 16|];
-```
-
-## copy
-
-```re sig
-let copy: array('a) => array('a);
-```
-
-`copy(a);`
-
-Returns a copy of a; that is; a fresh array containing the same elements as a.
-
-## fill
-
-```re sig
-let fill: (array('a), ~offset: int, ~len: int, 'a) => unit;
-```
-
-`fill(arr, ~offset, ~len, x);`
-
-Modifies `arr` in place, storing `x` in elements number `offset` to `offset + len - 1`.
-`offset` can be negative; and is evaluated as `length(arr - offset);`
-
-`fill(arr, ~offset=-1, ~len=1);` means fill the last element, if the array does not have enough data; `fill` will ignore it
-
-```re example
-let arr = Belt.Array.makeBy(5, (i) => i);
-
-Belt.Array.fill(arr, ~offset=2, ~len=2, 9);
-
-arr == [|0, 1, 9, 9, 4|];
-
-Belt.Array.fill(arr, ~offset=7, ~len=2, 8);
-
-arr == [|0, 1, 9, 9, 4|];
-```
-
-## blit
-
-```re sig
-let blit:
-  (
-    ~src: array('a),
-    ~srcOffset: int,
-    ~dst: array('a),
-    ~dstOffset: int,
-    ~len: int
-  ) =>
-  unit;
-```
-
-`blit(~src=v1, ~srcOffset=o1, ~dst=v2, ~dstOffset=o2, ~len);`
-
-copies `len` elements from array `v1`;starting at element number `o1`;to array `v2`, starting at element number `o2`.
-
-It works correctly even if `v1` and `v2` are the same array;and the source and destination chunks overlap.
-
-`offset` can be negative; `-1` means `len - 1`; if `len + offset` is still negative;it will be set as 0
-
-For each of the examples;presume that `v1 == [|10, 11, 12, 13, 14, 15, 16, 17|];` and `v2 == [|20, 21, 22, 23, 24, 25, 26, 27|];`. The result shown is the content of the destination array.
-
-```re example
-let v1 = [|10, 11, 12, 13, 14, 15, 16, 17|];
-let v2 = [|20, 21, 22, 23, 24, 25, 26, 27|];
-
-Belt.Array.blit(~src=v1, ~srcOffset=4, ~dst=v2, ~dstOffset=2, ~len=3);
-v2 == [|20, 21, 14, 15, 16, 25, 26, 27|];
-
-Belt.Array.blit(~src=v1, ~srcOffset=4, ~dst=v1, ~dstOffset=2, ~len=3);
-v1 == [|10, 11, 14, 15, 16, 15, 16, 17|];
-```
-
-## blitUnsafe
-
-```re sig
-let blitUnsafe: (~src: array('a), ~srcOffset: int, ~dst: array('a), ~dstOffset: int, ~len: int) => unit;
-```
-
-Unsafe blit without bounds checking.
-
-## forEachU
-
-```re sig
-let forEachU: (array('a), [@bs] ('a => unit)) => unit;
-```
-
-## forEach
-
-```re sig
-let forEach: (array('a), 'a => unit) => unit;
-```
-
-`forEach(xs, f);`
-
-Call `f` on each element of `xs` from the beginning to end. `f` returns `unit`;so no new array is created. Use `forEach` when you are primarily concerned with repetitively creating side effects.
-
-```re example
-Belt.Array.forEach([|"a", "b", "c"|], x => Js.log("Item: " ++ x));
-
-/*  prints:
-      Item: a
-      Item: b
-      Item: c
-    */
-let total = ref(0);
-
-Belt.Array.forEach([|1, 2, 3, 4|], x => total := total^ + x);
-
-total^ == 1 + 2 + 3 + 4;
-```
-
-## mapU
-
-```re sig
-let mapU: (array('a), [@bs] ('a => 'b)) => array('b);
-```
-
-## map
-
-```re sig
-let map: (array('a), 'a => 'b) => array('b);
-```
-
-`map(xs, f);`
-
-Returns a new array by calling `f` for each element of `xs` from the beginning to end.
-
-```re example
-Belt.Array.map([|1, 2|], (x) => x + 1) == [|3, 4|];
-```
-
-## getByU
-
-```re sig
-let getByU: (array('a), [@bs] ('a => bool)) => option('a);
-```
-
-## getBy
-
-```re sig
-let getBy: (array('a), 'a => bool) => option('a);
-```
-
-`getBy(xs, p);`
-
-Returns `Some(value)` for the first value in `xs` that satisifies the predicate function `p`; returns `None` if no element satisifies the function.
-
-```re example
-Belt.Array.getBy([|1, 4, 3, 2|], (x) => x mod 2 == 0) == Some(4);
-Belt.Array.getBy([|15, 13, 11|], (x) => x mod 2 == 0) == None;
-```
-
-## getIndexByU
-
-```re sig
-let getIndexByU: (array('a), [@bs] ('a => bool)) => option(int);
-```
-
-## getIndexBy
-
-```re sig
-let getIndexBy: (array('a), 'a => bool) => option(int);
-```
-
-`getIndexBy(xs, p);`
-
-returns `Some(index)` for the first value in `xs` that satisifies the predicate function `p`;
-returns `None` if no element satisifies the function.
-
-```re example
-Belt.Array.getIndexBy([|1, 4, 3, 2|], (x) => x mod 2 == 0) == Some(1);
-Belt.Array.getIndexBy([|15, 13, 11|], (x) => x mod 2 == 0) == None;
-```
-
-## keepU
-
-```re sig
-let keepU: (array('a), [@bs] ('a => bool)) => array('a);
-```
-
-## keep
-
-```re sig
-let keep: (array('a), 'a => bool) => array('a);
-```
-
-`keep(xs, p);`
-
-Returns a new array that keep all elements satisfy `p`.
-
-```re example
-Belt.Array.keep([|1, 2, 3|], (x) => x mod 2 == 0) == [|2|];
-```
-
-## keepWithIndexU
-
-```re sig
-let keepWithIndexU: (array('a), [@bs] (('a, int) => bool)) => array('a);
-```
-
-## keepWithIndex
-
-```re sig
-let keepWithIndex: (array('a), ('a, int) => bool) => array('a);
-```
-
-`keepWithIndex(xs, p);`
-
-Returns a new array that keep all elements satisfy `p`.
-
-```re example
-Belt.Array.keepWithIndex([|1, 2, 3|], (_x, i) => i == 1) == [|2|];
-```
-
-## keepMapU
-
-```re sig
-let keepMapU: (array('a), [@bs] ('a => option('b))) => array('b);
-```
-
-## keepMap
-
-```re sig
-let keepMap: (array('a), 'a => option('b)) => array('b);
-```
-
-`keepMap(xs, p);`
-
-Returns a new array that keep all elements that return a non-None applied `p`.
-
-```re example
-Belt.Array.keepMap([|1, 2, 3|], x =>
-  if (x mod 2 == 0) {
-    Some(x);
-  } else {
-    None;
-  }
-)
-== [|2|];
-```
-
-## forEachWithIndexU
-
-```re sig
-let forEachWithIndexU: (array('a), [@bs] ((int, 'a) => unit)) => unit;
-```
-
-## forEachWithIndex
-
-```re sig
-let forEachWithIndex: (array('a), (int, 'a) => unit) => unit;
-```
-
-`forEachWithIndex(xs, f);`
-
-The same as `Belt_Array.forEach`;
-except that `f` is supplied two arguments: the index starting from 0 and the element from `xs`.
-
-```re example
-Belt.Array.forEachWithIndex([|"a", "b", "c"|], (i, x) => Js.log("Item " ++ Belt.Int.toString(i) ++ " is " ++ x));
-
-/*  prints:
-      Item 0 is a
-      Item 1 is b
-      Item 2 is cc
-    */
-let total = ref(0);
-
-Belt.Array.forEachWithIndex([|10, 11, 12, 13|], (i, x) => total := total^ + x + i);
-
-total^ == 0 + 10 + 1 + 11 + 2 + 12 + 3 + 13;
-```
-
-## mapWithIndexU
-
-```re sig
-let mapWithIndexU: (array('a), [@bs] ((int, 'a) => 'b)) => array('b);
-```
-
-## mapWithIndex
-
-```re sig
-let mapWithIndex: (array('a), (int, 'a) => 'b) => array('b);
-```
-
-`mapWithIndex(xs, f);`
-
-`mapWithIndex(xs, f)` applies `f` to each element of `xs`. Function `f` takes two arguments: the index starting from 0 and the element from `xs`.
-
-```re example
-Belt.Array.mapWithIndex([|1, 2, 3|], (i, x) => i + x) == [|0 + 1, 1 + 2, 2 + 3|];
-```
-
-## partitionU
-
-```re sig
-let partitionU: (array('a), [@bs] ('a => bool)) => (array('a), array('a));
-```
-
-## partition
-
-```re sig
-let partition: (array('a), 'a => bool) => (array('a), array('a));
-```
-
-`partition(f, a)` split array into tuple of two arrays based on predicate `f`; first of tuple where predicate cause true, second where predicate cause false
-
-```re example
-Belt.Array.partition([|1, 2, 3, 4, 5|], (x) => x mod 2 == 0) == ([|2, 4|], [|1, 2, 3|]);
-
-Belt.Array.partition([|1, 2, 3, 4, 5|], (x) => x mod 2 != 0) == ([|1, 2, 3|], [|2, 4|]);
-```
-
-## reduceU
-
-```re sig
-let reduceU: (array('b), 'a, [@bs] (('a, 'b) => 'a)) => 'a;
-```
-
-## reduce
-
-```re sig
-let reduce: (array('b), 'a, ('a, 'b) => 'a) => 'a;
-```
-
-`reduce(xs, init, f);`
-
-Applies `f` to each element of `xs` from beginning to end. Function `f` has two parameters: the item from the list and an “accumulator”; which starts with a value of `init`. `reduce` returns the final value of the accumulator.
-
-```re example
-Belt.Array.reduce([|2, 3, 4|], 1, (+)) == 10;
-
-Belt.Array.reduce([|"a", "b", "c", "d"|], "", (++)) == "abcd";
-```
-
-## reduceReverseU
-
-```re sig
-let reduceReverseU: (array('b), 'a, [@bs] (('a, 'b) => 'a)) => 'a;
-```
-
-## reduceReverse
-
-```re sig
-let reduceReverse: (array('b), 'a, ('a, 'b) => 'a) => 'a;
-```
-
-`reduceReverse(xs, init, f);`
-
-Works like `Belt_Array.reduce`; except that function `f` is applied to each item of `xs` from the last back to the first.
-
-```re example
-Belt.Array.reduceReverse([|"a", "b", "c", "d"|], "", (++)) == "dcba";
-```
-
-## reduceReverse2U
-
-```re sig
-let reduceReverse2U: (array('a), array('b), 'c, [@bs] (('c, 'a, 'b) => 'c)) => 'c;
-```
-
-## reduceReverse2
-
-```re sig
-let reduceReverse2: (array('a), array('b), 'c, ('c, 'a, 'b) => 'c) => 'c;
-```
-
-`reduceReverse2(xs, ys, init, f);`
-
-Reduces two arrays xs and ys;taking items starting at `min(length(xs), length(ys))` down to and including zero.
-
-```re example
-Belt.Array.reduceReverse2([|1, 2, 3|], [|1, 2|], 0, (acc, x, y) => acc + x + y) == 6;
-```
-
-## reduceWithIndexU
-
-```re sig
-let reduceWithIndexU: (array('a), 'b, [@bs] (('b, 'a, int) => 'b)) => 'b;
-```
-
-## reduceWithIndex
-
-```re sig
-let reduceWithIndex: (array('a), 'b, ('b, 'a, int) => 'b) => 'b;
-```
-
-`reduceWithIndex(xs, f);`
-
-Applies `f` to each element of `xs` from beginning to end. Function `f` has three parameters: the item from the array and an “accumulator”, which starts with a value of `init` and the index of each element. `reduceWithIndex` returns the final value of the accumulator.
-
-```re example
-Belt.Array.reduceWithIndex([|1, 2, 3, 4|], 0, (acc, x, i) => acc + x + i) == 16;
-```
-
-## someU
-
-```re sig
-let someU: (array('a), [@bs] ('a => bool)) => bool;
-```
-
-## some
-
-```re sig
-let some: (array('a), 'a => bool) => bool;
-```
-
-`some(xs, p);`
-
-Returns true if at least one of the elements in `xs` satifies `p`; where `p` is a predicate: a function taking an element and returning a `bool`.
-
-```re example
-Belt.Array.some([|2, 3, 4|], (x) => x mod 2 == 1) == true;
-
-Belt.Array.some([|(-1), (-3), (-5)|], (x) => x > 0) == false;
-```
-
-## everyU
-
-```re sig
-let everyU: (array('a), [@bs] ('a => bool)) => bool;
-```
-
-## every
-
-```re sig
-let every: (array('a), 'a => bool) => bool;
-```
-
-`every(xs, p);`
-
-Returns `true` if all elements satisfy `p`; where `p` is a predicate: a function taking an element and returning a `bool`.
-
-```re example
-Belt.Array.every([|1, 3, 5|], (x) => x mod 2 == 1) == true;
-
-Belt.Array.every([|1, (-3), 5|], (x) => x > 0) == false;
-```
-
-## every2U
-
-```re sig
-let every2U: (array('a), array('b), [@bs] (('a, 'b) => bool)) => bool;
-```
-
-## every2
-
-```re sig
-let every2: (array('a), array('b), ('a, 'b) => bool) => bool;
-```
-
-`every2(xs, ys, p);`
-
-returns true if `p(xi, yi);` is true for all pairs of elements up to the shorter length (i.e. `min(length(xs), length(ys));`)
-
-```re example
-Belt.Array.every2([|1, 2, 3|], [|0, 1|], (>)) == true;
-
-Belt.Array.every2([||], [|1|], (x, y) => x > y) == true;
-
-Belt.Array.every2([|2, 3|], [|1|], (x, y) => x > y) == true;
-
-Belt.Array.every2([|0, 1|], [|5, 0|], (x, y) => x > y) == false;
-```
-
-## some2U
-
-```re sig
-let some2U: (array('a), array('b), [@bs] (('a, 'b) => bool)) => bool;
-```
-
-## some2
-
-```re sig
-let some2: (array('a), array('b), ('a, 'b) => bool) => bool;
-```
-
-`some2(xs, ys, p);`
-
-returns true if `p(xi, yi);` is true for any pair of elements up to the shorter length (i.e. `min(length(xs), length(ys));`)
-
-```re example
-Belt.Array.some2([|0, 2|], [|1, 0, 3|], (>)) == true;
-
-Belt.Array.some2([||], [|1|], (x, y) => x > y) == false;
-
-Belt.Array.some2([|2, 3|], [|1, 4|], (x, y) => x > y) == true;
-```
-
-## cmpU
-
-```re sig
-let cmpU: (array('a), array('a), [@bs] (('a, 'a) => int)) => int;
-```
-
-## cmp
-
-```re sig
-let cmp: (array('a), array('a), ('a, 'a) => int) => int;
-```
-
-`cmp(xs, ys, f);`
-
-Compared by length if `length(xs) != length(ys)`; returning -1 if `length(xs) < length(ys)` or 1 if `length(xs) > length(ys)`
-Otherwise compare one by one `f(x, y);`. `f` returns
-a negative number if `x` is “less than” `y`
-zero if `x` is “equal to” `y`
-a positive number if `x` is “greater than” `y`
-The comparison returns the first non-zero result of `f`;or zero if `f` returns zero for all `x` and `y`.
-
-```re example
-Belt.Array.cmp([|1, 3, 5|], [|1, 4, 2|], (a, b) => compare(a, b)) == (-1);
-
-Belt.Array.cmp([|1, 3, 5|], [|1, 2, 3|], (a, b) => compare(a, b)) == 1;
-
-Belt.Array.cmp([|1, 3, 5|], [|1, 3, 5|], (a, b) => compare(a, b)) == 0;
-```
-
-## eqU
-
-```re sig
-let eqU: (array('a), array('a), [@bs] (('a, 'a) => bool)) => bool;
-```
-
-## eq
-
-```re sig
-let eq: (array('a), array('a), ('a, 'a) => bool) => bool;
-```
-
-`eq(xs, ys);`
-
-return false if length is not the same
-otherwise compare items one by one using `f(xi, yi);`; and return true if all results are true;false otherwise
-
-```re example
-Belt.Array.eq([|1, 2, 3|], [|(-1), (-2), (-3)|], (a, b) => abs(a) == abs(b)) == true;
-```
-
-## truncateToLengthUnsafe
-
-```re sig
-let truncateToLengthUnsafe: (array('a), int) => unit;
-```
-
-Unsafe `truncateToLengthUnsafe(xs, n);` sets length of array `xs` to `n`.
-
-If `n` is greater than the length of `xs`; the extra elements are set to `Js.Null_undefined.null`.
-
-If `n` is less than zero; raises a `RangeError`.
-
-```re example
-let arr = [|"ant", "bee", "cat", "dog", "elk"|];
-
-Belt.Array.truncateToLengthUnsafe(arr, 3);
-
-arr == [|"ant", "bee", "cat"|];
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/debug.mdx b/pages/docs/manual/v8.0.0/api/belt/debug.mdx
deleted file mode 100644
index 31a620b81..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/debug.mdx
+++ /dev/null
@@ -1,7 +0,0 @@
-# Debug
-
-## setupChromeDebugger
-
-```
-let setupChromeDebugger: unit => unit;
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/float.mdx b/pages/docs/manual/v8.0.0/api/belt/float.mdx
deleted file mode 100644
index df49aeab9..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/float.mdx
+++ /dev/null
@@ -1,107 +0,0 @@
-# Float
-
-This module includes convenience methods for handling `float` types.
-
-## toInt
-
-```re sig
-let toInt: float => int;
-```
-
-Converts a given `float` to an `int`. 
-
-```re example
-Js.log(Belt.Float.toInt(1.0) === 1); /* true */
-```
-
-## fromInt
-
-```re sig
-let fromInt: int => float;
-```
-
-Converts a given `int` to a `float`.
-
-```re example
-Js.log(Belt.Float.fromInt(1) === 1.0); /* true */
-```
-
-## fromString
-
-```re sig
-let fromString: string => option(float);
-```
-
-Converts a given `string` to a `float`. Returns `Some(float)` when the input is a number, `None` otherwise.
-
-```re example
-Js.log(Belt.Float.fromString("1.0") === Some(1.0)); /* true */
-```
-
-## toString
-
-```re sig
-let toString: float => string;
-```
-
-Converts a given `float` to a `string`. Uses the JavaScript `String` constructor under the hood.
-
-```re example
-Js.log(Belt.Float.toString(1.0) === "1.0"); /* true */
-```
-
-## +
-
-```re sig
-let (+): (float, float) => float;
-```
-
-Addition of two `float` values. 
-Can be opened in a module to avoid dot-notation (`+.`), however this yields a shadow warning (Warning number 44) in the default configuration.
-
-```re example
-open Belt.Float;
-Js.log(2.0 + 2.0 === 4.0); /* true */
-```
-
-## -
-
-```re sig
-let (-): (float, float) => float;
-```
-
-Subtraction of two `float` values.
-Can be opened in a module to avoid dot-notation (`-.`), however this yields a shadow warning (Warning number 44) in the default configuration.
-
-```re example
-open Belt.Float;
-Js.log(2.0 - 1.0 === 1.0); /* true */
-```
-
-## \*
-
-```re sig
-let ( * ): (float, float) => float;
-```
-
-Multiplication of two `float` values. 
-Can be opened in a module to avoid dot-notation (`*.`), however this yields a shadow warning (Warning number 44) in the default configuration.
-
-```re example
-open Belt.Float;
-Js.log(2.0 * 2.0 === 4.0); /* true */
-```
-
-## /
-
-```re sig
-let (/): (float, float) => float;
-```
-
-Division of two `float` values.
-Can be opened in a module to avoid dot-notation (`/.`), however this yields a shadow warning (Warning number 44) in the default configuration.
-
-```re example
-open Belt.Float;
-Js.log(4.0 / 2.0 === 2.0); /* true */
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/hash-map-int.mdx b/pages/docs/manual/v8.0.0/api/belt/hash-map-int.mdx
deleted file mode 100644
index 5d1bd723b..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/hash-map-int.mdx
+++ /dev/null
@@ -1,331 +0,0 @@
-# HashMapInt
-
-<Intro>
-
-Specalized when key type is `int`, more efficient than the generic type
-
-</Intro>
-
-## key
-
-```re sig
-type key = int;
-```
-
-Type of the `Belt.HashMap.Int` key.
-
-## t
-
-```re sig
-type t('b);
-```
-
-Type of the `Belt.HashMap.Int`
-
-## make
-
-```re sig
-let make: (~hintSize: int) => t('b);
-```
-
-`make(~hintSize=10)` creates a new hash map by taking the `hintSize`.
-
-```re example
-
-let hMap = Belt.HashMap.Int.make(~hintSize=10);
-
-Belt.HashMap.Int.set(hMap, 1, "a");
-```
-
-## clear
-
-```re sig
-let clear: t('b) => unit;
-```
-
-Clears a hash table.
-
-```re example
-let hMap = Belt.HashMap.Int.fromArray([|(1, "1")|])  
-Belt.HashMap.Int.clear(hMap)
-Belt.HashMap.Int.isEmpty(hMap) == true;
-```
-
-## isEmpty
-
-```re sig
-let isEmpty: t('a) => bool;
-```
-
-`isEmpty(m)` checks whether a hash map is empty.
-
-```re example
-let hMap = Belt.HashMap.Int.fromArray([|(1, "1")|])  
-Belt.HashMap.Int.isEmpty(hMap) == false;
-```
-
-## set
-
-```re sig
-let set: (t('a), key, 'a) => unit;
-```
-
-`set(tbl, k, v)` if `k` does not exist, add the binding `k,v`, otherwise, update the old value with the new `v`.
-
-```re example
- 
-let hMap = Belt.HashMap.Int.fromArray([|(2, "2")|]);
-
-Belt.HashMap.Int.set(hMap, 1, "1");
-
-Belt.HashMap.Int.valuesToArray(hMap) == [|"1", "2"|];
-```
-
-## copy
-
-```re sig
-let copy: t('a) => t('a);
-```
-
-Creates copy of a hash map.
-
-```re example
-let hMap1 = Belt.HashMap.Int.fromArray([|(1, "1"), (2, "2")|]);
-let hMap2 = Belt.HashMap.Int.copy(hMap1)
-
-Belt.HashMap.Int.set(hMap2, 2, "3");
-
-Belt.HashMap.Int.get(hMap1, 2) != Belt.HashMap.Int.get(hMap2, 2)
-```
-
-## get
-
-```re sig
-let get: (t('a), key) => option('a);
-```
-
-## has
-
-```re sig
-let has: (t('b), key) => bool;
-```
-
-Returns value bound under specific key. If values not exist returns `None`.
-
-```re example
-let hMap = Belt.HashMap.Int.make(~hintSize=10);
-Belt.HashMap.Int.set(hMap, 1, "value1");
-
-Belt.HashMap.Int.get(hMap, 1) == Some("value1");
-Belt.HashMap.Int.get(hMap, 2) == None;
-```
-
-## remove
-
-```re sig
-let remove: (t('a), key) => unit;
-```
-
-If bound exists, removes it from the hash map.
-
-```re example
-let hMap = Belt.HashMap.Int.make(~hintSize=10);
-Belt.HashMap.Int.set(hMap, 1, "value1");
-Belt.HashMap.Int.remove(hMap, 1);
-Belt.HashMap.Int.has(hMap, 1) == false;
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t('b), [@bs] ((key, 'b) => unit)) => unit;
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```re sig
-let forEach: (t('b), (key, 'b) => unit) => unit;
-```
-
-`forEach(tbl, f)` applies `f` to all bindings in table `tbl`. `f` receives the key as first argument, and the associated value as second argument. Each binding is presented exactly once to `f`.
-
-```re example
-let hMap = Belt.HashMap.Int.make(~hintSize=10);
-Belt.HashMap.Int.set(hMap, 1, "value1");
-Belt.HashMap.Int.forEach(hMap, (key, value) => Js.log2(key, value));
-// prints ("1", "value1")
-```
-
-## reduceU
-
-```re sig
-let reduceU: (t('b), 'c, [@bs] (('c, key, 'b) => 'c)) => 'c;
-```
-
-Same as [reduce](##reduce) but takes uncurried functon.
-
-## reduce
-
-```re sig
-let reduce: (t('b), 'c, ('c, key, 'b) => 'c) => 'c;
-```
-
-`reduce(tbl, init, f)` computes `(f(kN, dN) ... (f(k1, d1, init))...)`, where `k1 ... kN` are the keys of all bindings in `tbl`, and `d1 ... dN` are the associated values. Each binding is presented exactly once to `f`.
-
-The order in which the bindings are passed to `f` is unspecified. However, if the table contains several bindings for the same key, they are passed to `f` in reverse order of introduction, that is, the most recent binding is passed first.
-
-```re example
-let hMap = Belt.HashMap.Int.make(~hintSize=10);
-Belt.HashMap.Int.set(hMap, 1, "value1");
-Belt.HashMap.Int.set(hMap, 2, "value2");
-
-Belt.HashMap.Int.reduce(hMap, "", (acc, key, value) => {
-  acc ++ ", " ++ value
-}) == "value1, value2";
-```
-
-## keepMapInPlaceU
-
-```re sig
-let keepMapInPlaceU: (t('a), [@bs] ((key, 'a) => option('a))) => unit;
-```
-
-Same as [keepMapInPlace](##keepMapInPlace) but takes uncurried functon.
-
-## keepMapInPlace
-
-```re sig
-let keepMapInPlace: (t('a), (key, 'a) => option('a)) => unit;
-```
-
-Filters out values for which function `f` returned `None`.
-
-```re example
-let hMap = Belt.HashMap.Int.make(~hintSize=10);
-Belt.HashMap.Int.set(hMap, 1, "value1");
-Belt.HashMap.Int.set(hMap, 2, "value2");
-
-Belt.HashMap.Int.keepMapInPlace(hMap, (key, value) => {
-  key mod 1 == 0 ? None : Some(value)
-});
-```
-
-## size
-
-```re sig
-let size: t('a) => int;
-```
-
-`size(tbl)` returns the number of bindings in `tbl`. It takes constant time.
-
-```re example
-let hMap = Belt.HashMap.Int.make(~hintSize=10);
-Belt.HashMap.Int.set(hMap, 1, "value1");
-Belt.HashMap.Int.set(hMap, 2, "value2");
-
-Belt.HashMap.Int.size(hMap) == 2;
-```
-
-## toArray
-
-```re sig
-let toArray: t('a) => array((key, 'a));
-```
-
-Returns array of key value pairs.
-
-```re example
-let hMap = Belt.HashMap.Int.make(~hintSize=10);
-Belt.HashMap.Int.set(hMap, 1, "value1");
-Belt.HashMap.Int.set(hMap, 2, "value2");
-
-Belt.HashMap.Int.toArray(hMap) == [|(1, "value1"), (2, "value2")|];
-```
-
-## keysToArray
-
-```re sig
-let keysToArray: t('a) => array(key);
-```
-
-Returns array of keys.
-
-```re example
-let hMap = Belt.HashMap.Int.make(~hintSize=10);
-Belt.HashMap.Int.set(hMap, 1, "value1");
-Belt.HashMap.Int.set(hMap, 2, "value2");
-
-Belt.HashMap.Int.keysToArray(hMap) == [|1, 2|];
-```
-
-## valuesToArray
-
-```re sig
-let valuesToArray: t('a) => array('a);
-```
-
-Returns array of values.
-
-```re example
-let hMap = Belt.HashMap.Int.make(~hintSize=10);
-Belt.HashMap.Int.set(hMap, 1, "value1");
-Belt.HashMap.Int.set(hMap, 2, "value2");
-
-Belt.HashMap.Int.valuesToArray(hMap) == [|"value1", "value2"|];
-```
-
-## fromArray
-
-```re sig
-let fromArray: array((key, 'a)) => t('a);
-```
-
-Creates new hash map from array of pairs.
-
-Returns array of values.
-
-```re example
-let hMap = Belt.HashMap.Int.fromArray([|(1, "value1"), (1, "value2")|]);
-Belt.HashMap.Int.toArray(hMap) == [|(1, "value1"), (2, "value2")|];
-```
-
-## mergeMany
-
-```re sig
-let mergeMany: (t('a), array((key, 'a))) => unit;
-```
-
-Merges many key value pairs into hash map.
-
-```re example
-let hMap = Belt.HashMap.Int.make(~hintSize=10);
-Belt.HashMap.Int.mergeMany(hMap, [|(1, "value1"), (2, "value2")|]);
-```
-
-## getBucketHistogram
-
-```re sig
-let getBucketHistogram: t('a) => array(int);
-```
-
-```re example
-let hMap = Belt.HashMap.Int.make(~hintSize=10);
-Belt.HashMap.Int.set(hMap, 1, "1");
-
-Belt.HashMap.Int.getBucketHistogram(hMap);
-```
-
-## logStats
-
-```re sig
-let logStats: t('a) => unit;
-```
-
-```re example
-let hMap = Belt.HashMap.Int.make(~hintSize=10);
-Belt.HashMap.Int.set(hMap, 1, "1");
-
-Belt.HashMap.Int.logStats(hMap);
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/hash-map-string.mdx b/pages/docs/manual/v8.0.0/api/belt/hash-map-string.mdx
deleted file mode 100644
index e91eea789..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/hash-map-string.mdx
+++ /dev/null
@@ -1,341 +0,0 @@
-# HashMapString
-
-<Intro>
-
-Specalized when key type is `string`, more efficient than the generic type
-
-</Intro>
-
-## key
-
-```re sig
-type key = string;
-```
-
-Type of the `Belt.HashMap.String` key.
-
-## t
-
-```re sig
-type t('b);
-```
-
-Type of the `Belt.HashMap.String`.
-
-## make
-
-```re sig
-let make: (~hintSize: int) => t('b);
-```
-
-`make(~hintSize=10)` creates a new hash map by taking the `hintSize`.
-
-```re example
-
-let hMap = Belt.HashMap.String.make(~hintSize=10);
-
-Belt.HashMap.String.set(hMap, "key1", "a");
-```
-
-## clear
-
-```re sig
-let clear: t('b) => unit;
-```
-
-Clears a hash table.
-
-```re example
-let hMap = Belt.HashMap.String.fromArray([|("1", "1")|])  
-Belt.HashMap.String.clear(hMap)
-Belt.HashMap.String.isEmpty(hMap) == true;
-```
-
-## isEmpty
-
-```re sig
-let isEmpty: t('a) => bool;
-```
-
-`isEmpty(m)` checks whether a hash map is empty.
-
-```re example
-let hMap = Belt.HashMap.String.fromArray([|("1", "1")|])  
-Belt.HashMap.String.isEmpty(hMap) == false;
-```
-
-## set
-
-```re sig
-let set: (t('a), key, 'a) => unit;
-```
-
-`set(tbl, k, v)` if `k` does not exist, add the binding `k,v`, otherwise, update the old value with the new `v`.
-
-```re example
- 
-let hMap = Belt.HashMap.String.fromArray([|("2", "2")|]);
-
-Belt.HashMap.String.set(hMap, "1", "1");
-
-Belt.HashMap.String.valuesToArray(hMap) == [|"1", "2"|];
-```
-
-## copy
-
-```re sig
-let copy: t('a) => t('a);
-```
-
-Creates copy of a hash map.
-
-```re example
-let hMap1 = Belt.HashMap.String.fromArray([|("1", "1"), ("2", "2")|]);
-let hMap2 = Belt.HashMap.String.copy(hMap1)
-
-Belt.HashMap.String.set(hMap2, "2", "3");
-
-Belt.HashMap.String.get(hMap1, "2") != Belt.HashMap.String.get(hMap2, "2")
-```
-
-## get
-
-```re sig
-let get: (t('a), key) => option('a);
-```
-
-Returns value bound under specific key. If values not exist returns `None`.
-
-```re example
-let hMap = Belt.HashMap.String.make(~hintSize=10);
-Belt.HashMap.String.set(hMap, "1", "value1");
-
-Belt.HashMap.String.get(hMap, "1") == Some("value1");
-Belt.HashMap.String.get(hMap, "2") == None;
-```
-
-## has
-
-```re sig
-let has: (t('b), key) => bool;
-```
-
-Checks if `x` is bound in `tbl`.
-
-```re example
-let hMap = Belt.HashMap.String.make(~hintSize=10);
-Belt.HashMap.String.set(hMap, "1", "value1");
-
-Belt.HashMap.String.has(hMap, "1") == true;
-Belt.HashMap.String.has(hMap, "2") == false;
-```
-
-## remove
-
-```re sig
-let remove: (t('a), key) => unit;
-```
-
-If bound exists, removes it from the hash map.
-
-```re example
-let hMap = Belt.HashMap.String.make(~hintSize=10);
-Belt.HashMap.String.set(hMap, "1", "value1");
-Belt.HashMap.String.remove(hMap, "1");
-Belt.HashMap.String.has(hMap, "1") == false;
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t('b), [@bs] ((key, 'b) => unit)) => unit;
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```re sig
-let forEach: (t('b), (key, 'b) => unit) => unit;
-```
-
-`forEach(tbl, f)` applies `f` to all bindings in table `tbl`. `f` receives the key as first argument, and the associated value as second argument. Each binding is presented exactly once to `f`.
-
-```re example
-let hMap = Belt.HashMap.String.make(~hintSize=10);
-Belt.HashMap.String.set(hMap, "1", "value1");
-Belt.HashMap.String.forEach(hMap, (key, value) => Js.log2(key, value));
-// prints ("1", "value1")
-```
-
-## reduceU
-
-```re sig
-let reduceU: (t('b), 'c, [@bs] (('c, key, 'b) => 'c)) => 'c;
-```
-
-Same as [reduce](##reduce) but takes uncurried functon.
-
-## reduce
-
-```re sig
-let reduce: (t('b), 'c, ('c, key, 'b) => 'c) => 'c;
-```
-
-`reduce(tbl, init, f)` computes `(f(kN, dN) ... (f(k1, d1, init))...)`, where `k1 ... kN` are the keys of all bindings in `tbl`, and `d1 ... dN` are the associated values. Each binding is presented exactly once to `f`.
-
-The order in which the bindings are passed to `f` is unspecified. However, if the table contains several bindings for the same key, they are passed to `f` in reverse order of introduction, that is, the most recent binding is passed first.
-
-```re example
-let hMap = Belt.HashMap.String.make(~hintSize=10);
-Belt.HashMap.String.set(hMap, "1", "value1");
-Belt.HashMap.String.set(hMap, "2", "value2");
-
-Belt.HashMap.String.reduce(hMap, "", (acc, key, value) => {
-  acc ++ ", " ++ value
-}) == "value1, value2";
-```
-
-## keepMapInPlaceU
-
-```re sig
-let keepMapInPlaceU: (t('a), [@bs] ((key, 'a) => option('a))) => unit;
-```
-
-Same as [keepMapInPlace](##keepMapInPlace) but takes uncurried functon.
-
-## keepMapInPlace
-
-```re sig
-let keepMapInPlace: (t('a), (key, 'a) => option('a)) => unit;
-```
-
-Filters out values for which function `f` returned `None`.
-
-```re example
-let hMap = Belt.HashMap.String.make(~hintSize=10);
-Belt.HashMap.String.set(hMap, "1", "value1");
-Belt.HashMap.String.set(hMap, "2", "value2");
-
-Belt.HashMap.String.keepMapInPlace(hMap, (key, value) => {
-  key == "1" ? None : Some(value)
-});
-```
-
-## size
-
-```re sig
-let size: t('a) => int;
-```
-
-`size(tbl)` returns the number of bindings in `tbl`. It takes constant time.
-
-```re example
-let hMap = Belt.HashMap.String.make(~hintSize=10);
-Belt.HashMap.String.set(hMap, "1", "value1");
-Belt.HashMap.String.set(hMap, "2", "value2");
-
-Belt.HashMap.String.size(hMap) == 2;
-```
-
-## toArray
-
-```re sig
-let toArray: t('a) => array((key, 'a));
-```
-
-Returns array of key value pairs.
-
-```re example
-let hMap = Belt.HashMap.String.make(~hintSize=10);
-Belt.HashMap.String.set(hMap, "1", "value1");
-Belt.HashMap.String.set(hMap, "2", "value2");
-
-Belt.HashMap.String.toArray(hMap) == [|("1", "value1"), ("2", "value2")|];
-```
-
-## keysToArray
-
-```re sig
-let keysToArray: t('a) => array(key);
-```
-
-Returns array of keys.
-
-```re example
-let hMap = Belt.HashMap.String.make(~hintSize=10);
-Belt.HashMap.String.set(hMap, "1", "value1");
-Belt.HashMap.String.set(hMap, "2", "value2");
-
-Belt.HashMap.String.keysToArray(hMap) == [|"1", "2"|];
-```
-
-## valuesToArray
-
-```re sig
-let valuesToArray: t('a) => array('a);
-```
-
-Returns array of values.
-
-```re example
-let hMap = Belt.HashMap.String.make(~hintSize=10);
-Belt.HashMap.String.set(hMap, "1", "value1");
-Belt.HashMap.String.set(hMap, "2", "value2");
-
-Belt.HashMap.String.valuesToArray(hMap) == [|"value1", "value2"|];
-```
-
-## fromArray
-
-```re sig
-let fromArray: array((key, 'a)) => t('a);
-```
-
-Creates new hash map from array of pairs.
-
-Returns array of values.
-
-```re example
-let hMap = Belt.HashMap.String.fromArray([|("1", "value1"), ("2", "value2")|]);
-Belt.HashMap.String.toArray(hMap) == [|("1", "value1"), ("2", "value2")|];
-```
-
-## mergeMany
-
-```re sig
-let mergeMany: (t('a), array((key, 'a))) => unit;
-```
-
-Merges many key value pairs into hash map.
-
-```re example
-let hMap = Belt.HashMap.String.make(~hintSize=10);
-Belt.HashMap.String.mergeMany(hMap, [|("1", "value1"), ("2", "value2")|]);
-```
-
-## getBucketHistogram
-
-```re sig
-let getBucketHistogram: t('a) => array(int);
-```
-
-```re example
-let hMap = Belt.HashMap.String.make(~hintSize=10);
-Belt.HashMap.String.set(hMap, "1", "1");
-
-Belt.HashMap.String.getBucketHistogram(hMap);
-```
-
-## logStats
-
-```re sig
-let logStats: t('a) => unit;
-```
-
-```re example
-let hMap = Belt.HashMap.String.make(~hintSize=10);
-Belt.HashMap.String.set(hMap, "1", "1");
-
-Belt.HashMap.String.logStats(hMap);
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/hash-map.mdx b/pages/docs/manual/v8.0.0/api/belt/hash-map.mdx
deleted file mode 100644
index c5185c670..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/hash-map.mdx
+++ /dev/null
@@ -1,467 +0,0 @@
-# HashMap
-
-<Intro>
-
-The top level provides generic mutable hash map operations.
-
-</Intro>
-
-## t
-
-```re sig
-type t('key, 'value, 'id);
-```
-
-The type of hash tables from type `'key` to type `'value`.
-
-## id
-
-```re sig
-type id('a, 'id) = BeltId.hashable('a, 'id);
-```
-
-The identity needed for making an empty hash map.
-
-## make
-
-```re sig
-let make: (~hintSize: int, ~id: id('key, 'id)) => t('key, 'value, 'id);
-```
-
-`make(~hintSize=10, ~id)` creates a new map by taking in the comparator and `hintSize`.
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-
-let hMap = Belt.HashMap.make(~hintSize=10, ~id=(module IntHash));
-
-Belt.HashMap.set(hMap, 0, "a");
-```
-
-## clear
-
-```re sig
-let clear: t('key, 'value, 'id) => unit;
-```
-
-Clears a hash table.
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-  
-let hMap = Belt.HashMap.fromArray([|(1, "1")|], ~id=(module IntHash))  
-Belt.HashMap.clear(hMap)
-Belt.HashMap.isEmpty(hMap) == true;
-```
-
-## isEmpty
-
-```re sig
-let isEmpty: t('a, 'b, 'c) => bool;
-```
-
-`isEmpty(m)` checks whether a hash map is empty.
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-  
-Belt.HashMap.isEmpty(Belt.HashMap.fromArray([|(1, "1")|], ~id=(module IntHash))) == false;
-```
-
-## set
-
-```re sig
-let set: (t('key, 'value, 'id), 'key, 'value) => unit;
-```
-
-`set(hMap, k, v)` if `k` does not exist, add the binding `k,v`, otherwise, update the old value with the new `v`.
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-  
-let s0 = Belt.HashMap.fromArray([|(2, "2"), (1, "1"), (3, "3")|], ~id=(module IntHash));
-
-Belt.HashMap.set(s0, 2, "3");
-
-Belt.HashMap.valuesToArray(s0) == [|"1", "3", "3"|];
-```
-
-## copy
-
-```re sig
-let copy: t('key, 'value, 'id) => t('key, 'value, 'id);
-```
-
-Creates copy of a hash map.
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-  
-let s0 = Belt.HashMap.fromArray([|(2, "2"), (1, "1"), (3, "3")|], ~id=(module IntHash));
-let s1 = Belt.HashMap.copy(s0)
-
-Belt.HashMap.set(s0, 2, "3");
-
-Belt.HashMap.get(s0, 2) != Belt.HashMap.get(s1, 2)
-```
-
-## get
-
-```re sig
-let get: (t('key, 'value, 'id), 'key) => option('value);
-```
-
-Returns value bound under specific key. If values not exist returns `None`.
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-  
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=(module IntHash));
-Belt.HashMap.set(s0, 1, "value1");
-
-Belt.HashMap.get(s0, 1) == Some("value1");
-Belt.HashMap.get(s0, 2) == None;
-```
-
-## has
-
-```re sig
-let has: (t('key, 'value, 'id), 'key) => bool;
-```
-
-Checks if `x` is bound in `tbl`.
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-  
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=(module IntHash));
-Belt.HashMap.set(s0, 1, "value1");
-
-Belt.HashMap.has(s0, 1) == true;
-Belt.HashMap.has(s0, 2) == false;
-```
-
-## remove
-
-```re sig
-let remove: (t('key, 'value, 'id), 'key) => unit;
-```
-
-If bound exists, removes it from the hash map.
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-  
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=(module IntHash));
-Belt.HashMap.set(s0, 1, "value1");
-Belt.HashMap.remove(s0, 1);
-Belt.HashMap.has(s0, 1) == false;
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t('key, 'value, 'id), [@bs] (('key, 'value) => unit)) => unit;
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```re sig
-let forEach: (t('key, 'value, 'id), ('key, 'value) => unit) => unit;
-```
-
-`forEach(tbl, f)` applies `f` to all bindings in table `tbl`. `f` receives the key as first argument, and the associated value as second argument. Each binding is presented exactly once to `f`.
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-  
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=(module IntHash));
-Belt.HashMap.set(s0, 1, "value1");
-Belt.HashMap.forEach(s0, (key, value) => Js.log2(key, value));
-// prints (1, "value1")
-```
-
-## reduceU
-
-```re sig
-let reduceU: (t('key, 'value, 'id), 'c, [@bs] (('c, 'key, 'value) => 'c)) => 'c;
-```
-
-Same as [reduce](##reduce) but takes uncurried functon.
-
-## reduce
-
-```re sig
-let reduce: (t('key, 'value, 'id), 'c, ('c, 'key, 'value) => 'c) => 'c;
-```
-
-`reduce(tbl, init, f)` computes `(f(kN, dN) ... (f(k1, d1, init))...)`, where `k1 ... kN` are the keys of all bindings in `tbl`, and `d1 ... dN` are the associated values. Each binding is presented exactly once to `f`.
-
-The order in which the bindings are passed to `f` is unspecified. However, if the table contains several bindings for the same key, they are passed to `f` in reverse order of introduction, that is, the most recent binding is passed first.
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-  
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=(module IntHash));
-Belt.HashMap.set(s0, 1, "value1");
-Belt.HashMap.set(s0, 2, "value2");
-
-Belt.HashMap.reduce(s0, "", (acc, key, value) => {
-  acc ++ ", " ++ value
-}) == "value1, value2";
-```
-
-## keepMapInPlaceU
-
-```re sig
-let keepMapInPlaceU: (t('key, 'value, 'id), [@bs] (('key, 'value) => option('value))) => unit;
-```
-
-Same as [keepMapInPlace](##keepMapInPlace) but takes uncurried functon.
-
-## keepMapInPlace
-
-```re sig
-let keepMapInPlace: (t('key, 'value, 'id), ('key, 'value) => option('value)) => unit;
-```
-
-Filters out values for which function `f` returned `None`.
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-  
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=(module IntHash));
-Belt.HashMap.set(s0, 1, "value1");
-Belt.HashMap.set(s0, 2, "value2");
-
-Belt.HashMap.keepMapInPlace(s0, (key, value) => {
-  key == 1 ? None : Some(value)
-});
-```
-
-## size
-
-```re sig
-let size: t('a, 'b, 'c) => int;
-```
-
-`size(tbl)` returns the number of bindings in `tbl`. It takes constant time.
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-  
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=(module IntHash));
-Belt.HashMap.set(s0, 1, "value1");
-Belt.HashMap.set(s0, 2, "value2");
-
-Belt.HashMap.size(s0) == 2;
-```
-
-## toArray
-
-```re sig
-let toArray: t('key, 'value, 'id) => array(('key, 'value));
-```
-
-Returns array of key value pairs.
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-  
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=(module IntHash));
-Belt.HashMap.set(s0, 1, "value1");
-Belt.HashMap.set(s0, 2, "value2");
-
-Belt.HashMap.toArray(s0) == [|(1, "value1"), (2, "value2")|];
-```
-
-## keysToArray
-
-```re sig
-let keysToArray: t('key, 'a, 'b) => array('key);
-```
-
-Returns array of keys.
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-  
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=(module IntHash));
-Belt.HashMap.set(s0, 1, "value1");
-Belt.HashMap.set(s0, 2, "value2");
-
-Belt.HashMap.keysToArray(s0) == [|1, 2|];
-```
-
-## valuesToArray
-
-```re sig
-let valuesToArray: t('a, 'value, 'b) => array('value);
-```
-
-Returns array of values.
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-  
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=(module IntHash));
-Belt.HashMap.set(s0, 1, "value1");
-Belt.HashMap.set(s0, 2, "value2");
-
-Belt.HashMap.valuesToArray(s0) == [|"value1", "value2"|];
-```
-
-## fromArray
-
-```re sig
-let fromArray: (array(('key, 'value)), ~id: id('key, 'id)) => t('key, 'value, 'id);
-```
-
-Creates new hash map from array of pairs.
-
-Returns array of values.
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-  
-let s0 = Belt.HashMap.fromArray([|(1, "value1"), (2, "value2")|], ~id=(module IntHash));
-Belt.HashMap.toArray(s0) == [|(1, "value1"), (2, "value2")|];
-```
-
-## mergeMany
-
-```re sig
-let mergeMany: (t('key, 'value, 'id), array(('key, 'value))) => unit;
-```
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-  
-let hMap = Belt.HashMap.make(~hintSize=10, ~id=(module IntHash));
-Belt.HashMap.mergeMany(hMap, [|(1, "1"), (2, "2")|])
-```
-
-## getBucketHistogram
-
-```re sig
-let getBucketHistogram: t('a, 'b, 'c) => array(int);
-```
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-let hMap = Belt.HashMap.make(~hintSize=10, ~id=(module IntHash));
-Belt.HashMap.set(hMap, 1, "1");
-
-Belt.HashMap.getBucketHistogram(hMap);
-```
-
-## logStats
-
-```re sig
-let logStats: t('a, 'b, 'c) => unit;
-```
-
-```re example
-module IntHash =
-  Belt.Id.MakeHashable({
-    type t = int;
-    let hash = a => a;
-    let eq = (a, b) => a == b;
-  });
-let hMap = Belt.HashMap.make(~hintSize=10, ~id=(module IntHash));
-Belt.HashMap.set(hMap, 1, "1");
-
-Belt.HashMap.logStats(hMap);
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/hash-set-int.mdx b/pages/docs/manual/v8.0.0/api/belt/hash-set-int.mdx
deleted file mode 100644
index b1812d954..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/hash-set-int.mdx
+++ /dev/null
@@ -1,123 +0,0 @@
-# HashSetInt
-
-<Intro>
-
-This module is `Belt.HashSet` specialized with key type to be a primitive type.
-
-It is more efficient in general, the API is the same with `Belt.HashSet` except its key type is fixed, and identity is not needed(using the built-in one).
-
-</Intro>
-
-## key
-
-```re sig
-type key = int;
-```
-
-## t
-
-```re sig
-type t;
-```
-
-## make
-
-```re sig
-let make: (~hintSize: int) => t;
-```
-
-## clear
-
-```re sig
-let clear: t => unit;
-```
-
-## isEmpty
-
-```re sig
-let isEmpty: t => bool;
-```
-
-## add
-
-```re sig
-let add: (t, key) => unit;
-```
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## has
-
-```re sig
-let has: (t, key) => bool;
-```
-
-## remove
-
-```re sig
-let remove: (t, key) => unit;
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t, [@bs] (key => unit)) => unit;
-```
-
-## forEach
-
-```re sig
-let forEach: (t, key => unit) => unit;
-```
-
-## reduceU
-
-```re sig
-let reduceU: (t, 'c, [@bs] (('c, key) => 'c)) => 'c;
-```
-
-## reduce
-
-```re sig
-let reduce: (t, 'c, ('c, key) => 'c) => 'c;
-```
-
-## size
-
-```re sig
-let size: t => int;
-```
-
-## logStats
-
-```re sig
-let logStats: t => unit;
-```
-
-## toArray
-
-```re sig
-let toArray: t => array(key);
-```
-
-## fromArray
-
-```re sig
-let fromArray: array(key) => t;
-```
-
-## mergeMany
-
-```re sig
-let mergeMany: (t, array(key)) => unit;
-```
-
-## getBucketHistogram
-
-```re sig
-let getBucketHistogram: t => array(int);
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/hash-set-string.mdx b/pages/docs/manual/v8.0.0/api/belt/hash-set-string.mdx
deleted file mode 100644
index 053c9600d..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/hash-set-string.mdx
+++ /dev/null
@@ -1,123 +0,0 @@
-# HashSetString
-
-<Intro>
-
-This module is `Belt.HashSet` specialized with key type to be a primitive type.
-
-It is more efficient in general, the API is the same with `Belt.HashSet` except its key type is fixed, and identity is not needed(using the built-in one).
-
-</Intro>
-
-## key
-
-```re sig
-type key = string;
-```
-
-## t
-
-```re sig
-type t;
-```
-
-## make
-
-```re sig
-let make: (~hintSize: int) => t;
-```
-
-## clear
-
-```re sig
-let clear: t => unit;
-```
-
-## isEmpty
-
-```re sig
-let isEmpty: t => bool;
-```
-
-## add
-
-```re sig
-let add: (t, key) => unit;
-```
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## has
-
-```re sig
-let has: (t, key) => bool;
-```
-
-## remove
-
-```re sig
-let remove: (t, key) => unit;
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t, [@bs] (key => unit)) => unit;
-```
-
-## forEach
-
-```re sig
-let forEach: (t, key => unit) => unit;
-```
-
-## reduceU
-
-```re sig
-let reduceU: (t, 'c, [@bs] (('c, key) => 'c)) => 'c;
-```
-
-## reduce
-
-```re sig
-let reduce: (t, 'c, ('c, key) => 'c) => 'c;
-```
-
-## size
-
-```re sig
-let size: t => int;
-```
-
-## logStats
-
-```re sig
-let logStats: t => unit;
-```
-
-## toArray
-
-```re sig
-let toArray: t => array(key);
-```
-
-## fromArray
-
-```re sig
-let fromArray: array(key) => t;
-```
-
-## mergeMany
-
-```re sig
-let mergeMany: (t, array(key)) => unit;
-```
-
-## getBucketHistogram
-
-```re sig
-let getBucketHistogram: t => array(int);
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/hash-set.mdx b/pages/docs/manual/v8.0.0/api/belt/hash-set.mdx
deleted file mode 100644
index 2a5a035a8..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/hash-set.mdx
+++ /dev/null
@@ -1,162 +0,0 @@
-# HashSet
-
-<Intro>
-
-A mutable Hash set which allows customized `hash` behavior.
-All data are parameterized by not its only type but also a unique identity in the time of initialization, so that two HashSets of ints initialized with different hash functions will have different type.
-
-</Intro>
-
-```re example
-type t = int;
-
-module I0 = (
-  val Belt.Id.hashableU(
-        ~hash=(. a: t) => a land 65535,
-        ~eq=(. a, b) => a == b,
-      )
-);
-
-let s0 = Belt.HashSet.make(~id=(module I0), ~hintSize=40);
-
-module I1 = (
-  val Belt.Id.hashableU(
-        ~hash=(. a: t) => a land 255,
-        ~eq=(. a, b) => a == b,
-      )
-);
-
-let s1 = Belt.HashSet.make(~id=(module I1), ~hintSize=40);
-
-Belt.HashSet.add(s1, 0);
-Belt.HashSet.add(s1, 1);
-```
-
-The invariant must be held: for two elements who are equal, their hashed value should be the same.
-
-Here the compiler would infer `s0` and `s1` having different type so that it would not mix.
-
-```re sig
-let s0: t(int, I0.identity);
-let s1: t(int, I1.identity);
-```
-
-We can add elements to the collection (see last two lines in the example above). Since this is an mutable data structure, `s1` will contain two pairs.
-
-## t
-
-```re sig
-type t('a, 'id);
-```
-
-## id
-
-```re sig
-type id('a, 'id) = BeltId.hashable('a, 'id);
-```
-
-## make
-
-```re sig
-let make: (~hintSize: int, ~id: id('a, 'id)) => t('a, 'id);
-```
-
-## clear
-
-```re sig
-let clear: t('a, 'id) => unit;
-```
-
-## isEmpty
-
-```re sig
-let isEmpty: t('a, 'b) => bool;
-```
-
-## add
-
-```re sig
-let add: (t('a, 'id), 'a) => unit;
-```
-
-## copy
-
-```re sig
-let copy: t('a, 'id) => t('a, 'id);
-```
-
-## has
-
-```re sig
-let has: (t('a, 'id), 'a) => bool;
-```
-
-## remove
-
-```re sig
-let remove: (t('a, 'id), 'a) => unit;
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t('a, 'id), [@bs] ('a => unit)) => unit;
-```
-
-## forEach
-
-```re sig
-let forEach: (t('a, 'id), 'a => unit) => unit;
-```
-
-Order unspecified.
-
-## reduceU
-
-```re sig
-let reduceU: (t('a, 'id), 'c, [@bs] (('c, 'a) => 'c)) => 'c;
-```
-
-## reduce
-
-```re sig
-let reduce: (t('a, 'id), 'c, ('c, 'a) => 'c) => 'c;
-```
-
-Order unspecified.
-
-## size
-
-```re sig
-let size: t('a, 'id) => int;
-```
-
-## logStats
-
-```re sig
-let logStats: t('a, 'b) => unit;
-```
-
-## toArray
-
-```re sig
-let toArray: t('a, 'id) => array('a);
-```
-
-## fromArray
-
-```re sig
-let fromArray: (array('a), ~id: id('a, 'id)) => t('a, 'id);
-```
-
-## mergeMany
-
-```re sig
-let mergeMany: (t('a, 'id), array('a)) => unit;
-```
-
-## getBucketHistogram
-
-```re sig
-let getBucketHistogram: t('a, 'b) => array(int);
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/id.mdx b/pages/docs/manual/v8.0.0/api/belt/id.mdx
deleted file mode 100644
index 0da25077e..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/id.mdx
+++ /dev/null
@@ -1,137 +0,0 @@
-# Id
-
-<Intro>
-
-Provide utilities to create identified comparators or hashes for data
-structures used below.
-
-It creates a unique identifier per module of functions so that different data
-structures with slightly different comparison functions won't mix.
-
-</Intro>
-
-## hash
-
-```re sig
-type hash('a, 'id);
-```
-
-Its runtime represenation is a hash function, but signed with a type parameter, so that different hash functions type mismatch.
-
-## eq
-
-```re sig
-type eq('a, 'id);
-```
-
-Its runtime represenation is an eq function, but signed with a type parameter, so that different hash functions type mismatch.
-
-## cmp
-
-```re sig
-type cmp('a, 'id);
-```
-
-Its runtime representation is a cmp function, but signed with a type parameter, so that different hash functions type mismatch.
-
-## Comparable
-
-```re sig
-module type Comparable {
-  type identity;
-
-  type t;
-
-  let cmp: BeltId.cmp(t, identity);
-}
-```
-
-## comparable
-
-```re sig
-type ('key,'id) comparable = (module BeltId.Comparable with type identity = 'id and type t = 'key)
-```
-
-is a module of functions, here it only includes cmp.
-
-Unlike normal functions, when created, it comes with a unique identity (guaranteed by the type system).
-
-It can be created using function `Belt_Id.comparableU` or `Belt_Id.comparable`.
-
-The idea of a unique identity when created is that it makes sure two sets would type mismatch if they use different comparison function
-
-## MakeComparableU
-
-```re sig
-module MakeComparableU: (M: {type t; let cmp: [@bs] ((t, t) => int);}) => Comparable with type t = M.t;
-```
-
-## MakeComparable
-
-```re sig
-module MakeComparable: (M: {type t; let cmp: (t, t) => int;}) => Comparable with type t = M.t;
-```
-
-## comparableU
-
-```re sig
-let comparableU: (~cmp: [@bs] (('a, 'a) => int)) => (module BeltId.Comparable with type t = 'a);
-```
-
-## comparable
-
-```re sig
-type ('key, 'id) comparable = (module BeltId.Comparable with type identity = 'id and type t = 'key)
-```
-
-## Hashable
-
-```re sig
-module type Hashable = {
-  type identity;
-
-  type t;
-
-  let hash: BeltId.hash(t, identity);
-
-  let eq: BeltId.eq(t, identity);
-}
-```
-
-## hashable
-
-```re sig
-type hashable('key, 'id) = (module BeltId.Hashable with type identity = 'id and type t = 'key);
-```
-
-is a module of functions, here it only includes hash, eq.
-
-Unlike normal functions, when created, it comes with a unique identity (guaranteed by the type system).
-
-It can be created using function `Belt_Id.hashableU` or `Belt_Id.hashable`.
-
-The idea of a unique identity when created is that it makes sure two hash sets would type mismatch if they use different comparison function.
-
-## MakeHashableU
-
-```re sig
-module MakeHashableU: (M: {type t; let hash: [@bs] (t => int); let eq: [@bs] ((t, t) => bool);}) => Hashable with type t = M.t;
-```
-
-## MakeHashable
-
-```re sig
-module MakeHashable: (M: {type t; let hash: t => int; let eq: (t, t) => bool;}) => Hashable with type t = M.t;
-```
-
-## hashableU
-
-```re sig
-let hashableU: (~hash: [@bs] ('a => int), ~eq: [@bs] (('a, 'a) => bool)) => (module BeltId.Hashable with type t = 'a);
-```
-
-## hashable
-
-```re sig
-let hashable: (~hash: 'a => int, ~eq: ('a, 'a) => bool) => (module BeltId.Hashable with type t = 'a);
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/int.mdx b/pages/docs/manual/v8.0.0/api/belt/int.mdx
deleted file mode 100644
index c2f5a912a..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/int.mdx
+++ /dev/null
@@ -1,104 +0,0 @@
-# Int
-
-This module includes convenience methods for handling `int` types.
-
-## toFloat
-
-```re sig
-let toFloat: int => float;
-```
-
-Converts a given `int` to a `float`. 
-
-```re example
-Js.log(Belt.Int.toFloat(1) === 1.0); /* true */
-```
-
-## fromFloat
-
-```re sig
-let fromFloat: float => int;
-```
-
-Converts a given `float` to an `int`.
-
-```re example
-Js.log(Belt.Int.fromFloat(1.0) === 1); /* true */
-```
-
-## fromString
-
-```re sig
-let fromString: string => option(int);
-```
-
-Converts a given `string` to an `int`. Returns `Some(int)` when the input is a number, `None` otherwise.
-
-```re example
-Js.log(Belt.Int.fromString("1") === Some(1)); /* true */
-```
-
-
-## toString
-
-```re sig
-let toString: int => string;
-```
-
-Converts a given `int` to a `string`. Uses the JavaScript `String` constructor under the hood.
-
-```re example
-Js.log(Belt.Int.toString(1) === "1"); /* true */
-```
-
-## +
-
-```re sig
-let (+): (int, int) => int;
-```
-
-Addition of two `int` values. Same as the addition from `Pervasives`.
-
-```re example
-open Belt.Int;
-Js.log(2 + 2 === 4); /* true */
-```
-
-## -
-
-```re sig
-let (-): (int, int) => int;
-```
-
-Subtraction of two `int` values. Same as the subtraction from `Pervasives`.
-
-```re example
-open Belt.Int;
-Js.log(2 - 1 === 1); /* true */
-```
-
-## \*
-
-```re sig
-let ( * ): (int, int) => int;
-```
-
-Multiplication of two `int` values. Same as the multiplication from `Pervasives`.
-
-```re example
-open Belt.Int;
-Js.log(2 * 2 === 4); /* true */
-```
-
-## /
-
-```re sig
-let (/): (int, int) => int;
-```
-
-Division of two `int` values. Same as the division from `Pervasives`.
-
-```re example
-open Belt.Int;
-Js.log(4 / 2 === 2); /* true */
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/list.mdx b/pages/docs/manual/v8.0.0/api/belt/list.mdx
deleted file mode 100644
index 8c47eb8a5..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/list.mdx
+++ /dev/null
@@ -1,1120 +0,0 @@
-# List
-
-<Intro>
-
-Collection functions for manipulating `list` data structures.
-
-</Intro>
-
-## t('a)
-
-```re sig
-type t('a) = list('a);
-```
-
-## length
-
-```re sig
-let length: t('a) => int;
-```
-
-Returns the length of a list.
-
-```re example
-Belt.List.length([1, 2, 3]); /* 3 */
-```
-
-## size
-
-```re sig
-let size: t('a) => int;
-```
-
-**See:** [length](#length)
-
-## head
-
-```re sig
-let head: t('a) => option('a);
-```
-
-Returns `Some(value)` where `value` is the first element in the list, or `None` if `someList` is an empty list.
-
-```re example
-Belt.List.head([]); /* None */
-
-Belt.List.head([1, 2, 3]); /* Some(1) */
-```
-
-## headExn
-
-```re sig
-let headExn: t('a) => 'a;
-```
-
-Same as [head](#head), but raises an exception if `someList` is empty. Use with care.
-
-```re example
-Belt.List.headExn([1, 2, 3]); /* 1 */
-
-Belt.List.headExn([]); /* Raises an Error */
-```
-
-## tail
-
-```re sig
-let tail: t('a) => option(t('a));
-```
-
-Returns `None` if `someList` is empty, otherwise it returns `Some(tail)` where `tail` is everything except the first element of `someList`.
-
-```re example
-Belt.List.tail([1, 2, 3]); /* Some([2, 3]) */
-
-Belt.List.tail([]); /* None */
-```
-
-## tailExn
-
-```re sig
-let tailExn: t('a) => t('a);
-```
-
-Same as [tail](#tail), but raises an exception if `someList` is empty. Use with care.
-
-```re example
-Belt.List.tailExn([1, 2, 3]); /* [2, 3] */
-
-Belt.List.tailExn([]); /* Raises an Error */
-```
-
-## add
-
-```re sig
-let add: (t('a), 'a) => t('a);
-```
-
-Adds `value` to the beginning of `someList`.
-
-```re example
-Belt.List.add([2, 3], 1); /* [1, 2, 3] */
-
-Belt.List.add(["World", "!"], "Hello"); /* ["Hello", "World", "!"] */
-```
-
-## get
-
-```re sig
-let get: (t('a), int) => option('a);
-```
-
-Return the nth element in `someList`, or `None` if `index` is larger than the length.
-
-```re example
-let abc = ["A", "B", "C"];
-
-abc->Belt.List.get(1); /* Some("B") */
-
-abc->Belt.List.get(4); /* None */
-```
-
-## getExn
-
-```re sig
-let getExn: (t('a), int) => 'a;
-```
-
-Same as [get](#get), but raises an exception if `index` is larger than the length. Use with care.
-
-```re example
-let abc = ["A", "B", "C"];
-
-abc->Belt.List.getExn(1); /* "B" */
-
-abc->Belt.List.getExn(4); /* Raises an Error */
-```
-
-## make
-
-```
-let make: (int, 'a) => t('a);
-```
-
-Returns a list of length `numItems` with each element filled with value `v`. Returns an empty list if `numItems` is negative.
-
-```re example
-Belt.List.make(3, 1); /* [1, 1, 1] */
-```
-
-## makeBy
-
-```re sig
-let makeBy: (int, int => 'a) => t('a);
-```
-
-Return a list of length `numItems` with element `i` initialized with `f(i)`.
-Returns an empty list if `numItems` is negative.
-
-```re example
-Belt.List.makeBy(5, i => i); /* [0, 1, 2, 3, 4] */
-
-Belt.List.makeBy(5, i => i * i); /* [0, 1, 4, 9, 16] */
-```
-
-## makeByU
-
-```re sig
-let makeByU: (int, [@bs] (int => 'a)) => t('a);
-```
-
-Uncurried version of [makeBy](#makeBy)
-
-## shuffle
-
-```re sig
-let shuffle: t('a) => t('a);
-```
-
-Returns a new list in random order.
-
-```re example
-Belt.List.shuffle([1, 2, 3]); /* [2, 1, 3] */
-```
-
-## drop
-
-```re sig
-let drop: (t('a), int) => option(t('a));
-```
-
-Return a new list, dropping the first `n` elements. Returns `None` if `someList` has fewer than `n` elements.
-
-```re example
-[1, 2, 3]->Belt.List.drop(2); /* Some([3]) */
-
-[1, 2, 3]->Belt.List.drop(3); /* Some([]) */
-
-[1, 2, 3]->Belt.List.drop(4); /* None */
-```
-
-## take
-
-```re sig
-let take: (t('a), int) => option(t('a));
-```
-
-Returns a list with the first `n` elements from `someList`, or `None` if `someList` has fewer than `n` elements.
-
-```re example
-[1, 2, 3]->Belt.List.take(1); /* Some([1]) */
-
-[1, 2, 3]->Belt.List.take(2); /* Some([1, 2]) */
-
-[1, 2, 3]->Belt.List.take(4); /* None */
-```
-
-## splitAt
-
-```re sig
-let splitAt: (t('a), int) => option((list('a), list('a)));
-```
-
-Split the list `someList` at `index`. Returns `None` when the length of `someList` is less than `index`.
-
-```re example
-["Hello", "World"]->Belt.List.splitAt(1); /* Some((["Hello"], ["World"])) */
-
-[0, 1, 2, 3, 4]->Belt.List.splitAt(2); /* Some(([0, 1], [2, 3, 4])) */
-```
-
-## concat
-
-```re sig
-let concat: (t('a), t('a)) => t('a);
-```
-
-Returns the list obtained by adding `secondList` after `firstList`.
-
-```re example
-Belt.List.concat([1, 2, 3], [4, 5]); /* [1, 2, 3, 4, 5] */
-```
-
-## concatMany
-
-```re sig
-let concatMany: array(t('a)) => t('a);
-```
-
-Returns the list obtained by concatenating all the lists in array `a`, in order.
-
-```re example
-Belt.List.concatMany([|[1, 2, 3], [], [3], [4]|]); /* [1, 2, 3, 3, 4] */
-```
-
-## reverseConcat
-
-```re sig
-let reverseConcat: (t('a), t('a)) => t('a);
-```
-
-Equivalent to writing: `concat(reverse(firstList), secondList)`
-
-```re example
-Belt.List.reverseConcat([1, 2], [3, 4]); /* [2, 1, 3, 4] */
-```
-
-## flatten
-
-```re sig
-let flatten: t(t('a)) => t('a);
-```
-
-Return the list obtained by concatenating all the lists in list `ls`, in order.
-
-```re example
-Belt.List.flatten([[1, 2, 3], [], [3], [4]]); /* [1, 2, 3, 3, 4] */
-```
-
-## map
-
-```re sig
-let map: (t('a), 'a => 'b) => t('b);
-```
-
-Returns a new list with `f` applied to each element of `someList`.
-
-```re example
-[1, 2]->Belt.List.map(x => x + 1); /* [3, 4] */
-```
-
-## mapU
-
-```re sig
-let mapU: (t('a), [@bs] ('a => 'b)) => t('b);
-```
-
-Uncurried version of [map](#map).
-
-## zip
-
-```re sig
-let zip: (t('a), t('b)) => t(('a, 'b));
-```
-
-Returns a list of pairs from the two lists with the length of the shorter list.
-
-```re example
-Belt.List.zip([1, 2], [3, 4, 5]); /* [(1, 3), (2, 4)] */
-```
-
-## zipBy
-
-```re sig
-let zipBy: (t('a), t('b), ('a, 'b) => 'c) => t('c);
-```
-
-**See:** [zip](#zip)
-
-Equivalent to:
-
-```re sig
-zip(firstList, secondList) |> List.map(((x, y)) => f(x, y));
-```
-
-```re example
-Belt.List.zipBy([1, 2, 3], [4, 5], (a, b) => 2 * a + b); /* [6, 9] */
-```
-
-## zipByU
-
-```re sig
-let zipByU: (t('a), t('b), [@bs] (('a, 'b) => 'c)) => t('c);
-```
-
-Uncurried version of [zipBy](#zipBy).
-
-## mapWithIndex
-
-```re sig
-let mapWithIndex: (t('a), (int, 'a) => 'b) => t('b);
-```
-
-Applies `f` to each element of `someList`.
-Function `f` takes two arguments: the index starting from 0 and the element from `someList`, in that order.
-
-```re example
-[1, 2, 3]->Belt.List.mapWithIndex((index, x) => index + x); /* [1, 3, 5] */
-```
-
-## mapWithIndexU
-
-```re sig
-let mapWithIndexU: (t('a), [@bs] ((int, 'a) => 'b)) => t('b);
-```
-
-Uncurried version of [mapWithIndex](#mapWithIndex).
-
-## fromArray
-
-```re sig
-let fromArray: array('a) => t('a);
-```
-
-Converts the given array to a list.
-
-```re example
-Belt.List.fromArray([|1, 2, 3|]); /* [1, 2, 3] */
-```
-
-## toArray
-
-```re sig
-let toArray: t('a) => array('a);
-```
-
-Converts the given list to an array.
-
-```re example
-Belt.List.toArray([1, 2, 3]); /* [|1, 2, 3|] */
-```
-
-## reverse
-
-```re sig
-let reverse: t('a) => t('a);
-```
-
-Returns a new list whose elements are those of `someList` in reversed order.
-
-```re example
-Belt.List.reverse([1, 2, 3]); /* [3, 2, 1] */
-```
-
-## mapReverse
-
-```re sig
-let mapReverse: (t('a), 'a => 'b) => t('b);
-```
-
-Equivalent to:
-
-```re sig
-map(someList, f)->reverse;
-```
-
-```re example
-[3, 4, 5]->Belt.List.mapReverse(x => x * x); /* [25, 16, 9] */
-```
-
-## mapReverseU
-
-```re sig
-let mapReverseU: (t('a), [@bs] ('a => 'b)) => t('b);
-```
-
-Uncurried version of [mapReverse](#mapReverse).
-
-## forEach
-
-```re sig
-let forEach: (t('a), 'a => 'b) => unit;
-```
-
-Call `f` on each element of `someList` from the beginning to end.
-`f` returns `unit`, so no new array is created. Use `forEach` when you are primarily concerned with repetitively creating side effects.
-
-```re example
-Belt.List.forEach(["a", "b", "c"], x => Js.log("Item: " ++ x));
-/*
-  prints:
-    Item: a
-    Item: b
-    Item: c
-*/
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t('a), [@bs] ('a => 'b)) => unit;
-```
-
-Uncurried version of [forEach](#forEach).
-
-## forEachWithIndex
-
-```re sig
-let forEachWithIndex: (t('a), (int, 'a) => 'b) => unit;
-```
-
-Call `f` on each element of `someList` from beginning to end.
-Function `f` takes two arguments: the index starting from 0 and the element from `someList`. `f` returns `unit`.
-
-```re example
-Belt.List.forEachWithIndex(["a", "b", "c"], (index, x) => Js.log("Item " ++ string_of_int(index) ++ " is " ++ x));
-/*  prints:
-      Item 0 is a
-      Item 1 is b
-      Item 2 is cc
-    */
-```
-
-## forEachWithIndexU
-
-```re sig
-let forEachWithIndexU: (t('a), [@bs] ((int, 'a) => 'b)) => unit;
-```
-
-Uncurried version of [forEachWithIndex](#forEachWithIndex).
-
-## reduce
-
-```re sig
-let reduce: (t('a), 'b, ('b, 'a) => 'b) => 'b;
-```
-
-Applies `f` to each element of `someList` from beginning to end. Function `f` has two parameters: the item from the list and an “accumulator”, which starts with a value of `initialValue`. reduce returns the final value of the accumulator.
-
-```re example
-[1, 2, 3, 4]->Belt.List.reduce(0, (+)); /* 10 */
-
-/* same as */
-
-[1, 2, 3, 4]->Belt.List.reduce(0, (acc, item) => acc + item); /* 10 */
-```
-
-## reduceU
-
-```re sig
-let reduceU: (t('a), 'b, [@bs] (('b, 'a) => 'b)) => 'b;
-```
-
-Uncurried version of [reduce](#reduce).
-
-## reduceWithIndex
-
-```re sig
-let reduceWithIndex: (t('a), 'b, ('b, 'a, int) => 'b) => 'b;
-```
-
-Applies `f` to each element of `someList` from beginning to end. Function `f` has three parameters: the item from the list and an “accumulator”, which starts with a value of `initialValue` and the index of each element. `reduceWithIndex` returns the final value of the accumulator.
-
-```re example
-[1, 2, 3, 4]->Belt.List.reduceWithIndex(0, (acc, item, index) => acc + item + index); /* 16 */
-```
-
-## reduceWithIndexU
-
-```re sig
-let reduceWithIndexU: (t('a), 'b, [@bs] (('b, 'a, int) => 'b)) => 'b;
-```
-
-Uncurried version of [reduceWithIndex](#reduceWithIndex).
-
-## reduceReverse
-
-```re sig
-let reduceReverse: (t('a), 'b, ('b, 'a) => 'b) => 'b;
-```
-
-Works like [reduce](#reduce), except that function `f` is applied to each item of `someList` from the last back to the first.
-
-```re example
-[1, 2, 3, 4]->Belt.List.reduceReverse(0, (+)); /* 10 */
-
-[1, 2, 3, 4]->Belt.List.reduceReverse(10, (-)); /* 0 */
-
-[1, 2, 3, 4]->Belt.List.reduceReverse([], Belt.List.add); /* [1, 2, 3, 4] */
-```
-
-## reduceReverseU
-
-```re sig
-let reduceReverseU: (t('a), 'b, [@bs] (('b, 'a) => 'b)) => 'b;
-```
-
-Uncurried version of [reduceReverse](#reduceReverse).
-
-## mapReverse2
-
-```re sig
-let mapReverse2: (t('a), t('b), ('a, 'b) => 'c) => t('c);
-```
-
-Equivalent to: `zipBy(xs, ys, f)->reverse`
-
-```re example
-
-Belt.List.mapReverse2([1, 2, 3], [1, 2], (+)); /* [4, 2] */
-```
-## mapReverse2U
-
-```re sig
-let mapReverse2U: (t('a), t('b), [@bs] (('a, 'b) => 'c)) => t('c);
-```
-
-Uncurried version of [mapReverse2](#mapReverse2).
-
-## forEach2
-
-```re sig
-let forEach2: (t('a), t('b), ('a, 'b) => 'c) => unit;
-```
-
-Stops at the length of the shorter list.
-
-```re example
-Belt.List.forEach2(["Z", "Y"], ["A", "B", "C"], (x, y) => Js.log2(x, y));
-
-/* prints:
-"Z" "A"
-"Y" "B"
-*/
-```
-
-## forEach2U
-
-```re sig
-let forEach2U: (t('a), t('b), (.'a, 'b) => 'c) => unit;
-```
-
-Uncurried version of [forEach2](#forEach2).
-
-## reduce2
-
-```re sig
-let reduce2: (t('b), t('c), 'a, ('a, 'b, 'c) => 'a) => 'a;
-```
-
-Applies `f` to each element of `firstList` and `secondList` from beginning to end. Stops with the shorter list. Function `f` has three parameters: an “accumulator” which starts with a value of `initialValue`, an item from `firstList`, and an item from `secondList`. `reduce2` returns the final value of the accumulator.
-
-```re example
-Belt.List.reduce2([1, 2, 3], [4, 5], 0, (acc, x, y) => acc + x * x + y); /* 0 + (1 * 1 + 4) + (2 * 2 + 5) */
-```
-
-## reduce2U
-
-```re sig
-let reduce2U: (t('b), t('c), 'a, (.'a, 'b, 'c) => 'a) => 'a;
-```
-
-Uncurried version of [reduce2](#reduce2).
-
-## reduceReverse2
-
-```re sig
-let reduceReverse2: (t('a), t('b), 'c, ('c, 'a, 'b) => 'c) => 'c;
-```
-
-Applies `f` to each element of `firstList` and `secondList` from end to beginning. Stops with the shorter list. Function `f` has three parameters: an “accumulator” which starts with a value of init, an item from `firstList`, and an item from `secondList`. `reduce2` returns the final value of the accumulator.
-
-```re example
-Belt.List.reduceReverse2([1, 2, 3], [4, 5], 0, (acc, x, y) => acc + x * x + y); /*  + (1 * 1 + 4) + (2 * 2 + 5) */
-```
-
-## reduceReverse2U
-
-```re sig
-let reduceReverse2U: (t('a), t('b), 'c, (.'c, 'a, 'b) => 'c) => 'c;
-```
-
-Uncurried version of [reduceReverse2](#reduceReverse2).
-
-## every
-
-```re sig
-let every: (t('a), 'a => bool) => bool;
-```
-
-Returns `true` if all elements satisfy `pred`, where `pred` is a predicate: a function taking an element and returning a bool.
-
-```re example
-let isBelow10 = value => value < 10;
-
-[1, 9, 8, 2]->Belt.List.every(isBelow10); /* true */
-
-[1, 99, 8, 2]->Belt.List.every(isBelow10); /* false */
-```
-
-## everyU
-
-```re sig
-let everyU: (t('a), (.'a) => bool) => bool;
-```
-
-Uncurried version of [every](#every).
-
-## some
-
-```re sig
-let some: (t('a), 'a => bool) => bool;
-```
-
-Returns `true` if at least _one_ of the elements in `someList` satisfies `pred`, where `pred` is a predicate: a function taking an element and returning a bool.
-
-```re example
-let isAbove100 = value => value > 100;
-
-[101, 1, 2, 3]->Belt.List.some(isAbove100); /* true */
-
-[1, 2, 3, 4]->Belt.List.some(isAbove100); /* false */
-```
-
-## someU
-
-```re sig
-let someU: (t('a), (.'a => bool)) => bool;
-```
-
-Uncurried version of [some](#some).
-
-## every2
-
-```re sig
-let every2: (t('a), t('b), ('a, 'b) => bool) => bool;
-```
-
-Returns `true` if predicate `pred(a, b)` is `true` for all pairs of elements up to the shorter length (i.e. `min(length(firstList), length(secondList))`)
-
-```re example
-Belt.List.every2([1, 2, 3], [0, 1], (>)); /* true */
-
-Belt.List.every2([], [1], (a, b) => a > b); /* true */
-
-Belt.List.every2([2, 3], [1], (a, b) => a > b); /* true */
-
-Belt.List.every2([0, 1], [5, 0], (a, b) => a > b); /* false */
-```
-
-## every2U
-
-```re sig
-let every2U: (t('a), t('b), [@bs] (('a, 'b) => bool)) => bool;
-```
-
-Uncurried version of [every2](#every2).
-
-## some2
-
-```re sig
-let some2: (t('a), t('b), ('a, 'b) => bool) => bool;
-```
-
-Returns `true` if predicate `pred(a, b)` is true for any pair of elements up to the shorter length (i.e. `min(length(firstList), length(secondList))`)
-
-```re example
-Belt.List.some2([1, 2, 3], [0, 1], (>)); /* true */
-
-Belt.List.some2([], [1], (a, b) => a > b); /* false */
-
-Belt.List.some2([2, 3], [1], (a, b) => a > b); /* true */
-
-Belt.List.some2([0, 1], [5, 0], (a, b) => a > b); /* true */
-```
-
-## some2U
-
-```re sig
-let some2U: (t('a), t('b), [@bs] (('a, 'b) => bool)) => bool;
-```
-
-Uncurried version of [some2](#some2).
-
-## cmpByLength
-
-```re sig
-let cmpByLength: (t('a), t('a)) => int;
-```
-
-```re sig
-cmpByLength(firstList, secondList);
-```
-
-Compare two lists solely by length. Returns `-1` if `length(firstList)` is less than `length(secondList)`, `0` if `length(firstList)` equals `length(secondList)`, and `1` if `length(firstList)` is greater than `length(secondList)`.
-
-```re example
-Belt.List.cmpByLength([1, 2], [3, 4, 5, 6]); /* (-1) */
-
-Belt.List.cmpByLength([1, 2, 3], [4, 5, 6]); /* = 0 */
-
-Belt.List.cmpByLength([1, 2, 3, 4], [5, 6]); /* = 1 */
-```
-
-## cmp
-
-```re sig
-let cmp: (t('a), t('a), ('a, 'a) => int) => int;
-```
-
-Compare elements one by one `compareFn(a, b)`. `compareFn` returns a negative number if `a` is "less than" `b`, zero if `a` is "equal to" `b`, a positive number if `a` is "greater than" `b`.
-
-The comparison returns the first non-zero result of `compareFn`, or zero if `compareFn` returns zero for all `a` and `b`.
-
-If all items have compared equal, but `firstList` is exhausted first, return `-1`. (`firstList` is shorter).
-If all items have compared equal, but `secondList` is exhausted first, return `1` (`firstList` is longer).
-
-```re example
-Belt.List.cmp([3], [3, 7], (a, b) => compare(a, b)); /* (-1) */
-
-Belt.List.cmp([5, 3], [5], (a, b) => compare(a, b)); /* 1 */
-
-Belt.List.cmp([1, 3, 5], [1, 4, 2], (a, b) => compare(a, b)); /* (-1) */
-
-Belt.List.cmp([1, 3, 5], [1, 2, 3], (a, b) => compare(a, b)); /* 1 */
-
-Belt.List.cmp([1, 3, 5], [1, 3, 5], (a, b) => compare(a, b)); /* 0 */
-```
-
-**Please note:** The total ordering of List is different from Array,
-for Array, we compare the length first and, only if the lengths are equal, elements one by one.
-For lists, we just compare elements one by one.
-
-## cmpU
-
-```re sig
-let cmpU: (t('a), t('a), [@bs] (('a, 'a) => int)) => int;
-```
-
-Uncurried version of [cmp](#cmp).
-
-## eq
-
-```re sig
-let eq: (t('a), t('a), ('a, 'a) => bool) => bool;
-```
-
-Check equality of `firstList` and `secondList` using `eqElem` for equality on elements, where `eqElem` is a function that returns `true` if items `x` and `y` meet some criterion for equality, `false` otherwise. eq `false` if length of `firstList` and `secondList` are not the same.
-
-```re example
-Belt.List.eq([1, 2, 3], [1, 2], (==)); /* false */
-
-Belt.List.eq([1, 2], [1, 2], (==)); /* true */
-
-Belt.List.eq([1, 2, 3], [(-1), (-2), (-3)], (a, b) => abs(a) == abs(b)); /* true */
-```
-
-## eqU
-
-```re sig
-let eqU: (t('a), t('a), [@bs] (('a, 'a) => bool)) => bool;
-```
-
-Uncurried version of [eqU](#eqU).
-
-## has
-
-```re sig
-let has: (t('a), 'b, ('a, 'b) => bool) => bool;
-```
-
-Returns `true` if the list contains at least one element for which `eqFunction(x)` returns true.
-
-```re example
-[1, 2, 3]->Belt.List.has(2, (==)); /* true */
-
-[1, 2, 3]->Belt.List.has(4, (==)); /* false */
-
-[(-1), (-2), (-3)]->Belt.List.has(2, (a, b) => abs(a) == abs(b)); /* true */
-```
-
-## hasU
-
-```re sig
-let hasU: (t('a), 'b, [@bs] (('a, 'b) => bool)) => bool;
-```
-
-Uncurried version of [has](#has).
-
-## getBy
-
-```re sig
-let getBy: (t('a), 'a => bool) => option('a);
-```
-
-Returns `Some(value)` for the first value in `someList` that satisfies the predicate function `pred`. Returns `None` if no element satisfies the function.
-
-```re example
-Belt.List.getBy([1, 4, 3, 2], x => x > 3); /* Some(4) */
-
-Belt.List.getBy([1, 4, 3, 2], x => x > 4); /* None */
-```
-
-## getByU
-
-```re sig
-let getByU: (t('a), [@bs] ('a => bool)) => option('a);
-```
-
-Uncurried version of [getBy](#getBy).
-
-## keep
-
-```re sig
-let keep: (t('a), 'a => bool) => t('a);
-```
-
-Returns a list of all elements in `someList` which satisfy the predicate function `pred`.
-
-```re example
-let isEven = x => x mod 2 == 0;
-
-Belt.List.keep([1, 2, 3, 4], isEven); /* [2, 4] */
-
-Belt.List.keep([None, Some(2), Some(3), None], Belt.Option.isSome); /* [Some(2), Some(3)] */
-```
-
-## keepU
-
-```re sig
-let keepU: (t('a), [@bs] ('a => bool)) => t('a);
-```
-
-Uncurried version of [keep](#keep).
-
-## filter
-
-```re sig
-let filter: (t('a), 'a => bool) => t('a);
-```
-
-Returns a list of all elements in `someList` which satisfy the predicate function `pred`.
-
-```re example
-let isEven = x => x mod 2 == 0;
-
-Belt.List.filter([1, 2, 3, 4], isEven); /* [2, 4] */
-
-Belt.List.filter([None, Some(2), Some(3), None], Belt.Option.isSome); /* [Some(2), Some(3)] */
-```
-
-## keepWithIndex
-
-```re sig
-let keepWithIndex: (t('a), ('a, int) => bool) => t('a);
-```
-
-Returns a list of all elements in `someList` which satisfy the predicate function `pred`.
-
-```re example
-let isEven = x => x mod 2 == 0;
-
-Belt.List.keepWithIndex([1, 2, 3, 4], (_x, index) => isEven(index)); /* [1, 3] */
-```
-
-## keepWithIndexU
-
-```re sig
-let keepWithIndexU: (t('a), [@bs] (('a, int) => bool)) => t('a);
-```
-
-Uncurried version of [keepWithIndex](#keepWithIndex).
-
-## filterWithIndex
-
-```re sig
-let filterWithIndex: (t('a), ('a, int) => bool) => t('a);
-```
-
-Returns a list of all elements in `someList` which satisfy the predicate function `pred`.
-
-```re example
-let isEven = x => x mod 2 == 0;
-
-Belt.List.filterWithIndex([1, 2, 3, 4], (_x, index) => isEven(index)); /* [1, 3] */
-```
-
-## keepMap
-
-```re sig
-let keepMap: (t('a), 'a => option('b)) => t('b);
-```
-
-Applies `f` to each element of `someList`. If `f(x)` returns `Some(value)`, then `value` is _kept_ in the resulting list.
-If `f(x)` returns `None`, the element is _not_ retained in the result.
-
-```re example
-let isEven = x => x mod 2 == 0;
-
-[1, 2, 3, 4]
-->Belt.List.keepMap(x =>
-    if (isEven(x)) {
-      Some(x);
-    } else {
-      None;
-    }
-  ); /* [2, 4] */
-
-[Some(1), Some(2), None]->Belt.List.keepMap(x => x); /* [1, 2] */
-```
-
-## keepMapU
-
-```re sig
-let keepMapU: (t('a), [@bs] ('a => option('b))) => t('b);
-```
-
-Uncurried version of [keepMap](#keepMap).
-
-## partition
-
-```re sig
-let partition: (t('a), 'a => bool) => (t('a), t('a));
-```
-
-Creates a pair of lists; the first list consists of all elements of `someList` that satisfy the predicate function `pred`; the second list consists of all elements of `someList` that _do not_ satisfy `pred.
-
-In other words:
-
-```
-([elementsThatSatisfies], [elementsThatDoesNotSatisfy]);
-```
-
-```re example
-Belt.List.partition([1, 2, 3, 4], x => x > 2); /* ([3, 4], [1, 2]) */
-```
-
-## partitionU
-
-```re sig
-let partitionU: (t('a), [@bs] ('a => bool)) => (t('a), t('a));
-```
-
-Uncurried version of [partition](#partition).
-
-## unzip
-
-```re sig
-let unzip: t(('a, 'b)) => (t('a), t('b));
-```
-
-Takes a list of pairs and creates a pair of lists. The first list contains all the first items of the pairs; the second list contains all the second items.
-
-```re example
-Belt.List.unzip([(1, 2), (3, 4)]); /* ([1, 3], [2, 4]) */
-
-Belt.List.unzip([("H", "W"), ("e", "o"), ("l", "r"), ("l", "l"), ("o", "d"), (" ", "!")]);
-/* (["H", "e", "l", "l", "o", " "], ["W", "o", "r", "l", "d", "!"]); */
-```
-
-## getAssoc
-
-```re sig
-let getAssoc: (t(('a, 'c)), 'b, ('a, 'b) => bool) => option('c);
-```
-
-Return the second element of a pair in `someList` where the first element equals `k` as per the predicate function `eqFunction`, or `None` if not found.
-
-```re example
-[(1, "a"), (2, "b"), (3, "c")]->Belt.List.getAssoc(3, (==)); /* Some("c") */
-
-[(9, "morning"), (15, "afternoon"), (22, "night")]
-->Belt.List.getAssoc(15, (k, item) => k /* 15 */ == item /* 9, 5, 22 */);
-/* Some("afternoon"); */
-```
-
-## getAssocU
-
-```re sig
-let getAssocU: (t(('a, 'c)), 'b, [@bs] (('a, 'b) => bool)) => option('c);
-```
-
-Uncurried version of [getAssoc](#getAssoc).
-
-## hasAssoc
-
-```re sig
-let hasAssoc: (t(('a, 'c)), 'b, ('a, 'b) => bool) => bool;
-```
-
-Returns `true` if there is a pair in `someList` where the first element equals `k` as per the predicate function `eqFunction`.
-
-```re example
-[(1, "a"), (2, "b"), (3, "c")]->Belt.List.hasAssoc(1, (==)); /* true */
-
-[(9, "morning"), (15, "afternoon"), (22, "night")]
-->Belt.List.hasAssoc(25, (k, item) => k /* 25 */ == item /* 9, 5, 22 */); /* false */
-```
-
-## hasAssocU
-
-```re sig
-let hasAssocU: (t(('a, 'c)), 'b, [@bs] (('a, 'b) => bool)) => bool;
-```
-
-Uncurried version of [hasAssoc](#hasAssoc).
-
-## removeAssoc
-
-```re sig
-let removeAssoc: (t(('a, 'c)), 'b, ('a, 'b) => bool) => t(('a, 'c));
-```
-
-Return a list after removing the first pair whose first value is `k` per the equality predicate `eqFunction`; if not found, return a new list identical to `someList`.
-
-```re example
-[(1, "a"), (2, "b"), (3, "c")]->Belt.List.removeAssoc(1, (==)); /* [(2, "b"), (3, "c")] */
-
-[(9, "morning"), (15, "afternoon"), (22, "night")]
-->Belt.List.removeAssoc(9, (k, item) => k /* 9 */ == item /* 9, 5, 22 */);
-/* [(15, "afternoon"), (22, "night")] */
-```
-
-## removeAssocU
-
-```re sig
-let removeAssocU: (t(('a, 'c)), 'b, [@bs] (('a, 'b) => bool)) => t(('a, 'c));
-```
-
-Uncurried version of [removeAssoc](#removeAssoc).
-
-## setAssoc
-
-```re sig
-let setAssoc: (t(('a, 'c)), 'a, 'c, ('a, 'a) => bool) => t(('a, 'c));
-```
-
-If `k` exists in `someList` by satisfying the `eqFunction` predicate, return a new list with the key and value replaced by the new `k` and `v`; otherwise, return a new list with the pair `k`, `v` added to the head of `someList`.
-
-```re example
-[(1, "a"), (2, "b"), (3, "c")]->Belt.List.setAssoc(2, "x", (==)); /* [(1, "a"), (2, "x"), (3, "c")]; */
-
-[(1, "a"), (3, "c")]->Belt.List.setAssoc(2, "b", (==)); /* [(2, "b"), (1, "a"), (3, "c")] */
-
-[(9, "morning"), (3, "morning?!"), (22, "night")]
-->Belt.List.setAssoc(15, "afternoon", (a, b) => a mod 12 == b mod 12);
-/* [(9, "morning"), (15, "afternoon"), (22, "night")] */
-```
-
-**Please note**
-
-In the last example, since: `15 mod 12` equals `3 mod 12`
-
-Both the key _and_ the value are replaced in the list.
-
-## setAssocU
-
-```re sig
-let setAssocU: (t(('a, 'c)), 'a, 'c, [@bs] (('a, 'a) => bool)) => t(('a, 'c));
-```
-
-Uncurried version of [setAssoc](#setAssoc).
-
-## sort
-
-```re sig
-let sort: (t('a), ('a, 'a) => int) => t('a);
-```
-
-Returns a sorted list.
-
-```re example
-Belt.List.sort([5, 4, 9, 3, 7], (a, b) => a - b); /* [3, 4, 5, 7, 9] */
-```
-
-## sortU
-
-```re sig
-let sortU: (t('a), [@bs] (('a, 'a) => int)) => t('a);
-```
-
-Uncurried version of [sort](#sort).
diff --git a/pages/docs/manual/v8.0.0/api/belt/map-dict.mdx b/pages/docs/manual/v8.0.0/api/belt/map-dict.mdx
deleted file mode 100644
index 030c04f94..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/map-dict.mdx
+++ /dev/null
@@ -1,397 +0,0 @@
-# MapDict
-
-<Intro>
-
-This module seprate identity from data, it is a bit more verboe but slightly more efficient due to the fact that there is no need to pack identity and data back after each operation
-
-**_Advanced usage only_**
-
-</Intro>
-
-## t
-
-```re sig
-type t('key, 'value, 'id);
-```
-
-## cmp
-
-```re sig
-type cmp('key, 'id) = Belt_Id.cmp('key, 'id);
-```
-
-## empty
-
-```re sig
-let empty: t('k, 'v, 'id);
-```
-
-## isEmpty
-
-```re sig
-let isEmpty: t('k, 'v, 'id) => bool;
-```
-
-## has
-
-```re sig
-let has: (t('k, 'a, 'id), 'k, ~cmp: cmp('k, 'id)) => bool;
-```
-
-## cmpU
-
-```re sig
-let cmpU:
-  (t('k, 'v, 'id), t('k, 'v, 'id), ~kcmp: cmp('k, 'id), ~vcmp: [@bs] (('v, 'v) => int)) => int;
-```
-
-## cmp
-
-```re sig
-let cmp: (t('k, 'v, 'id), t('k, 'v, 'id), ~kcmp: cmp('k, 'id), ~vcmp: ('v, 'v) => int) => int;
-```
-
-## eqU
-
-```re sig
-let eqU:
-  (t('k, 'a, 'id), t('k, 'a, 'id), ~kcmp: cmp('k, 'id), ~veq: [@bs] (('a, 'a) => bool)) => bool;
-```
-
-## eq
-
-```re sig
-let eq: (t('k, 'a, 'id), t('k, 'a, 'id), ~kcmp: cmp('k, 'id), ~veq: ('a, 'a) => bool) => bool;
-```
-
-`eq(m1, m2, cmp)` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data. `cmp` is the equality predicate used to compare the data associated with the keys.
-
-## findFirstByU
-
-```re sig
-let findFirstByU: (t('k, 'v, 'id), [@bs] (('k, 'v) => bool)) => option(('k, 'v));
-```
-
-## findFirstBy
-
-```re sig
-let findFirstBy: (t('k, 'v, 'id), ('k, 'v) => bool) => option(('k, 'v));
-```
-
-`findFirstBy(m, p)` uses function `f` to find the first key value pair to match predicate `p`.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Map.Dict.fromArray([|(4, "4"), (1, "1"), (2, "2"), (3, "3")|], ~cmp=IntCmp.cmp);
-
-Belt.Map.Dict.findFirstBy(s0, (k, _) => k == 4) == Some((4, "4"));
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t('k, 'a, 'id), [@bs] (('k, 'a) => unit)) => unit;
-```
-
-## forEach
-
-```re sig
-let forEach: (t('k, 'a, 'id), ('k, 'a) => unit) => unit;
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the key as first argument, and the associated value as second argument. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## reduceU
-
-```re sig
-let reduceU: (t('k, 'a, 'id), 'b, [@bs] (('b, 'k, 'a) => 'b)) => 'b;
-```
-
-## reduce
-
-```re sig
-let reduce: (t('k, 'a, 'id), 'b, ('b, 'k, 'a) => 'b) => 'b;
-```
-
-`reduce(m, a, f)` computes `f(kN, dN ... f(k1, d1, a)...)`, where `k1 ... kN` are the keys of all bindings in `m` (in increasing order), and `d1 ... dN` are the associated data.
-
-## everyU
-
-```re sig
-let everyU: (t('k, 'a, 'id), [@bs] (('k, 'a) => bool)) => bool;
-```
-
-## every
-
-```re sig
-let every: (t('k, 'a, 'id), ('k, 'a) => bool) => bool;
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. Order unspecified
-
-## someU
-
-```re sig
-let someU: (t('k, 'a, 'id), [@bs] (('k, 'a) => bool)) => bool;
-```
-
-## some
-
-```re sig
-let some: (t('k, 'a, 'id), ('k, 'a) => bool) => bool;
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. Order unspecified
-
-## size
-
-```re sig
-let size: t('k, 'a, 'id) => int;
-```
-
-## toList
-
-```re sig
-let toList: t('k, 'a, 'id) => list(('k, 'a));
-```
-
-In increasing order.
-
-## toArray
-
-```re sig
-let toArray: t('k, 'a, 'id) => array(('k, 'a));
-```
-
-## fromArray
-
-```re sig
-let fromArray: (array(('k, 'a)), ~cmp: cmp('k, 'id)) => t('k, 'a, 'id);
-```
-
-## keysToArray
-
-```re sig
-let keysToArray: t('k, 'a, 'id) => array('k);
-```
-
-## valuesToArray
-
-```re sig
-let valuesToArray: t('k, 'a, 'id) => array('a);
-```
-
-## minKey
-
-```re sig
-let minKey: t('k, 'a, 'b) => option('k);
-```
-
-## minKeyUndefined
-
-```re sig
-let minKeyUndefined: t('k, 'a, 'b) => Js.undefined('k);
-```
-
-## maxKey
-
-```re sig
-let maxKey: t('k, 'a, 'b) => option('k);
-```
-
-## maxKeyUndefined
-
-```re sig
-let maxKeyUndefined: t('k, 'a, 'b) => Js.undefined('k);
-```
-
-## minimum
-
-```re sig
-let minimum: t('k, 'a, 'b) => option(('k, 'a));
-```
-
-## minUndefined
-
-```re sig
-let minUndefined: t('k, 'a, 'b) => Js.undefined(('k, 'a));
-```
-
-## maximum
-
-```re sig
-let maximum: t('k, 'a, 'b) => option(('k, 'a));
-```
-
-## maxUndefined
-
-```re sig
-let maxUndefined: t('k, 'a, 'b) => Js.undefined(('k, 'a));
-```
-
-## get
-
-```re sig
-let get: (t('k, 'a, 'id), 'k, ~cmp: cmp('k, 'id)) => option('a);
-```
-
-## getUndefined
-
-```re sig
-let getUndefined: (t('k, 'a, 'id), 'k, ~cmp: cmp('k, 'id)) => Js.undefined('a);
-```
-
-## getWithDefault
-
-```re sig
-let getWithDefault: (t('k, 'a, 'id), 'k, 'a, ~cmp: cmp('k, 'id)) => 'a;
-```
-
-## getExn
-
-```re sig
-let getExn: (t('k, 'a, 'id), 'k, ~cmp: cmp('k, 'id)) => 'a;
-```
-
-## checkInvariantInternal
-
-```re sig
-let checkInvariantInternal: t('a, 'b, 'c) => unit;
-```
-
-## remove
-
-```re sig
-let remove: (t('a, 'b, 'id), 'a, ~cmp: cmp('a, 'id)) => t('a, 'b, 'id);
-```
-
-`remove(m, x)` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
-
-## removeMany
-
-```re sig
-let removeMany: (t('a, 'b, 'id), array('a), ~cmp: cmp('a, 'id)) => t('a, 'b, 'id);
-```
-
-## set
-
-```re sig
-let set: (t('a, 'b, 'id), 'a, 'b, ~cmp: cmp('a, 'id)) => t('a, 'b, 'id);
-```
-
-`set(m, x, y)` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`. If `x` was already bound in `m`, its previous binding disappears.
-
-## updateU
-
-```re sig
-let updateU:
-  (t('a, 'b, 'id), 'a, [@bs] (option('b) => option('b)), ~cmp: cmp('a, 'id)) => t('a, 'b, 'id);
-```
-
-## update
-
-```re sig
-let update: (t('a, 'b, 'id), 'a, option('b) => option('b), ~cmp: cmp('a, 'id)) => t('a, 'b, 'id);
-```
-
-## mergeU
-
-```re sig
-let mergeU:
-  (
-    t('a, 'b, 'id),
-    t('a, 'c, 'id),
-    [@bs] (('a, option('b), option('c)) => option('d)),
-    ~cmp: cmp('a, 'id)
-  ) =>
-  t('a, 'd, 'id);
-```
-
-## merge
-
-```re sig
-let merge:
-  (
-    t('a, 'b, 'id),
-    t('a, 'c, 'id),
-    ('a, option('b), option('c)) => option('d),
-    ~cmp: cmp('a, 'id)
-  ) =>
-  t('a, 'd, 'id);
-```
-
-`merge(m1, m2, f)` computes a map whose keys is a subset of keys of `m1` and of `m2`. The presence of each such binding, and the corresponding value, is determined with the function `f`.
-
-## mergeMany
-
-```re sig
-let mergeMany: (t('a, 'b, 'id), array(('a, 'b)), ~cmp: cmp('a, 'id)) => t('a, 'b, 'id);
-```
-
-## keepU
-
-```re sig
-let keepU: (t('k, 'a, 'id), [@bs] (('k, 'a) => bool)) => t('k, 'a, 'id);
-```
-
-## keep
-
-```re sig
-let keep: (t('k, 'a, 'id), ('k, 'a) => bool) => t('k, 'a, 'id);
-```
-
-`keep(m, p)` returns the map with all the bindings in `m` that satisfy predicate `p`.
-
-## partitionU
-
-```re sig
-let partitionU: (t('k, 'a, 'id), [@bs] (('k, 'a) => bool)) => (t('k, 'a, 'id), t('k, 'a, 'id));
-```
-
-## partition
-
-```re sig
-let partition: (t('k, 'a, 'id), ('k, 'a) => bool) => (t('k, 'a, 'id), t('k, 'a, 'id));
-```
-
-`partition(m, p)` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `s` that satisfy the predicate `p`, and `m2` is the map with all the bindings of `s` that do not satisfy `p`.
-
-## split
-
-```re sig
-let split:
-  (t('a, 'b, 'id), 'a, ~cmp: cmp('a, 'id)) => ((t('a, 'b, 'id), t('a, 'b, 'id)), option('b));
-```
-
-`split(x, m)` returns a triple `(l, data, r)`, where `l` is the map with all the bindings of `m` whose key is strictly less than `x`; `r` is the map with all the bindings of `m` whose key is strictly greater than `x`; `data` is `None` if `m` contains no binding for `x`, or `Some(v)` if `m` binds `v` to `x`.
-
-## mapU
-
-```re sig
-let mapU: (t('k, 'a, 'id), [@bs] ('a => 'b)) => t('k, 'b, 'id);
-```
-
-## map
-
-```re sig
-let map: (t('k, 'a, 'id), 'a => 'b) => t('k, 'b, 'id);
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value `a` of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```re sig
-let mapWithKeyU: (t('k, 'a, 'id), [@bs] (('k, 'a) => 'b)) => t('k, 'b, 'id);
-```
-
-## mapWithKey
-
-```re sig
-let mapWithKey: (t('k, 'a, 'id), ('k, 'a) => 'b) => t('k, 'b, 'id);
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/map-int.mdx b/pages/docs/manual/v8.0.0/api/belt/map-int.mdx
deleted file mode 100644
index 1998e7b24..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/map-int.mdx
+++ /dev/null
@@ -1,373 +0,0 @@
-# MapInt
-
-<Intro>
-
-Specalized when key type is `int`, more efficient than the generic type, its compare behavior is fixed using the built-in comparison
-
-</Intro>
-
-## key
-
-```re sig
-type key = int;
-```
-
-## t
-
-```re sig
-type t('value);
-```
-
-The type of maps from type `key` to type `'value`.
-
-## empty
-
-```re sig
-let empty: t('v);
-```
-
-## isEmpty
-
-```re sig
-let isEmpty: t('v) => bool;
-```
-
-## has
-
-```re sig
-let has: (t('v), key) => bool;
-```
-
-## cmpU
-
-```re sig
-let cmpU: (t('v), t('v), [@bs] (('v, 'v) => int)) => int;
-```
-
-## cmp
-
-```re sig
-let cmp: (t('v), t('v), ('v, 'v) => int) => int;
-```
-
-## eqU
-
-```re sig
-let eqU: (t('v), t('v), [@bs] (('v, 'v) => bool)) => bool;
-```
-
-## eq
-
-```re sig
-let eq: (t('v), t('v), ('v, 'v) => bool) => bool;
-```
-
-`eq(m1,m2)` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data.
-
-## findFirstByU
-
-```re sig
-let findFirstByU: (t('v), [@bs] ((key, 'v) => bool)) => option((key, 'v));
-```
-
-## findFirstBy
-
-```re sig
-let findFirstBy: (t('v), (key, 'v) => bool) => option((key, 'v));
-```
-
-`findFirstBy(m, p)` uses function `f` to find the first key value pair to match predicate `p`.
-
-```re example
-let s0 = Belt.Map.Int.fromArray([|(4, "4"), (1, "1"), (2, "2"), (3, "3")|]);
-
-Belt.Map.Int.findFirstBy(s0, (k, v) => k == 4) == Some((4, "4"));
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t('v), [@bs] ((key, 'v) => unit)) => unit;
-```
-
-## forEach
-
-```re sig
-let forEach: (t('v), (key, 'v) => unit) => unit;
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the key as first argument, and the associated value as second argument. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## reduceU
-
-```re sig
-let reduceU: (t('v), 'v2, [@bs] (('v2, key, 'v) => 'v2)) => 'v2;
-```
-
-## reduce
-
-```re sig
-let reduce: (t('v), 'v2, ('v2, key, 'v) => 'v2) => 'v2;
-```
-
-`reduce(m, a, f)` computes `f(kN, dN, ... f(k1, d1, a)...)`, where `k1 ... kN` are the keys of all bindings in `m` (in increasing order), and `d1 ... dN` are the associated data.
-
-## everyU
-
-```re sig
-let everyU: (t('v), [@bs] ((key, 'v) => bool)) => bool;
-```
-
-## every
-
-```re sig
-let every: (t('v), (key, 'v) => bool) => bool;
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. Order unspecified
-
-## someU
-
-```re sig
-let someU: (t('v), [@bs] ((key, 'v) => bool)) => bool;
-```
-
-## some
-
-```re sig
-let some: (t('v), (key, 'v) => bool) => bool;
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. Order unspecified
-
-## size
-
-```re sig
-let size: t('v) => int;
-```
-
-## toList
-
-```re sig
-let toList: t('v) => list((key, 'v));
-```
-
-In increasing order.
-
-## toArray
-
-```re sig
-let toArray: t('v) => array((key, 'v));
-```
-
-## fromArray
-
-```re sig
-let fromArray: array((key, 'v)) => t('v);
-```
-
-## keysToArray
-
-```re sig
-let keysToArray: t('v) => array(key);
-```
-
-## valuesToArray
-
-```re sig
-let valuesToArray: t('v) => array('v);
-```
-
-## minKey
-
-```re sig
-let minKey: t('a) => option(key);
-```
-
-## minKeyUndefined
-
-```re sig
-let minKeyUndefined: t('a) => Js.undefined(key);
-```
-
-## maxKey
-
-```re sig
-let maxKey: t('a) => option(key);
-```
-
-## maxKeyUndefined
-
-```re sig
-let maxKeyUndefined: t('a) => Js.undefined(key);
-```
-
-## minimum
-
-```re sig
-let minimum: t('v) => option((key, 'v));
-```
-
-## minUndefined
-
-```re sig
-let minUndefined: t('v) => Js.undefined((key, 'v));
-```
-
-## maximum
-
-```re sig
-let maximum: t('v) => option((key, 'v));
-```
-
-## maxUndefined
-
-```re sig
-let maxUndefined: t('v) => Js.undefined((key, 'v));
-```
-
-## get
-
-```re sig
-let get: (t('v), key) => option('v);
-```
-
-## getUndefined
-
-```re sig
-let getUndefined: (t('v), key) => Js.undefined('v);
-```
-
-## getWithDefault
-
-```re sig
-let getWithDefault: (t('v), key, 'v) => 'v;
-```
-
-## getExn
-
-```re sig
-let getExn: (t('v), key) => 'v;
-```
-
-## checkInvariantInternal
-
-```re sig
-let checkInvariantInternal: t('a) => unit;
-```
-
-**raise** when invariant is not held
-
-## remove
-
-```re sig
-let remove: (t('v), key) => t('v);
-```
-
-`remove(m, x)` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
-
-## removeMany
-
-```re sig
-let removeMany: (t('v), array(key)) => t('v);
-```
-
-## set
-
-```re sig
-let set: (t('v), key, 'v) => t('v);
-```
-
-`set(m, x, y)` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`. If `x` was already bound in `m`, its previous binding disappears.
-
-## updateU
-
-```re sig
-let updateU: (t('v), key, [@bs] (option('v) => option('v))) => t('v);
-```
-
-## update
-
-```re sig
-let update: (t('v), key, option('v) => option('v)) => t('v);
-```
-
-## mergeU
-
-```re sig
-let mergeU: (t('v), t('v2), [@bs] ((key, option('v), option('v2)) => option('c))) => t('c);
-```
-
-## merge
-
-```re sig
-let merge: (t('v), t('v2), (key, option('v), option('v2)) => option('c)) => t('c);
-```
-
-`merge(m1, m2, f)` computes a map whose keys is a subset of keys of `m1` and of `m2`. The presence of each such binding, and the corresponding value, is determined with the function `f`.
-
-## mergeMany
-
-```re sig
-let mergeMany: (t('v), array((key, 'v))) => t('v);
-```
-
-## keepU
-
-```re sig
-let keepU: (t('v), [@bs] ((key, 'v) => bool)) => t('v);
-```
-
-## keep
-
-```re sig
-let keep: (t('v), (key, 'v) => bool) => t('v);
-```
-
-## partitionU
-
-```re sig
-let partitionU: (t('v), [@bs] ((key, 'v) => bool)) => (t('v), t('v));
-```
-
-## partition
-
-```re sig
-let partition: (t('v), (key, 'v) => bool) => (t('v), t('v));
-```
-
-`partition(m, p)` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `s` that satisfy the predicate `p`, and `m2` is the map with all the bindings of `s` that do not satisfy `p`.
-
-## split
-
-```re sig
-let split: (key, t('v)) => (t('v), option('v), t('v));
-```
-
-`split(x, m)` returns a triple `(l, data, r)`, where `l` is the map with all the bindings of `m` whose key is strictly less than `x`; `r` is the map with all the bindings of `m` whose key is strictly greater than `x`; `data` is `None` if m contains no binding for `x`, or `Some(v)` if `m` binds `v` to `x`.
-
-## mapU
-
-```re sig
-let mapU: (t('v), [@bs] ('v => 'v2)) => t('v2);
-```
-
-## map
-
-```re sig
-let map: (t('v), 'v => 'v2) => t('v2);
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value `a` of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```re sig
-let mapWithKeyU: (t('v), [@bs] ((key, 'v) => 'v2)) => t('v2);
-```
-
-## mapWithKey
-
-```re sig
-let mapWithKey: (t('v), (key, 'v) => 'v2) => t('v2);
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/map-string.mdx b/pages/docs/manual/v8.0.0/api/belt/map-string.mdx
deleted file mode 100644
index ee0cae32f..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/map-string.mdx
+++ /dev/null
@@ -1,375 +0,0 @@
-# MapString
-
-<Intro>
-
-Specalized when key type is `string`, more efficient than the generic type, its compare behavior is fixed using the built-in comparison
-
-</Intro>
-
-## key
-
-```re sig
-type key = string;
-```
-
-## t
-
-```re sig
-type t('value);
-```
-
-The type of maps from type `key` to type `'value`.
-
-## empty
-
-```re sig
-let empty: t('v);
-```
-
-## isEmpty
-
-```re sig
-let isEmpty: t('v) => bool;
-```
-
-## has
-
-```re sig
-let has: (t('v), key) => bool;
-```
-
-## cmpU
-
-```re sig
-let cmpU: (t('v), t('v), [@bs] (('v, 'v) => int)) => int;
-```
-
-## cmp
-
-```re sig
-let cmp: (t('v), t('v), ('v, 'v) => int) => int;
-```
-
-## eqU
-
-```re sig
-let eqU: (t('v), t('v), [@bs] (('v, 'v) => bool)) => bool;
-```
-
-## eq
-
-```re sig
-let eq: (t('v), t('v), ('v, 'v) => bool) => bool;
-```
-
-`eq(m1, m2)` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data.
-
-## findFirstByU
-
-```re sig
-let findFirstByU: (t('v), [@bs] ((key, 'v) => bool)) => option((key, 'v));
-```
-
-## findFirstBy
-
-```re sig
-let findFirstBy: (t('v), (key, 'v) => bool) => option((key, 'v));
-```
-
-`findFirstBy(m, p)` uses function `f` to find the first key value pair to match predicate `p`.
-
-```re example
-let s0 = Belt.Map.String.fromArray([|("4", 4), ("1", 1), ("2", 2), ("3", 3)|]);
-
-Belt.Map.String.findFirstBy(s0, (k, _) => k == "4") == Some(("4", 4));
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t('v), [@bs] ((key, 'v) => unit)) => unit;
-```
-
-## forEach
-
-```re sig
-let forEach: (t('v), (key, 'v) => unit) => unit;
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the key as first argument, and the associated value as second argument. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## reduceU
-
-```re sig
-let reduceU: (t('v), 'v2, [@bs] (('v2, key, 'v) => 'v2)) => 'v2;
-```
-
-## reduce
-
-```re sig
-let reduce: (t('v), 'v2, ('v2, key, 'v) => 'v2) => 'v2;
-```
-
-`reduce(m, a, f)` computes `f(kN, dN ... f(k1, d1, a)...), where k1 ... kN)` are the keys of all bindings in `m` (in increasing order), and `d1 ... dN` are the associated data.
-
-## everyU
-
-```re sig
-let everyU: (t('v), [@bs] ((key, 'v) => bool)) => bool;
-```
-
-## every
-
-```re sig
-let every: (t('v), (key, 'v) => bool) => bool;
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. Order unspecified
-
-## someU
-
-```re sig
-let someU: (t('v), [@bs] ((key, 'v) => bool)) => bool;
-```
-
-## some
-
-```re sig
-let some: (t('v), (key, 'v) => bool) => bool;
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. Order unspecified
-
-## size
-
-```re sig
-let size: t('v) => int;
-```
-
-## toList
-
-```re sig
-let toList: t('v) => list((key, 'v));
-```
-
-In increasing order.
-
-## toArray
-
-```re sig
-let toArray: t('v) => array((key, 'v));
-```
-
-## fromArray
-
-```re sig
-let fromArray: array((key, 'v)) => t('v);
-```
-
-## keysToArray
-
-```re sig
-let keysToArray: t('v) => array(key);
-```
-
-## valuesToArray
-
-```re sig
-let valuesToArray: t('v) => array('v);
-```
-
-## minKey
-
-```re sig
-let minKey: t('a) => option(key);
-```
-
-## minKeyUndefined
-
-```re sig
-let minKeyUndefined: t('a) => Js.undefined(key);
-```
-
-## maxKey
-
-```re sig
-let maxKey: t('a) => option(key);
-```
-
-## maxKeyUndefined
-
-```re sig
-let maxKeyUndefined: t('a) => Js.undefined(key);
-```
-
-## minimum
-
-```re sig
-let minimum: t('v) => option((key, 'v));
-```
-
-## minUndefined
-
-```re sig
-let minUndefined: t('v) => Js.undefined((key, 'v));
-```
-
-## maximum
-
-```re sig
-let maximum: t('v) => option((key, 'v));
-```
-
-## maxUndefined
-
-```re sig
-let maxUndefined: t('v) => Js.undefined((key, 'v));
-```
-
-## get
-
-```re sig
-let get: (t('v), key) => option('v);
-```
-
-## getUndefined
-
-```re sig
-let getUndefined: (t('v), key) => Js.undefined('v);
-```
-
-## getWithDefault
-
-```re sig
-let getWithDefault: (t('v), key, 'v) => 'v;
-```
-
-## getExn
-
-```re sig
-let getExn: (t('v), key) => 'v;
-```
-
-## checkInvariantInternal
-
-```re sig
-let checkInvariantInternal: t('a) => unit;
-```
-
-**raise** when invariant is not held
-
-## remove
-
-```re sig
-let remove: (t('v), key) => t('v);
-```
-
-`remove(m, x)` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
-
-## removeMany
-
-```re sig
-let removeMany: (t('v), array(key)) => t('v);
-```
-
-## set
-
-```re sig
-let set: (t('v), key, 'v) => t('v);
-```
-
-`set(m, x, y)` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`. If `x` was already bound in `m`, its previous binding disappears.
-
-## updateU
-
-```re sig
-let updateU: (t('v), key, [@bs] (option('v) => option('v))) => t('v);
-```
-
-## update
-
-```re sig
-let update: (t('v), key, option('v) => option('v)) => t('v);
-```
-
-## mergeU
-
-```re sig
-let mergeU: (t('v), t('v2), [@bs] ((key, option('v), option('v2)) => option('c))) => t('c);
-```
-
-## merge
-
-```re sig
-let merge: (t('v), t('v2), (key, option('v), option('v2)) => option('c)) => t('c);
-```
-
-`merge(m1, m2, f)` computes a map whose keys is a subset of keys of `m1` and of `m2`. The presence of each such binding, and the corresponding value, is determined with the function `f`.
-
-## mergeMany
-
-```re sig
-let mergeMany: (t('v), array((key, 'v))) => t('v);
-```
-
-## keepU
-
-```re sig
-let keepU: (t('v), [@bs] ((key, 'v) => bool)) => t('v);
-```
-
-## keep
-
-```re sig
-let keep: (t('v), (key, 'v) => bool) => t('v);
-```
-
-`keep(m, p)` returns the map with all the bindings in `m` that satisfy predicate `p`.
-
-## partitionU
-
-```re sig
-let partitionU: (t('v), [@bs] ((key, 'v) => bool)) => (t('v), t('v));
-```
-
-## partition
-
-```re sig
-let partition: (t('v), (key, 'v) => bool) => (t('v), t('v));
-```
-
-`partition(m, p)` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `s` that satisfy the predicate `p`, and `m2` is the map with all the bindings of s that do not satisfy `p`.
-
-## split
-
-```re sig
-let split: (key, t('v)) => (t('v), option('v), t('v));
-```
-
-`split(x, m)` returns a triple `(l, data, r)`, where `l` is the map with all the bindings of `m` whose key is strictly less than `x`; `r` is the map with all the bindings of m whose key is strictly greater than `x`; `data` is `None` if `m` contains no binding for `x`, or `Some(v)` if `m` binds `v` to `x`.
-
-## mapU
-
-```re sig
-let mapU: (t('v), [@bs] ('v => 'v2)) => t('v2);
-```
-
-## map
-
-```re sig
-let map: (t('v), 'v => 'v2) => t('v2);
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value `a` of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```re sig
-let mapWithKeyU: (t('v), [@bs] ((key, 'v) => 'v2)) => t('v2);
-```
-
-## mapWithKey
-
-```re sig
-let mapWithKey: (t('v), (key, 'v) => 'v2) => t('v2);
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/map.mdx b/pages/docs/manual/v8.0.0/api/belt/map.mdx
deleted file mode 100644
index e3c60653b..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/map.mdx
+++ /dev/null
@@ -1,643 +0,0 @@
-# Map
-
-The top level provides generic immutable map operations.
-
-It also has three specialized inner modules `Belt.Map.Int`, `Belt.Map.String` and `Belt.Map.Dict`.
-
-## t
-
-```re sig
-type t('key, 'value, 'identity);
-```
-
-`'key` is the field type
-
-`'value` is the element type
-
-`'identity` the identity of the collection
-
-## id
-
-```re sig
-type id('key, 'id) = Belt_Id.comparable('key, 'id);
-```
-
-The identity needed for making an empty map.
-
-## make
-
-```re sig
-let make: (~id: id('k, 'id)) => t('k, 'v, 'id);
-```
-
-`make(~id)` creates a new map by taking in the comparator.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = (a, b) => Pervasives.compare(a, b);
-  });
-
-let m = Belt.Map.make(~id=(module IntCmp));
-
-Belt.Map.set(m, 0, "a");
-```
-
-## isEmpty
-
-```re sig
-let isEmpty: t('a, 'b, 'c) => bool;
-```
-
-`isEmpty(m)` checks whether a map m is empty.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = (a, b) => Pervasives.compare(a, b);
-  });
-  
-Belt.Map.isEmpty(Belt.Map.fromArray([|(1, "1")|], ~id=(module IntCmp))) == false;
-```
-
-## has
-
-```re sig
-let has: (t('k, 'v, 'id), 'k) => bool;
-```
-
-`has(m, k)` checks whether `m` has the key `k`.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = (a, b) => Pervasives.compare(a, b);
-  });
-
-Belt.Map.has(Belt.Map.fromArray([|(1, "1")|], ~id=(module IntCmp)), 1) == true;
-```
-
-## cmpU
-
-```re sig
-let cmpU: (t('k, 'v, 'id), t('k, 'v, 'id), [@bs] (('v, 'v) => int)) => int;
-```
-
-## cmp
-
-```re sig
-let cmp: (t('k, 'v, 'id), t('k, 'v, 'id), ('v, 'v) => int) => int;
-```
-
-`cmp(m0, m1, vcmp);`
-
-Total ordering of map given total ordering of value function.
-
-It will compare size first and each element following the order one by one.
-
-## eq
-
-```re sig
-let eqU: (t('k, 'v, 'id), t('k, 'v, 'id), [@bs] (('v, 'v) => bool)) => bool;
-```
-
-`eq(m1, m2, veq)` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data. `veq` is the equality predicate used to compare the data associated with the keys.
-
-## eq
-
-```re sig
-let eq: (t('k, 'v, 'id), t('k, 'v, 'id), ('v, 'v) => bool) => bool;
-```
-
-## findFirstByU
-
-```re sig
-let findFirstByU: (t('k, 'v, 'id), [@bs] (('k, 'v) => bool)) => option(('k, 'v));
-```
-
-## findFirstBy
-
-```re sig
-let findFirstBy: (t('k, 'v, 'id), ('k, 'v) => bool) => option(('k, 'v));
-```
-
-`findFirstBy(m, p)` uses function `f` to find the first key value pair to match predicate `p`.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = (a, b) => Pervasives.compare(a, b);
-  });
-
-let s0 = Belt.Map.fromArray(~id=(module IntCmp), [|(4, "4"), (1, "1"), (2, "2"), (3, "")|]);
-
-Belt.Map.findFirstBy(s0, (k, v) => k == 4); /* (4, "4") */
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t('k, 'v, 'id), [@bs] (('k, 'v) => unit)) => unit;
-```
-
-## forEach
-
-```re sig
-let forEach: (t('k, 'v, 'id), ('k, 'v) => unit) => unit;
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the `'k` as first argument, and the associated value as second argument. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = (a, b) => Pervasives.compare(a, b);
-  });
-
-let s0 = Belt.Map.fromArray(~id=(module IntCmp), [|(4, "4"), (1, "1"), (2, "2"), (3, "")|]);
-
-let acc = ref([]);
-
-Belt.Map.forEach(s0, (k, v) => acc := [(k, v), ...acc^]);
-
-acc^ == [(4, "4"), (3, "3"), (2, "2"), (1, "1")];
-```
-
-## reduceU
-
-```re sig
-let reduceU: (t('k, 'v, 'id), 'acc, [@bs] (('acc, 'k, 'v) => 'acc)) => 'acc;
-```
-
-## reduce
-
-```re sig
-let reduce: (t('k, 'v, 'id), 'acc, ('acc, 'k, 'v) => 'acc) => 'acc;
-```
-
-`reduce(m, a, f)` computes `(f(kN, dN) ... (f(k1, d1, a))...)`, where `k1 ... kN` are the keys of all bindings in m (in increasing order), and `d1 ... dN` are the associated data.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = (a, b) => Pervasives.compare(a, b);
-  });
-
-let s0 = Belt.Map.fromArray(~id=(module IntCmp), [|(4, "4"), (1, "1"), (2, "2"), (3, "3")|]);
-
-Belt.Map.reduce(s0, [], (acc, k, v) => [(k, v), ...acc]); /* [(4, "4"), (3, "3"), (2, "2"), (1, "1"), 0] */
-```
-
-## everyU
-
-```re sig
-let everyU: (t('k, 'v, 'id), [@bs] (('k, 'v) => bool)) => bool;
-```
-
-## every
-
-```re sig
-let every: (t('k, 'v, 'id), ('k, 'v) => bool) => bool;
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. Order unspecified
-
-## someU
-
-```re sig
-let someU: (t('k, 'v, 'id), [@bs] (('k, 'v) => bool)) => bool;
-```
-
-## some
-
-```re sig
-let some: (t('k, 'v, 'id), ('k, 'v) => bool) => bool;
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. Order unspecified
-
-## size
-
-```re sig
-let size: t('k, 'v, 'id) => int;
-```
-
-`size(s)`
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = (a, b) => Pervasives.compare(a, b);
-  });
-
-Belt.Map.size(Belt.Map.fromArray([|(2, "2"), (2, "1"), (3, "3")|], ~id=(module IntCmp))) == 2;
-```
-
-## toArray
-
-```re sig
-let toArray: t('k, 'v, 'id) => array(('k, 'v));
-```
-
-`toArray(s)`
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = (a, b) => Pervasives.compare(a, b);
-  });
-
-Belt.Map.toArray(Belt.Map.fromArray([|(2, "2"), (1, "1"), (3, "3")|], ~id=(module IntCmp)))
-== [|(1, "1"), (2, "2"), (3, "3")|];
-```
-
-## toList
-
-```re sig
-let toList: t('k, 'v, 'id) => list(('k, 'v));
-```
-
-In increasing order.
-
-See `Belt.Map.toArray`
-
-## fromArray
-
-```re sig
-let fromArray: (array(('k, 'v)), ~id: id('k, 'id)) => t('k, 'v, 'id);
-```
-
-`fromArray(kvs, ~id);`
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = (a, b) => Pervasives.compare(a, b);
-  });
-
-Belt.Map.toArray(Belt.Map.fromArray([|(2, "2"), (1, "1"), (3, "3")|], ~id=(module IntCmp)))
-== [|(1, "1"), (2, "2"), (3, "3")|];
-```
-
-## keysToArray
-
-```re sig
-let keysToArray: t('k, 'v, 'id) => array('k);
-```
-
-`keysToArray(s);`
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = (a, b) => Pervasives.compare(a, b);
-  });
-
-Belt.Map.keysToArray(Belt.Map.fromArray([|(2, "2"), (1, "1"), (3, "3")|], ~id=(module IntCmp))) == [|1, 2, 3|];
-```
-
-## valuesToArray
-
-```re sig
-let valuesToArray: t('k, 'v, 'id) => array('v);
-```
-
-`valuesToArray(s);`
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = (a, b) => Pervasives.compare(a, b);
-  });
-
-Belt.Map.valuesToArray(Belt.Map.fromArray([|(2, "2"), (1, "1"), (3, "3")|], ~id=(module IntCmp))) == [|"1", "2", "3"|];
-```
-
-## minKey
-
-```re sig
-let minKey: t('k, 'a, 'b) => option('k);
-```
-
-`minKey(s)` returns the minimum key, None if not exist.
-
-## minKeyUndefined
-
-```re sig
-let minKeyUndefined: t('k, 'a, 'b) => Js.undefined('k);
-```
-
-See `Belt.Map.minKey`
-
-## maxKey
-
-```re sig
-let maxKey: t('k, 'a, 'b) => option('k);
-```
-
-`maxKey(s)` returns the maximum key, None if not exist.
-
-## maxKeyUndefined
-
-```re sig
-let maxKeyUndefined: t('k, 'a, 'b) => Js.undefined('k);
-```
-
-See `Belt.Map.maxKey`
-
-## minimum
-
-```re sig
-let minimum: t('k, 'v, 'a) => option(('k, 'v));
-```
-
-`minimum(s)` returns the minimum key value pair, None if not exist
-
-## minUndefined
-
-```re sig
-let minUndefined: t('k, 'v, 'a) => Js.undefined(('k, 'v));
-```
-
-See `Belt.Map.minimum`
-
-## maximum
-
-```re sig
-let maximum: t('k, 'v, 'a) => option(('k, 'v));
-```
-
-`maximum(s)` returns the maximum key value pair, None if not exist.
-
-## maxUndefined
-
-```re sig
-let maxUndefined: t('k, 'v, 'a) => Js.undefined(('k, 'v));
-```
-
-See `Belt.Map.maximum`
-
-## get
-
-```re sig
-let get: (t('k, 'v, 'id), 'k) => option('v);
-```
-
-`get(s, k)`
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = (a, b) => Pervasives.compare(a, b);
-  });
-
-Belt.Map.get(Belt.Map.fromArray([|(2, "2"), (1, "1"), (3, "3")|], ~id=(module IntCmp)), 2) == Some("2");
-
-Belt.Map.get(Belt.Map.fromArray([|(2, "2"), (1, "1"), (3, "3")|], ~id=(module IntCmp)), 2) == None;
-```
-
-## getUndefined
-
-```re sig
-let getUndefined: (t('k, 'v, 'id), 'k) => Js.undefined('v);
-```
-
-See `Belt.Map.get`
-
-Returns `undefined` when not found
-
-## getWithDefault
-
-```re sig
-let getWithDefault: (t('k, 'v, 'id), 'k, 'v) => 'v;
-```
-
-`getWithDefault(s, k, default)`
-
-See `Belt.Map.get`
-
-Returns default when `k` is not found.
-
-## getExn
-
-```re sig
-let getExn: (t('k, 'v, 'id), 'k) => 'v;
-```
-
-`getExn(s, k)`
-
-See `Belt.Map.getExn`
-
-raise when `k` not exist
-
-## remove
-
-```re sig
-let remove: (t('k, 'v, 'id), 'k) => t('k, 'v, 'id);
-```
-
-`remove(m, x)` when `x` is not in `m`, `m` is returned reference unchanged.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = (a, b) => Pervasives.compare(a, b);
-  });
-
-let s0 = Belt.Map.fromArray([|(2, "2"), (1, "1"), (3, "3")|], ~id=(module IntCmp));
-
-let s1 = Belt.Map.remove(s0, 1);
-
-let s2 = Belt.Map.remove(s1, 1);
-
-s1 === s2;
-
-Belt.Map.keysToArray(s1) == [|2, 3|];
-```
-
-## removeMany
-
-```re sig
-let removeMany: (t('k, 'v, 'id), array('k)) => t('k, 'v, 'id);
-```
-
-`removeMany(s, xs)`
-
-Removing each of `xs` to `s`, note unlike `Belt.Map.remove`, the reference of return value might be changed even if none in `xs` exists `s`.
-
-## set
-
-```re sig
-let set: (t('k, 'v, 'id), 'k, 'v) => t('k, 'v, 'id);
-```
-
-`set(m, x, y)` returns a map containing the same bindings as `m`, with a new binding of `x` to `y`. If `x` was already bound in `m`, its previous binding disappears.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = (a, b) => Pervasives.compare(a, b);
-  });
-  
-let s0 = Belt.Map.fromArray([|(2, "2"), (1, "1"), (3, "3")|], ~id=(module IntCmp));
-
-let s1 = Belt.Map.set(s0, 2, "3");
-
-Belt.Map.valuesToArray(s1) == [|"1", "3", "3"|];
-```
-
-## updateU
-
-```re sig
-let updateU: (t('k, 'v, 'id), 'k, [@bs] (option('v) => option('v))) => t('k, 'v, 'id);
-```
-
-## update
-
-```re sig
-let update: (t('k, 'v, 'id), 'k, option('v) => option('v)) => t('k, 'v, 'id);
-```
-
-`update(m, x, f)` returns a map containing the same bindings as `m`, except for the binding of `x`. Depending on the value of `y` where `y` is `f(get(x, m))`, the binding of `x` is added, removed or updated. If `y` is `None`, the binding is removed if it exists; otherwise, if `y` is `Some(z)` then `x` is associated to `z` in the resulting map.
-
-## mergeMany
-
-```re sig
-let mergeMany: (t('k, 'v, 'id), array(('k, 'v))) => t('k, 'v, 'id);
-```
-
-`mergeMany(s, xs)`
-
-Adding each of `xs` to `s`, note unlike `add`, the reference of return value might be changed even if all values in `xs` exist `s`.
-
-## mergeU
-
-```re sig
-let mergeU:
-(t('k, 'v, 'id), t('k, 'v2, 'id), [@bs] (('k, option('v), option('v2)) => option('v3))) =>
-t('k, 'v3, 'id);
-```
-
-## merge
-
-```re sig
-let merge:
-(t('k, 'v, 'id), t('k, 'v2, 'id), ('k, option('v), option('v2)) => option('v3)) =>
-t('k, 'v3, 'id);
-```
-
-`merge(m1, m2, f)` computes a map whose keys is a subset of keys of `m1` and of `m2`. The presence of each such binding, and the corresponding value, is determined with the function `f`.
-
-## keepU
-
-```re sig
-let keepU: (t('k, 'v, 'id), [@bs] (('k, 'v) => bool)) => t('k, 'v, 'id);
-```
-
-## keep
-
-```re sig
-let keep: (t('k, 'v, 'id), ('k, 'v) => bool) => t('k, 'v, 'id);
-```
-
-`keep(m, p)` returns the map with all the bindings in m that satisfy predicate `p`.
-
-## partitionU
-
-```re sig
-let partitionU: (t('k, 'v, 'id), [@bs] (('k, 'v) => bool)) => (t('k, 'v, 'id), t('k, 'v, 'id));
-```
-
-## partition
-
-```re sig
-let partition: (t('k, 'v, 'id), ('k, 'v) => bool) => (t('k, 'v, 'id), t('k, 'v, 'id));
-```
-
-`partition(m, p)` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `s` that satisfy the predicate `p`, and `m2` is the map with all the bindings of `s` that do not satisfy `p`.
-
-## split
-
-```re sig
-let split: (t('k, 'v, 'id), 'k) => ((t('k, 'v, 'id), t('k, 'v, 'id)), option('v));
-```
-
-`split(x, m)` returns a tuple `(l, r)`, data, where `l` is the map with all the bindings of `m` whose 'k is strictly less than `x`; `r` is the map with all the bindings of m whose 'k is strictly greater than `x`; `data` is `None` if `m` contains no binding for `x`, or `Some(v)` if `m` binds `v` to `x`.
-
-## mapU
-
-```re sig
-let mapU: (t('k, 'v, 'id), [@bs] ('v => 'v2)) => t('k, 'v2, 'id);
-```
-
-## map
-
-```re sig
-let map: (t('k, 'v, 'id), 'v => 'v2) => t('k, 'v2, 'id);
-```
-
-`map(m, f) returns a map with same domain as`m`, where the associated value`a`of all bindings of`m`has been replaced by the result of the application of`f`to`a`. The bindings are passed to`f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```re sig
-let mapWithKeyU: (t('k, 'v, 'id), [@bs] (('k, 'v) => 'v2)) => t('k, 'v2, 'id);
-```
-
-## mapWithKey
-
-```re sig
-let mapWithKey: (t('k, 'v, 'id), ('k, 'v) => 'v2) => t('k, 'v2, 'id);
-```
-
-`mapWithKey(m, f)`
-
-The same as `Belt.Map.map` except that `f` is supplied with one more argument: the key.
-
-## getData
-
-```re sig
-let getData: t('k, 'v, 'id) => Belt_MapDict.t('k, 'v, 'id);
-```
-
-`getData(s0)`
-
-Advanced usage only
-
-Returns the raw data (detached from comparator), but its type is still manifested, so that user can pass identity directly without boxing.
-
-## getId
-
-```re sig
-let getId: t('k, 'v, 'id) => id('k, 'id);
-```
-
-Advanced usage only
-
-Returns the identity of s0.
-
-## packIdData
-
-```re sig
-let packIdData: (~id: id('k, 'id), ~data: Belt_MapDict.t('k, 'v, 'id)) => t('k, 'v, 'id);
-```
-
-`packIdData(~id, ~data)`
-
-Advanced usage only
-
-Returns the packed collection.
diff --git a/pages/docs/manual/v8.0.0/api/belt/mutable-map-int.mdx b/pages/docs/manual/v8.0.0/api/belt/mutable-map-int.mdx
deleted file mode 100644
index 1364551bf..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/mutable-map-int.mdx
+++ /dev/null
@@ -1,299 +0,0 @@
-# MutableMapInt
-
-## key
-
-```re sig
-type key = int;
-```
-
-## t
-
-```re sig
-type t('a);
-```
-
-## make
-
-```re sig
-let make: unit => t('a);
-```
-
-## clear
-
-```re sig
-let clear: t('a) => unit;
-```
-
-## isEmpty
-
-```re sig
-let isEmpty: t('a) => bool;
-```
-
-## has
-
-```re sig
-let has: (t('a), key) => bool;
-```
-
-## cmpU
-
-```re sig
-let cmpU: (t('a), t('a), [@bs] (('a, 'a) => int)) => int;
-```
-
-## cmp
-
-```re sig
-let cmp: (t('a), t('a), ('a, 'a) => int) => int;
-```
-
-`cmp(m1, m2, cmp)` First compare by size, if size is the same, compare by key, value pair.
-
-## eqU
-
-```re sig
-let eqU: (t('a), t('a), [@bs] (('a, 'a) => bool)) => bool;
-```
-
-## eq
-
-```re sig
-let eq: (t('a), t('a), ('a, 'a) => bool) => bool;
-```
-
-`eq(m1, m2, cmp)`
-
-## forEachU
-
-```re sig
-let forEachU: (t('a), [@bs] ((key, 'a) => unit)) => unit;
-```
-
-## forEach
-
-```re sig
-let forEach: (t('a), (key, 'a) => unit) => unit;
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the key as first argument, and the associated value as second argument. The application order of `f` is in increasing order.
-
-## reduceU
-
-```re sig
-let reduceU: (t('a), 'b, [@bs] (('b, key, 'a) => 'b)) => 'b;
-```
-
-## reduce
-
-```re sig
-let reduce: (t('a), 'b, ('b, key, 'a) => 'b) => 'b;
-```
-
-`reduce(m, a, f), computes`(f(kN, dN) ... (f(k1, d1, a))...)`, where`k1 ... kN`are the keys of all bindings in`m`(in increasing order), and`d1 ... dN` are the associated data.
-
-## everyU
-
-```re sig
-let everyU: (t('a), [@bs] ((key, 'a) => bool)) => bool;
-```
-
-## every
-
-```re sig
-let every: (t('a), (key, 'a) => bool) => bool;
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. The application order of `p` is unspecified.
-
-## someU
-
-```re sig
-let someU: (t('a), [@bs] ((key, 'a) => bool)) => bool;
-```
-
-## some
-
-```re sig
-let some: (t('a), (key, 'a) => bool) => bool;
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. The application order of `p` is unspecified.
-
-## size
-
-```re sig
-let size: t('a) => int;
-```
-
-## toList
-
-```re sig
-let toList: t('a) => list((key, 'a));
-```
-
-In increasing order
-
-## toArray
-
-```re sig
-let toArray: t('a) => array((key, 'a));
-```
-
-## fromArray
-
-```re sig
-let fromArray: array((key, 'a)) => t('a);
-```
-
-## keysToArray
-
-```re sig
-let keysToArray: t('a) => array(key);
-```
-
-## valuesToArray
-
-```re sig
-let valuesToArray: t('a) => array('a);
-```
-
-## minKey
-
-```re sig
-let minKey: t('a) => option(key);
-```
-
-## minKeyUndefined
-
-```re sig
-let minKeyUndefined: t('a) => Js.undefined(key);
-```
-
-## maxKey
-
-```re sig
-let maxKey: t('a) => option(key);
-```
-
-## maxKeyUndefined
-
-```re sig
-let maxKeyUndefined: t('a) => Js.undefined(key);
-```
-
-## minimum
-
-```re sig
-let minimum: t('a) => option((key, 'a));
-```
-
-## minUndefined
-
-```re sig
-let minUndefined: t('a) => Js.undefined((key, 'a));
-```
-
-## maximum
-
-```re sig
-let maximum: t('a) => option((key, 'a));
-```
-
-## maxUndefined
-
-```re sig
-let maxUndefined: t('a) => Js.undefined((key, 'a));
-```
-
-## get
-
-```re sig
-let get: (t('a), key) => option('a);
-```
-
-## getUndefined
-
-```re sig
-let getUndefined: (t('a), key) => Js.undefined('a);
-```
-
-## getWithDefault
-
-```re sig
-let getWithDefault: (t('a), key, 'a) => 'a;
-```
-
-## getExn
-
-```re sig
-let getExn: (t('a), key) => 'a;
-```
-
-## checkInvariantInternal
-
-```re sig
-let checkInvariantInternal: t('a) => unit;
-```
-
-Raise when invariant is not held.
-
-## remove
-
-```re sig
-let remove: (t('a), key) => unit;
-```
-
-`remove(m, x)` do the in-place modification.
-
-## removeMany
-
-```re sig
-let removeMany: (t('a), array(key)) => unit;
-```
-
-## set
-
-```re sig
-let set: (t('a), key, 'a) => unit;
-```
-
-`set(m, x, y)` do the in-place modification, return `m` for chaining. If `x` was already bound in `m`, its previous binding disappears.
-
-## updateU
-
-```re sig
-let updateU: (t('a), key, [@bs] (option('a) => option('a))) => unit;
-```
-
-## update
-
-```re sig
-let update: (t('a), key, option('a) => option('a)) => unit;
-```
-
-## mapU
-
-```re sig
-let mapU: (t('a), [@bs] ('a => 'b)) => t('b);
-```
-
-## map
-
-```re sig
-let map: (t('a), 'a => 'b) => t('b);
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value a of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```re sig
-let mapWithKeyU: (t('a), [@bs] ((key, 'a) => 'b)) => t('b);
-```
-
-## mapWithKey
-
-```re sig
-let mapWithKey: (t('a), (key, 'a) => 'b) => t('b);
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/mutable-map-string.mdx b/pages/docs/manual/v8.0.0/api/belt/mutable-map-string.mdx
deleted file mode 100644
index 9c2f6b4d6..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/mutable-map-string.mdx
+++ /dev/null
@@ -1,299 +0,0 @@
-# MutableMapString
-
-## key
-
-```re sig
-type key = string;
-```
-
-## t
-
-```re sig
-type t('a);
-```
-
-## make
-
-```re sig
-let make: unit => t('a);
-```
-
-## clear
-
-```re sig
-let clear: t('a) => unit;
-```
-
-## isEmpty
-
-```re sig
-let isEmpty: t('a) => bool;
-```
-
-## has
-
-```re sig
-let has: (t('a), key) => bool;
-```
-
-## cmpU
-
-```re sig
-let cmpU: (t('a), t('a), [@bs] (('a, 'a) => int)) => int;
-```
-
-## cmp
-
-```re sig
-let cmp: (t('a), t('a), ('a, 'a) => int) => int;
-```
-
-`cmp(m1, m2, cmp)` First compare by size, if size is the same, compare by key, value pair.
-
-## eqU
-
-```re sig
-let eqU: (t('a), t('a), [@bs] (('a, 'a) => bool)) => bool;
-```
-
-## eq
-
-```re sig
-let eq: (t('a), t('a), ('a, 'a) => bool) => bool;
-```
-
-`eq(m1, m2, cmp)`
-
-## forEachU
-
-```re sig
-let forEachU: (t('a), [@bs] ((key, 'a) => unit)) => unit;
-```
-
-## forEach
-
-```re sig
-let forEach: (t('a), (key, 'a) => unit) => unit;
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the key as first argument, and the associated value as second argument. The application order of `f` is in increasing order.
-
-## reduceU
-
-```re sig
-let reduceU: (t('a), 'b, [@bs] (('b, key, 'a) => 'b)) => 'b;
-```
-
-## reduce
-
-```re sig
-let reduce: (t('a), 'b, ('b, key, 'a) => 'b) => 'b;
-```
-
-`reduce(m, a, f), computes`(f(kN, dN) ... (f(k1, d1, a))...)`, where`k1 ... kN`are the keys of all bindings in`m`(in increasing order), and`d1 ... dN` are the associated data.
-
-## everyU
-
-```re sig
-let everyU: (t('a), [@bs] ((key, 'a) => bool)) => bool;
-```
-
-## every
-
-```re sig
-let every: (t('a), (key, 'a) => bool) => bool;
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. The application order of `p` is unspecified.
-
-## someU
-
-```re sig
-let someU: (t('a), [@bs] ((key, 'a) => bool)) => bool;
-```
-
-## some
-
-```re sig
-let some: (t('a), (key, 'a) => bool) => bool;
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. The application order of `p` is unspecified.
-
-## size
-
-```re sig
-let size: t('a) => int;
-```
-
-## toList
-
-```re sig
-let toList: t('a) => list((key, 'a));
-```
-
-In increasing order
-
-## toArray
-
-```re sig
-let toArray: t('a) => array((key, 'a));
-```
-
-## fromArray
-
-```re sig
-let fromArray: array((key, 'a)) => t('a);
-```
-
-## keysToArray
-
-```re sig
-let keysToArray: t('a) => array(key);
-```
-
-## valuesToArray
-
-```re sig
-let valuesToArray: t('a) => array('a);
-```
-
-## minKey
-
-```re sig
-let minKey: t('a) => option(key);
-```
-
-## minKeyUndefined
-
-```re sig
-let minKeyUndefined: t('a) => Js.undefined(key);
-```
-
-## maxKey
-
-```re sig
-let maxKey: t('a) => option(key);
-```
-
-## maxKeyUndefined
-
-```re sig
-let maxKeyUndefined: t('a) => Js.undefined(key);
-```
-
-## minimum
-
-```re sig
-let minimum: t('a) => option((key, 'a));
-```
-
-## minUndefined
-
-```re sig
-let minUndefined: t('a) => Js.undefined((key, 'a));
-```
-
-## maximum
-
-```re sig
-let maximum: t('a) => option((key, 'a));
-```
-
-## maxUndefined
-
-```re sig
-let maxUndefined: t('a) => Js.undefined((key, 'a));
-```
-
-## get
-
-```re sig
-let get: (t('a), key) => option('a);
-```
-
-## getUndefined
-
-```re sig
-let getUndefined: (t('a), key) => Js.undefined('a);
-```
-
-## getWithDefault
-
-```re sig
-let getWithDefault: (t('a), key, 'a) => 'a;
-```
-
-## getExn
-
-```re sig
-let getExn: (t('a), key) => 'a;
-```
-
-## checkInvariantInternal
-
-```re sig
-let checkInvariantInternal: t('a) => unit;
-```
-
-Raise when invariant is not held.
-
-## remove
-
-```re sig
-let remove: (t('a), key) => unit;
-```
-
-`remove(m, x)` do the in-place modification.
-
-## removeMany
-
-```re sig
-let removeMany: (t('a), array(key)) => unit;
-```
-
-## set
-
-```re sig
-let set: (t('a), key, 'a) => unit;
-```
-
-`set(m, x, y)` do the in-place modification, return `m` for chaining. If `x` was already bound in `m`, its previous binding disappears.
-
-## updateU
-
-```re sig
-let updateU: (t('a), key, [@bs] (option('a) => option('a))) => unit;
-```
-
-## update
-
-```re sig
-let update: (t('a), key, option('a) => option('a)) => unit;
-```
-
-## mapU
-
-```re sig
-let mapU: (t('a), [@bs] ('a => 'b)) => t('b);
-```
-
-## map
-
-```re sig
-let map: (t('a), 'a => 'b) => t('b);
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value a of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```re sig
-let mapWithKeyU: (t('a), [@bs] ((key, 'a) => 'b)) => t('b);
-```
-
-## mapWithKey
-
-```re sig
-let mapWithKey: (t('a), (key, 'a) => 'b) => t('b);
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/mutable-map.mdx b/pages/docs/manual/v8.0.0/api/belt/mutable-map.mdx
deleted file mode 100644
index c862f915d..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/mutable-map.mdx
+++ /dev/null
@@ -1,313 +0,0 @@
-# MutableMap
-
-<Intro>
-
-A mutable sorted map module which allows customize compare behavior.
-
-</Intro>
-
-Same as `Belt.Map`, but mutable.
-
-## t
-
-```re sig
-type t('k, 'v, 'id);
-```
-
-## id
-
-```re sig
-type id('key, 'id) = Belt_Id.comparable('key, 'id);
-```
-
-## make
-
-```re sig
-let make: (~id: id('k, 'id)) => t('k, 'a, 'id);
-```
-
-## clear
-
-```re sig
-let clear: t('a, 'b, 'c) => unit;
-```
-
-## isEmpty
-
-```re sig
-let isEmpty: t('a, 'b, 'c) => bool;
-```
-
-## has
-
-```re sig
-let has: (t('k, 'a, 'b), 'k) => bool;
-```
-
-## cmpU
-
-```re sig
-let cmpU: (t('k, 'a, 'id), t('k, 'a, 'id), [@bs] (('a, 'a) => int)) => int;
-```
-
-## cmp
-
-```re sig
-let cmp: (t('k, 'a, 'id), t('k, 'a, 'id), ('a, 'a) => int) => int;
-```
-
-`cmp(m1, m2, cmp)` First compare by size, if size is the same, compare by key, value pair.
-
-## eqU
-
-```re sig
-let eqU: (t('k, 'a, 'id), t('k, 'a, 'id), [@bs] (('a, 'a) => bool)) => bool;
-```
-
-## eq
-
-```re sig
-let eq: (t('k, 'a, 'id), t('k, 'a, 'id), ('a, 'a) => bool) => bool;
-```
-
-`eq(m1, m2, eqf)` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data. `eqf` is the equality predicate used to compare the data associated with the keys.
-
-## forEachU
-
-```re sig
-let forEachU: (t('k, 'a, 'id), [@bs] (('k, 'a) => unit)) => unit;
-```
-
-## forEach
-
-```re sig
-let forEach: (t('k, 'a, 'id), ('k, 'a) => unit) => unit;
-```
-
-`forEach(m, f)` applies f to all bindings in map `m`. `f` receives the `'k` as first argument, and the associated value as second argument. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## reduceU
-
-```re sig
-let reduceU: (t('k, 'a, 'id), 'b, [@bs] (('b, 'k, 'a) => 'b)) => 'b;
-```
-
-## reduce
-
-```re sig
-let reduce: (t('k, 'a, 'id), 'b, ('b, 'k, 'a) => 'b) => 'b;
-```
-
-`reduce(m, a, f), computes`(f(kN, dN) ... (f(k1, d1, a))...)`, where`k1 ... kN`are the keys of all bindings in`m`(in increasing order), and`d1 ... dN` are the associated data.
-
-## everyU
-
-```re sig
-let everyU: (t('k, 'a, 'id), [@bs] (('k, 'a) => bool)) => bool;
-```
-
-## every
-
-```re sig
-let every: (t('k, 'a, 'id), ('k, 'a) => bool) => bool;
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`.
-
-## someU
-
-```re sig
-let someU: (t('k, 'a, 'id), [@bs] (('k, 'a) => bool)) => bool;
-```
-
-## some
-
-```re sig
-let some: (t('k, 'a, 'id), ('k, 'a) => bool) => bool;
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`.
-
-## size
-
-```re sig
-let size: t('k, 'a, 'id) => int;
-```
-
-## toList
-
-```re sig
-let toList: t('k, 'a, 'id) => list(('k, 'a));
-```
-
-In increasing order.
-
-## toArray
-
-```re sig
-let toArray: t('k, 'a, 'id) => array(('k, 'a));
-```
-
-## fromArray
-
-```re sig
-let fromArray: (array(('k, 'a)), ~id: id('k, 'id)) => t('k, 'a, 'id);
-```
-
-## keysToArray
-
-```re sig
-let keysToArray: t('k, 'a, 'b) => array('k);
-```
-
-## valuesToArray
-
-```re sig
-let valuesToArray: t('b, 'a, 'c) => array('a);
-```
-
-## minKey
-
-```re sig
-let minKey: t('k, 'a, 'b) => option('k);
-```
-
-## minKeyUndefined
-
-```re sig
-let minKeyUndefined: t('k, 'a, 'b) => Js.undefined('k);
-```
-
-## maxKey
-
-```re sig
-let maxKey: t('k, 'a, 'b) => option('k);
-```
-
-## maxKeyUndefined
-
-```re sig
-let maxKeyUndefined: t('k, 'a, 'b) => Js.undefined('k);
-```
-
-## minimum
-
-```re sig
-let minimum: t('k, 'a, 'b) => option(('k, 'a));
-```
-
-## minUndefined
-
-```re sig
-let minUndefined: t('k, 'a, 'b) => Js.undefined(('k, 'a));
-```
-
-## maximum
-
-```re sig
-let maximum: t('k, 'a, 'b) => option(('k, 'a));
-```
-
-## maxUndefined
-
-```re sig
-let maxUndefined: t('k, 'a, 'b) => Js.undefined(('k, 'a));
-```
-
-## get
-
-```re sig
-let get: (t('k, 'a, 'id), 'k) => option('a);
-```
-
-## getUndefined
-
-```re sig
-let getUndefined: (t('k, 'a, 'id), 'k) => Js.undefined('a);
-```
-
-## getWithDefault
-
-```re sig
-let getWithDefault: (t('k, 'a, 'id), 'k, 'a) => 'a;
-```
-
-## getExn
-
-```re sig
-let getExn: (t('k, 'a, 'id), 'k) => 'a;
-```
-
-## checkInvariantInternal
-
-```re sig
-let checkInvariantInternal: t('a, 'b, 'c) => unit;
-```
-
-Raise when invariant is not held.
-
-## remove
-
-```re sig
-let remove: (t('k, 'a, 'id), 'k) => unit;
-```
-
-`remove(m, x)` do the in-place modification.
-
-## removeMany
-
-```re sig
-let removeMany: (t('k, 'a, 'id), array('k)) => unit;
-```
-
-## set
-
-```re sig
-let set: (t('k, 'a, 'id), 'k, 'a) => unit;
-```
-
-`set(m, x, y)` do the in-place modification
-
-## updateU
-
-```re sig
-let updateU: (t('k, 'a, 'id), 'k, [@bs] (option('a) => option('a))) => unit;
-```
-
-## update
-
-```re sig
-let update: (t('k, 'a, 'id), 'k, option('a) => option('a)) => unit;
-```
-
-## mergeMany
-
-```re sig
-let mergeMany: (t('k, 'a, 'id), array(('k, 'a))) => unit;
-```
-
-## mapU
-
-```re sig
-let mapU: (t('k, 'a, 'id), [@bs] ('a => 'b)) => t('k, 'b, 'id);
-```
-
-## map
-
-```re sig
-let map: (t('k, 'a, 'id), 'a => 'b) => t('k, 'b, 'id);
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value a of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```re sig
-let mapWithKeyU: (t('k, 'a, 'id), [@bs] (('k, 'a) => 'b)) => t('k, 'b, 'id);
-```
-
-## mapWithKey
-
-```re sig
-let mapWithKey: (t('k, 'a, 'id), ('k, 'a) => 'b) => t('k, 'b, 'id);
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/mutable-queue.mdx b/pages/docs/manual/v8.0.0/api/belt/mutable-queue.mdx
deleted file mode 100644
index 4cdfca820..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/mutable-queue.mdx
+++ /dev/null
@@ -1,175 +0,0 @@
-# MutableQueue
-
-<Intro>
-
-An FIFO(first in first out) queue data structure.
-
-</Intro>
-
-## t
-
-```
-type t('a);
-```
-
-The type of queues containing elements of `type('a)`.
-
-## make
-
-```
-let make: unit => t('a);
-```
-
-Returns a new queue, initially empty.
-
-## clear
-
-```
-let clear: t('a) => unit;
-```
-
-Discard all elements from the queue.
-
-## isEmpty
-
-```
-let isEmpty: t('a) => bool;
-```
-
-Returns `true` if the given queue is empty, `false` otherwise.
-
-## fromArray
-
-```
-let fromArray: array('a) => t('a);
-```
-
-`fromArray` a is equivalent to `Array.forEach(a, add(q, a));`
-
-## add
-
-```
-let add: (t('a), 'a) => unit;
-```
-
-`add(q, x)` adds the element `x` at the end of the queue `q`.
-
-## peek
-
-```
-let peek: t('a) => option('a);
-```
-
-`peekOpt(q)` returns the first element in queue `q`, without removing it from the queue.
-
-## peekUndefined
-
-```
-let peekUndefined: t('a) => Js.undefined('a);
-```
-
-`peekUndefined(q)` returns `undefined` if not found.
-
-## peekExn
-
-```
-let peekExn: t('a) => 'a;
-```
-
-raise an exception if `q` is empty
-
-## pop
-
-```
-let pop: t('a) => option('a);
-```
-
-`pop(q)` removes and returns the first element in queue `q`.
-
-## popUndefined
-
-```
-let popUndefined: t('a) => Js.undefined('a);
-```
-
-`popUndefined(q)` removes and returns the first element in queue `q`. it will return `undefined` if it is already empty.
-
-## popExn
-
-```
-let popExn: t('a) => 'a;
-```
-
-`popExn(q)` raise an exception if q is empty.
-
-## copy
-
-```
-let copy: t('a) => t('a);
-```
-
-`copy(q)` returns a fresh queue.
-
-## size
-
-```
-let size: t('a) => int;
-```
-
-Returns the number of elements in a queue.
-
-## mapU
-
-```
-let mapU: (t('a), [@bs] ('a => 'b)) => t('b);
-```
-
-## map
-
-```
-let map: (t('a), 'a => 'b) => t('b);
-```
-
-## forEachU
-
-```
-let forEachU: (t('a), [@bs] ('a => unit)) => unit;
-```
-
-## forEach
-
-```
-let forEach: (t('a), 'a => unit) => unit;
-```
-
-`forEach(q, f) applies`f`in turn to all elements of`q`, from the least recently entered to the most recently entered. The queue itself is unchanged.
-
-## reduceU
-
-```
-let reduceU: (t('a), 'b, [@bs] (('b, 'a) => 'b)) => 'b;
-```
-
-## reduce
-
-```
-let reduce: (t('a), 'b, ('b, 'a) => 'b) => 'b;
-```
-
-`reduce(q, accu, f)` is equivalent to `List.reduce(l, accu, f)`, where `l` is the list of `q`'s elements. The queue remains unchanged.
-
-## transfer
-
-```
-let transfer: (t('a), t('a)) => unit;
-```
-
-`transfer(q1, q2)` adds all of `q1`'s elements at the end of the queue `q2`, then clears `q1`. It is equivalent to the sequence `forEach((x) => add(x, q2), q1);`; clear `q1`, but runs in constant time.
-
-## toArray
-
-```
-let toArray: t('a) => array('a);
-```
-
-First added will be in the beginning of the array.
diff --git a/pages/docs/manual/v8.0.0/api/belt/mutable-set-int.mdx b/pages/docs/manual/v8.0.0/api/belt/mutable-set-int.mdx
deleted file mode 100644
index 7e4e10cd0..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/mutable-set-int.mdx
+++ /dev/null
@@ -1,563 +0,0 @@
-# MutableSetInt
-
-<Intro>
-
-This module is [Belt.MutableSet](./mutable-set) specialized with key type to be a `int` type.
-It is more efficient in general, the API is the same with [Belt.MutableSet](./mutable-set) except its key type is fixed, and identity is not needed (using the built-in one).
-
-</Intro>
-
-## value
-
-```re sig
-type value = int;
-```
-
-The type of the set elements
-
-## t
-
-```re sig
-type t;
-```
-
-Type of the sets.
-
-## make
-
-```re sig
-let make: unit => t;
-```
-
-Returns empty set.
-
-```re example
-let set = Belt.MutableSet.Int.make();
-```
-
-## fromArray
-
-```re sig
-let fromArray: array(value) => t;
-```
-
-Creates new set from array of elements.
-
-```re example
-let s0 = Belt.MutableSet.Int.fromArray([|1, 3, 2, 4|])
-
-s0->Belt.MutableSet.Int.toArray; /* [|1, 2, 3, 4|] */
-```
-
-## fromSortedArrayUnsafe
-
-```re sig
-let fromSortedArrayUnsafe: array(value) => t;
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-Returns copy of a set.
-
-```re example
-let s0 = Belt.MutableSet.Int.fromArray([|1, 3, 2, 4|])
-
-let copied = s0->Belt.MutableSet.Int.copy;
-copied->Belt.MutableSet.Int.toArray /* [|1, 2, 3, 4|] */
-```
-
-## isEmpty
-
-```re sig
-let isEmpty: t => bool;
-```
-
-Checks if set is empty.
-
-```re example
-let empty = Belt.MutableSet.Int.fromArray([||]);
-let notEmpty = Belt.MutableSet.Int.fromArray([|1|]);
-
-Belt.MutableSet.Int.isEmpty(empty); /* true */
-Belt.MutableSet.Int.isEmpty(notEmpty); /* false */
-```
-
-## has
-
-```re sig
-let has: (t, value) => bool;
-```
-
-Checks if element exists in set.
-
-```re example
-let set = Belt.MutableSet.Int.fromArray([|1, 4, 2, 5|]);
-
-set->Belt.MutableSet.Int.has(3) /* false */
-set->Belt.MutableSet.Int.has(1) /* true */
-```
-
-## add
-
-```re sig
-let add: (t, value) => unit;
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```re example
-let s0 = Belt.MutableSet.Int.make();
-s0->Belt.MutableSet.Int.add(1);
-s0->Belt.MutableSet.Int.add(2);
-s0->Belt.MutableSet.Int.add(2);
-
-s0->Belt.MutableSet.Int.toArray; /* [|1, 2|] */
-```
-
-## addCheck
-
-```
-let addCheck: (t, value) => bool;
-```
-
-## mergeMany
-
-```re sig
-let mergeMany: (t, array(value)) => unit;
-```
-
-Adds each element of array to set. Unlike [add](#add), the reference of return value might be changed even if all values in array already exist in set
-
-```re example
-let set = Belt.MutableSet.Int.make();
-
-set->Belt.MutableSet.Int.mergeMany([|5, 4, 3, 2, 1|]);
-set->Belt.MutableSet.Int.toArray; /* [|1, 2, 3, 4, 5|] */
-```
-
-## remove
-
-```re sig
-let remove: (t, value) => unit;
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```re example
-let s0 = Belt.MutableSet.Int.fromArray([|2,3,1,4,5|]);
-s0->Belt.MutableSet.Int.remove(1);
-s0->Belt.MutableSet.Int.remove(3);
-s0->Belt.MutableSet.Int.remove(3);
-
-s0->Belt.MutableSet.Int.toArray; /* [|2,4,5|] */
-```
-
-## removeCheck
-
-```re sig
-let removeCheck: (t, value) => bool;
-```
-
-## removeMany
-
-```re sig
-let removeMany: (t, array(value)) => unit;
-```
-
-Removes each element of array from set.
-
-```re example
-let set = Belt.MutableSet.Int.fromArray([|1, 2, 3, 4|]);
-
-set->Belt.MutableSet.Int.removeMany([|5, 4, 3, 2, 1|]);
-set->Belt.MutableSet.Int.toArray; /* [||] */
-```
-
-## union
-
-```re sig
-let union: (t, t) => t;
-```
-
-Returns union of two sets.
-
-```re example
-let s0 = Belt.MutableSet.Int.fromArray([|5,2,3,5,6|]);
-let s1 = Belt.MutableSet.Int.fromArray([|5,2,3,1,5,4|]);
-let union = Belt.MutableSet.Int.union(s0, s1);
-union->Belt.MutableSet.Int.toArray; /* [|1,2,3,4,5,6|] */
-```
-
-## intersect
-
-```re sig
-let intersect: (t, t) => t;
-```
-
-Returns intersection of two sets.
-
-```re example
-
-let s0 = Belt.MutableSet.Int.fromArray([|5,2,3,5,6|]);
-let s1 = Belt.MutableSet.Int.fromArray([|5,2,3,1,5,4|]);
-let intersect = Belt.MutableSet.Int.intersect(s0, s1);
-intersect->Belt.MutableSet.Int.toArray; /* [|2,3,5|] */
-```
-
-## diff
-
-```re sig
-let diff: (t, t) => t;
-```
-
-Returns elements from first set, not existing in second set.
-
-```re example
-let s0 = Belt.MutableSet.Int.fromArray([|5,2,3,5,6|]);
-let s1 = Belt.MutableSet.Int.fromArray([|5,2,3,1,5,4|]);
-Belt.MutableSet.Int.toArray(Belt.MutableSet.Int.diff(s0, s1)); /* [|6|] */
-Belt.MutableSet.Int.toArray(Belt.MutableSet.Int.diff(s1,s0)); /* [|1,4|] */
-```
-
-## subset
-
-```re sig
-let subset: (t, t) => bool;
-```
-
-Checks if second set is subset of first set.
-
-```re example
-let s0 = Belt.MutableSet.Int.fromArray([|5,2,3,5,6|]);
-let s1 = Belt.MutableSet.Int.fromArray([|5,2,3,1,5,4|]);
-let s2 = Belt.MutableSet.Int.intersect(s0, s1);
-Belt.MutableSet.Int.subset(s2, s0); /* true */
-Belt.MutableSet.Int.subset(s2, s1); /* true */
-Belt.MutableSet.Int.subset(s1, s0); /* false */
-```
-
-## cmp
-
-```re sig
-let cmp: (t, t) => int;
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```re sig
-let eq: (t, t) => bool;
-```
-
-Checks if two sets are equal.
-
-```re example
-let s0 = Belt.MutableSet.Int.fromArray([|5,2,3|]);
-let s1 = Belt.MutableSet.Int.fromArray([|3,2,5|]);
-
-Belt.MutableSet.Int.eq(s0, s1); /* true */
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t, [@bs] (value => unit)) => unit;
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```re sig
-let forEach: (t, value => unit) => unit;
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```re example
-let s0 = Belt.MutableSet.Int.fromArray([|5,2,3,5,6|]);
-let acc = ref([]);
-s0->Belt.MutableSet.Int.forEach(x => {
-  acc := Belt.List.add(acc^, x)
-});
-acc; /* [6,5,3,2] */
-```
-
-## reduceU
-
-```re sig
-let reduceU: (t, 'a, [@bs] (('a, value) => 'a)) => 'a;
-```
-
-## reduce
-
-```
-let reduce: (t, 'a, ('a, value) => 'a) => 'a;
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```re example
-let s0 = Belt.MutableSet.Int.fromArray([|5,2,3,5,6|]);
-s0->Belt.MutableSet.Int.reduce([], (acc, element) =>
-  acc->Belt.List.add(element)
-); /* [6,5,3,2] */
-```
-
-## everyU
-
-```re sig
-let everyU: (t, [@bs] (value => bool)) => bool;
-```
-
-## every
-
-```re sig
-let every: (t, value => bool) => bool;
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```re example
-let isEven = x => x mod 2 == 0;
-
-let s0 = Belt.MutableSet.Int.fromArray([|2,4,6,8|]);
-s0->Belt.MutableSet.Int.every(isEven); /* true */
-```
-
-## someU
-
-```re sig
-let someU: (t, [@bs] (value => bool)) => bool;
-```
-
-## some
-
-```re sig
-let some: (t, value => bool) => bool;
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```re example
-let isOdd = x => x mod 2 != 0;
-
-let s0 = Belt.MutableSet.Int.fromArray([|1,2,4,6,8|]);
-s0->Belt.MutableSet.Int.some(isOdd); /* true */
-```
-
-## keepU
-
-```re sig
-let keepU: (t, [@bs] (value => bool)) => t;
-```
-
-## keep
-
-```re sig
-let keep: (t, value => bool) => t;
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```re example
-let isEven = x => x mod 2 == 0;
-
-let s0 = Belt.MutableSet.Int.fromArray([|1,2,3,4,5|]);
-let s1 = s0->Belt.MutableSet.Int.keep(isEven);
-
-s1->Belt.MutableSet.Int.toArray; /* [|2, 4|] */
-```
-
-## partitionU
-
-```re sig
-let partitionU: (t, [@bs] (value => bool)) => (t, t);
-```
-
-## partition
-
-```re sig
-let partition: (t, value => bool) => (t, t);
-```
-
-```re example
-let isOdd = x => x mod 2 != 0;
-
-let s0 = Belt.MutableSet.Int.fromArray([|1,2,3,4,5|]);
-let (s1, s2) = s0->Belt.MutableSet.Int.partition(isOdd);
-
-s1->Belt.MutableSet.Int.toArray; /* [|1,3,5|] */
-s2->Belt.MutableSet.Int.toArray; /* [|2,4|] */
-```
-
-## size
-
-```re sig
-let size: t => int;
-```
-
-Returns size of the set.
-
-```re example
-let s0 = Belt.MutableSet.Int.fromArray([|1,2,3,4|]);
-
-s0->Belt.MutableSet.Int.size; /* 4 */
-```
-
-## toList
-
-```re sig
-let toList: t => list(value);
-```
-
-Returns list of ordered set elements.
-
-```re example
-let s0 = Belt.MutableSet.Int.fromArray([|3,2,1,5|]);
-
-s0->Belt.MutableSet.Int.toList; /* [1,2,3,5] */
-```
-
-## toArray
-
-```re sig
-let toArray: t => array(value);
-```
-
-Returns array of ordered set elements.
-
-```re example
-let s0 = Belt.MutableSet.Int.fromArray([|3,2,1,5|]);
-
-s0->Belt.MutableSet.Int.toArray; /* [|1,2,3,5|] */
-```
-
-## minimum
-
-```re sig
-let minimum: t => option(value);
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```re example
-let s0 = Belt.MutableSet.Int.make();
-let s1 = Belt.MutableSet.Int.fromArray([|3,2,1,5|]);
-
-s0->Belt.MutableSet.Int.minimum; /* None */
-s1->Belt.MutableSet.Int.minimum; /* Some(1) */
-```
-
-## minUndefined
-
-```re sig
-let minUndefined: t => Js.undefined(value);
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```re example
-let s0 = Belt.MutableSet.Int.make();
-let s1 = Belt.MutableSet.Int.fromArray([|3,2,1,5|]);
-
-s0->Belt.MutableSet.Int.minUndefined; /* undefined */
-s1->Belt.MutableSet.Int.minUndefined; /* 1 */
-```
-
-## maximum
-
-```re sig
-let maximum: t => option(value);
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```re example
-let s0 = Belt.MutableSet.Int.make();
-let s1 = Belt.MutableSet.Int.fromArray([|3,2,1,5|]);
-
-s0->Belt.MutableSet.Int.maximum; /* None */
-s1->Belt.MutableSet.Int.maximum; /* Some(5) */
-```
-
-## maxUndefined
-
-```re sig
-let maxUndefined: t => Js.undefined(value);
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```re example
-let s0 = Belt.MutableSet.Int.make();
-let s1 = Belt.MutableSet.Int.fromArray([|3,2,1,5|]);
-
-s0->Belt.MutableSet.Int.maxUndefined; /* undefined */
-s1->Belt.MutableSet.Int.maxUndefined; /* 5 */
-```
-
-## get
-
-```re sig
-let get: (t, value) => option(value);
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```re example
-let s0 = Belt.MutableSet.Int.fromArray([|1,2,3,4,5|]);
-
-s0->Belt.MutableSet.Int.get(3); /* Some(3) */
-s0->Belt.MutableSet.Int.get(20); /* None */
-```
-
-## getUndefined
-
-```re sig
-let getUndefined: (t, value) => Js.undefined(value);
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```re sig
-let getExn: (t, value) => value;
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```re sig
-let split: (t, value) => ((t, t), bool);
-```
-
-Returns a tuple `((smaller, larger), present)`, `present` is true when element exist in set.
-
-```re example
-let s0 = Belt.MutableSet.Int.fromArray([|1,2,3,4,5|]);
-
-let ((smaller, larger), present) = s0->Belt.MutableSet.Int.split(3);
-
-present; /* true */
-smaller->Belt.MutableSet.Int.toArray; /* [|1,2|] */
-larger->Belt.MutableSet.Int.toArray; /* [|4,5|] */
-
-```
-
-## checkInvariantInternal
-
-```re sig
-let checkInvariantInternal: t => unit;
-```
-
-**raise** when invariant is not held
diff --git a/pages/docs/manual/v8.0.0/api/belt/mutable-set-string.mdx b/pages/docs/manual/v8.0.0/api/belt/mutable-set-string.mdx
deleted file mode 100644
index aeab80160..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/mutable-set-string.mdx
+++ /dev/null
@@ -1,565 +0,0 @@
-# MutableSetString
-
-<Intro>
-
-This module is [Belt.MutableSet](./mutable-set) specialized with key type to be a `string` type.
-It is more efficient in general, the API is the same with [Belt.MutableSet](./mutable-set) except its key type is fixed, and identity is not needed (using the built-in one)
-
-</Intro>
-
-## value
-
-```re sig
-type value = string;
-```
-
-The type of the set elements.
-
-## t
-
-```re sig
-type t;
-```
-
-The type of sets.
-
-## make
-
-```re sig
-let make: unit => t;
-```
-
-Returns empty set.
-
-```re example
-let set = Belt.MutableSet.String.make();
-```
-
-## fromArray
-
-```re sig
-let fromArray: array(value) => t;
-```
-
-Creates new set from array of elements.
-
-```re example
-let s0 = Belt.MutableSet.String.fromArray([|"apple", "orange", "banana"|])
-
-s0->Belt.MutableSet.String.toArray; /* [|"apple", "banana", "orange"|] */
-```
-
-## fromSortedArrayUnsafe
-
-```re sig
-let fromSortedArrayUnsafe: array(value) => t;
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-Returns copy of a set.
-
-```re example
-let s0 = Belt.MutableSet.String.fromArray([|"orange", "apple"|])
-
-let copied = s0->Belt.MutableSet.String.copy;
-copied->Belt.MutableSet.String.toArray /* [|"apple", "orange"|] */
-```
-
-## isEmpty
-
-```re sig
-let isEmpty: t => bool;
-```
-
-Checks if set is empty.
-
-```re example
-let empty = Belt.MutableSet.String.fromArray([||]);
-let notEmpty = Belt.MutableSet.String.fromArray([|"apple"|]);
-
-Belt.MutableSet.String.isEmpty(empty); /* true */
-Belt.MutableSet.String.isEmpty(notEmpty); /* false */
-```
-
-## has
-
-```re sig
-let has: (t, value) => bool;
-```
-
-Checks if element exists in set.
-
-```re example
-let set = Belt.MutableSet.String.fromArray([|"apple", "orange", "banana"|]);
-
-set->Belt.MutableSet.String.has("strawberry") /* false */
-set->Belt.MutableSet.String.has("apple") /* true */
-```
-
-## add
-
-```re sig
-let add: (t, value) => unit;
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```re example
-let s0 = Belt.MutableSet.String.make();
-s0->Belt.MutableSet.String.add("apple");
-s0->Belt.MutableSet.String.add("banana");
-s0->Belt.MutableSet.String.add("banana");
-
-s0->Belt.MutableSet.String.toArray; /* [|"apple", "banana"|] */
-```
-
-## addCheck
-
-```re sig
-let addCheck: (t, value) => bool;
-```
-
-## mergeMany
-
-```re sig
-let mergeMany: (t, array(value)) => unit;
-```
-
-Adds each element of array to set.
-
-```re example
-let set = Belt.MutableSet.String.make();
-
-set->Belt.MutableSet.String.mergeMany([|"apple", "banana", "orange", "strawberry"|]);
-set->Belt.MutableSet.String.toArray; /* [|"apple", "banana", "orange", "strawberry"|] */
-```
-
-## remove
-
-```re sig
-let remove: (t, value) => unit;
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```re example
-let s0 = Belt.MutableSet.String.fromArray([|"orange", "banana", "apple"|]);
-s0->Belt.MutableSet.String.remove("apple");
-s0->Belt.MutableSet.String.remove("banana");
-s0->Belt.MutableSet.String.remove("banana");
-
-s0->Belt.MutableSet.String.toArray; /* [|"orange"|] */
-```
-
-## removeCheck
-
-```re sig
-let removeCheck: (t, value) => bool;
-```
-
-## removeMany
-
-```re sig
-let removeMany: (t, array(value)) => unit;
-```
-
-Removes each element of array from set.
-
-```re example
-let set = Belt.MutableSet.String.fromArray([|"apple", "banana", "orange"|]);
-
-set->Belt.MutableSet.String.removeMany([|"strawberry", "apple", "banana", "orange"|]);
-set->Belt.MutableSet.String.toArray; /* [||] */
-```
-
-## union
-
-```re sig
-let union: (t, t) => t;
-```
-
-Returns union of two sets.
-
-```re example
-let s0 = Belt.MutableSet.String.fromArray([|"apple", "banana", "orange", "carrot"|]);
-let s1 = Belt.MutableSet.String.fromArray([|"apple", "banana", "orange", "strawberry"|]);
-let union = Belt.MutableSet.String.union(s0, s1);
-union->Belt.MutableSet.String.toArray; /* [|"apple", "banana", "carrot", "orange", "strawberry"|] */
-```
-
-## intersect
-
-```re sig
-let intersect: (t, t) => t;
-```
-
-Returns intersection of two sets.
-
-```re example
-let s0 = Belt.MutableSet.String.fromArray([|"apple", "banana", "orange", "carrot"|]);
-let s1 = Belt.MutableSet.String.fromArray([|"apple", "banana", "orange", "strawberry"|]);
-let intersect = Belt.MutableSet.String.intersect(s0, s1);
-intersect->Belt.MutableSet.String.toArray; /* [|"apple", "banana", "orange"|] */
-```
-
-## diff
-
-```re sig
-let diff: (t, t) => t;
-```
-
-Returns elements from first set, not existing in second set.
-
-```re example
-let s0 = Belt.MutableSet.String.fromArray([|"apple", "banana", "orange", "carrot"|]);
-let s1 = Belt.MutableSet.String.fromArray([|"apple", "banana", "orange", "strawberry"|]);
-Belt.MutableSet.String.toArray(Belt.MutableSet.String.diff(s0, s1)); /* [|"carrot"|] */
-Belt.MutableSet.String.toArray(Belt.MutableSet.String.diff(s1, s0)); /* [|"strawberry"|] */
-```
-
-## subset
-
-```re sig
-let subset: (t, t) => bool;
-```
-
-Checks if second set is subset of first set.
-
-```re example
-let s0 = Belt.MutableSet.String.fromArray([|"5", "2", "3", "5", "6"|]);
-let s1 = Belt.MutableSet.String.fromArray([|"5", "2", "3", "1", "5", "4"|]);
-let s2 = Belt.MutableSet.String.intersect(s0, s1);
-Belt.MutableSet.String.subset(s2, s0); /* true */
-Belt.MutableSet.String.subset(s2, s1); /* true */
-Belt.MutableSet.String.subset(s1, s0); /* false */
-```
-
-## cmp
-
-```re sig
-let cmp: (t, t) => int;
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```re sig
-let eq: (t, t) => bool;
-```
-
-Checks if two sets are equal.
-
-```re example
-let s0 = Belt.MutableSet.String.fromArray([|"apple", "orange"|]);
-let s1 = Belt.MutableSet.String.fromArray([|"orange", "apple"|]);
-
-Belt.MutableSet.String.eq(s0, s1); /* true */
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t, [@bs] (value => unit)) => unit;
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```re sig
-let forEach: (t, value => unit) => unit;
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```re example
-let s0 = Belt.MutableSet.String.fromArray([|"banana", "orange", "apple"|]);
-let acc = ref([]);
-s0->Belt.MutableSet.String.forEach(x => {
-  acc := Belt.List.add(acc^, x)
-});
-acc; /* ["orange", "banana", "apple"] */
-```
-
-## reduceU
-
-```re sig
-let reduceU: (t, 'a, [@bs] (('a, value) => 'a)) => 'a;
-```
-
-## reduce
-
-```re sig
-let reduce: (t, 'a, ('a, value) => 'a) => 'a;
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```re example
-let s0 = Belt.MutableSet.String.fromArray([|"apple", "orange"|]);
-s0->Belt.MutableSet.String.reduce(0, (acc, element) =>
-  acc + String.length(element)
-); /* 11 */
-```
-
-## everyU
-
-```re sig
-let everyU: (t, [@bs] (value => bool)) => bool;
-```
-
-## every
-
-```re sig
-let every: (t, value => bool) => bool;
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```re example
-let hasAtLeastFiveChars = x => String.length(x) >= 5;
-
-let s0 = Belt.MutableSet.String.fromArray([|"apple", "carrot"|]);
-s0->Belt.MutableSet.String.every(hasAtLeastFiveChars); /* true */
-```
-
-## someU
-
-```re sig
-let someU: (t, [@bs] (value => bool)) => bool;
-```
-
-## some
-
-```re sig
-let some: (t, value => bool) => bool;
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```re example
-let hasFiveChars = x => String.length(x) == 5;
-
-let s0 = Belt.MutableSet.String.fromArray([|"strawberry", "apple"|]);
-s0->Belt.MutableSet.String.some(hasFiveChars); /* true */
-```
-
-## keepU
-
-```re sig
-let keepU: (t, [@bs] (value => bool)) => t;
-```
-
-## keep
-
-```re sig
-let keep: (t, value => bool) => t;
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```re example
-let hasFiveChars = x => String.length(x) == 5;
-
-let s0 = Belt.MutableSet.String.fromArray([|"apple", "orange", "banana"|]);
-let s1 = s0->Belt.MutableSet.String.keep(hasFiveChars);
-
-s1->Belt.MutableSet.String.toArray; /* [|"apple"|] */
-```
-
-## partitionU
-
-```re sig
-let partitionU: (t, [@bs] (value => bool)) => (t, t);
-```
-
-## partition
-
-```re sig
-let partition: (t, value => bool) => (t, t);
-```
-
-Returns a pair of sets, where first is the set of all the elements of set that satisfy the predicate, and second is the set of all the elements of set that do not satisfy the predicate.
-
-```re example
-let hasFiveChars = x => String.length(x) == 5;
-
-let s0 = Belt.MutableSet.String.fromArray([|"apple", "carrot"|]);
-let (s1, s2) = s0->Belt.MutableSet.String.partition(hasFiveChars);
-
-s1->Belt.MutableSet.String.toArray; /* [|"apple"|] */
-s2->Belt.MutableSet.String.toArray; /* [|"carrot"|] */
-```
-
-## size
-
-```re sig
-let size: t => int;
-```
-
-Returns size of the set.
-
-```re example
-let s0 = Belt.MutableSet.String.fromArray([|"apple"|]);
-
-s0->Belt.MutableSet.String.size; /* 1 */
-```
-
-## toList
-
-```re sig
-let toList: t => list(value);
-```
-
-Returns list of ordered set elements.
-
-```re example
-let s0 = Belt.MutableSet.String.fromArray([|"apple", "watermelon"|]);
-
-s0->Belt.MutableSet.String.toList; /* ["apple", "watermelon"] */
-```
-
-## toArray
-
-```re sig
-let toArray: t => array(value);
-```
-
-Returns array of ordered set elements.
-
-```re example
-let s0 = Belt.MutableSet.String.fromArray([|"apple", "watermelon"|]);
-
-s0->Belt.MutableSet.String.toArray; /* [|"apple", "watermelon"|] */
-```
-
-## minimum
-
-```re sig
-let minimum: t => option(value);
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```re example
-let s0 = Belt.MutableSet.String.make();
-let s1 = Belt.MutableSet.String.fromArray([|"apple", "orange"|]);
-
-s0->Belt.MutableSet.String.minimum; /* None */
-s1->Belt.MutableSet.String.minimum; /* Some("apple") */
-```
-
-## minUndefined
-
-```re sig
-let minUndefined: t => Js.undefined(value);
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```re example
-let s0 = Belt.MutableSet.String.make();
-let s1 = Belt.MutableSet.String.fromArray([|"apple", "orange"|]);
-
-s0->Belt.MutableSet.String.minUndefined; /* undefined */
-s1->Belt.MutableSet.String.minUndefined; /* "apple" */
-```
-
-## maximum
-
-```re sig
-let maximum: t => option(value);
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```re example
-let s0 = Belt.MutableSet.String.make();
-let s1 = Belt.MutableSet.String.fromArray([|"apple", "orange"|]);
-
-s0->Belt.MutableSet.String.maximum; /* None */
-s1->Belt.MutableSet.String.maximum; /* Some("orange") */
-```
-
-## maxUndefined
-
-```re sig
-let maxUndefined: t => Js.undefined(value);
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```re example
-let s0 = Belt.MutableSet.String.make();
-let s1 = Belt.MutableSet.String.fromArray([|"apple", "orange"|]);
-
-s0->Belt.MutableSet.String.maxUndefined; /* undefined */
-s1->Belt.MutableSet.String.maxUndefined; /* orange */
-```
-
-## get
-
-```re sig
-let get: (t, value) => option(value);
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```re example
-let s0 = Belt.MutableSet.String.fromArray([|"apple", "carrot"|]);
-
-s0->Belt.MutableSet.String.get("carrot"); /* Some("carrot") */
-s0->Belt.MutableSet.String.get("watermelon"); /* None */
-```
-
-## getUndefined
-
-```re sig
-let getUndefined: (t, value) => Js.undefined(value);
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```re sig
-let getExn: (t, value) => value;
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```re sig
-let split: (t, value) => ((t, t), bool);
-```
-
-Returns a tuple `((smaller, larger), present)`, `present` is true when element exist in set.
-
-```re example
-let s0 = Belt.MutableSet.String.fromArray([|"apple", "banana", "orange"|]);
-
-let ((smaller, larger), present) = s0->Belt.MutableSet.String.split("banana");
-
-present; /* true */
-smaller->Belt.MutableSet.String.toArray; /* [|"apple"|] */
-larger->Belt.MutableSet.String.toArray; /* [|"orange"|] */
-```
-
-## checkInvariantInternal
-
-```re sig
-let checkInvariantInternal: t => unit;
-```
-
-**raise** when invariant is not held
diff --git a/pages/docs/manual/v8.0.0/api/belt/mutable-set.mdx b/pages/docs/manual/v8.0.0/api/belt/mutable-set.mdx
deleted file mode 100644
index 21bd2ab4a..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/mutable-set.mdx
+++ /dev/null
@@ -1,745 +0,0 @@
-# MutableSet
-
-<Intro>
-
-A **mutable** sorted set module which allows customize compare behavior.
-The implementation uses balanced binary trees, and therefore searching and insertion take time logarithmic in the size of the map.
-
-It also has three specialized inner modules [Belt.MutableSet.Int](./mutable-set-int) and [Belt.MutableSet.String](./mutable-set-string) - This module separates data from function which is more verbose but slightly more efficient
-
-</Intro>
-
-```re example
-module PairComparator =
-  Belt.Id.MakeComparable({
-    type t = (int, int);
-    let cmp = ((a0, a1), (b0, b1)) =>
-      switch (Pervasives.compare(a0, b0)) {
-      | 0 => Pervasives.compare(a1, b1)
-      | c => c
-      };
-  });
-
-let mySet = Belt.MutableSet.make(~id=(module PairComparator));
-mySet->Belt.MutableSet.add((1, 2));
-```
-
-## t
-
-```re sig
-type t('value, 'id);
-```
-
-`'value` is the element type
-
-`'id` the identity of the collection
-
-## id
-
-```re sig
-type id('value, 'id) = Belt_Id.comparable('value, 'id);
-```
-
-The identity needed for making a set from scratch
-
-## make
-
-```re sig
-let make: (~id: id('value, 'id)) => t('value, 'id);
-```
-
-Creates a new set by taking in the comparator
-
-## fromArray
-
-```re sig
-let fromArray: (array('value), ~id: id('value, 'id)) => t('value, 'id);
-```
-
-Creates new set from array of elements.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.fromArray([|1, 3, 2, 4|], ~id=(module IntCmp))
-
-s0->Belt.MutableSet.toArray; /* [|1, 2, 3, 4|] */
-```
-
-## fromSortedArrayUnsafe
-
-```re sig
-let fromSortedArrayUnsafe: (array('value), ~id: id('value, 'id)) => t('value, 'id);
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## copy
-
-```re sig
-let copy: t('value, 'id) => t('value, 'id);
-```
-
-Returns copy of a set.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.fromArray([|1, 3, 2, 4|], ~id=(module IntCmp))
-
-let copied = s0->Belt.MutableSet.copy;
-copied->Belt.MutableSet.toArray /* [|1, 2, 3, 4|] */
-```
-
-## isEmpty
-
-```re sig
-let isEmpty: t('a, 'b) => bool;
-```
-
-Checks if set is empty.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let empty = Belt.MutableSet.fromArray([||], ~id=(module IntCmp));
-let notEmpty = Belt.MutableSet.fromArray([|1|],~id=(module IntCmp));
-
-Belt.MutableSet.isEmpty(empty); /* true */
-Belt.MutableSet.isEmpty(notEmpty); /* false */
-```
-
-## has
-
-```re sig
-let has: (t('value, 'a), 'value) => bool;
-```
-
-Checks if element exists in set.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let set = Belt.MutableSet.fromArray([|1, 4, 2, 5|], ~id=(module IntCmp));
-
-set->Belt.MutableSet.has(3) /* false */
-set->Belt.MutableSet.has(1) /* true */
-```
-
-## add
-
-```re sig
-let add: (t('value, 'id), 'value) => unit;
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.make(~id=(module IntCmp));
-s0->Belt.MutableSet.add(1);
-s0->Belt.MutableSet.add(2);
-s0->Belt.MutableSet.add(2);
-
-s0->Belt.MutableSet.toArray; /* [|1, 2|] */
-```
-
-## addCheck
-
-```re sig
-let addCheck: (t('value, 'id), 'value) => bool;
-```
-
-## mergeMany
-
-```re sig
-let mergeMany: (t('value, 'id), array('value)) => unit;
-```
-
-Adds each element of array to set.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let set = Belt.MutableSet.make(~id=(module IntCmp));
-
-set->Belt.MutableSet.mergeMany([|5, 4, 3, 2, 1|]);
-set->Belt.MutableSet.toArray; /* [|1, 2, 3, 4, 5|] */
-```
-
-## remove
-
-```re sig
-let remove: (t('value, 'id), 'value) => unit;
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.fromArray([|2,3,1,4,5|], ~id=(module IntCmp));
-s0->Belt.MutableSet.remove(1);
-s0->Belt.MutableSet.remove(3);
-s0->Belt.MutableSet.remove(3);
-
-s0->Belt.MutableSet.toArray; /* [|2,4,5|] */
-```
-
-## removeCheck
-
-```re sig
-let removeCheck: (t('value, 'id), 'value) => bool;
-```
-
-## removeMany
-
-```re sig
-let removeMany: (t('value, 'id), array('value)) => unit;
-```
-
-Removes each element of array from set.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let set = Belt.MutableSet.fromArray([|1, 2, 3, 4|],~id=(module IntCmp));
-
-set->Belt.MutableSet.removeMany([|5, 4, 3, 2, 1|]);
-set->Belt.MutableSet.toArray; /* [||] */
-```
-
-## union
-
-```re sig
-let union: (t('value, 'id), t('value, 'id)) => t('value, 'id);
-```
-
-Returns union of two sets.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.fromArray([|5,2,3,5,6|], ~id=(module IntCmp));
-let s1 = Belt.MutableSet.fromArray([|5,2,3,1,5,4|], ~id=(module IntCmp));
-let union = Belt.MutableSet.union(s0, s1);
-union->Belt.MutableSet.toArray; /* [|1,2,3,4,5,6|] */
-```
-
-## intersect
-
-```re sig
-let intersect: (t('value, 'id), t('value, 'id)) => t('value, 'id);
-```
-
-Returns intersection of two sets.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.fromArray([|5,2,3,5,6|], ~id=(module IntCmp));
-let s1 = Belt.MutableSet.fromArray([|5,2,3,1,5,4|], ~id=(module IntCmp));
-let intersect = Belt.MutableSet.intersect(s0, s1);
-intersect->Belt.MutableSet.toArray; /* [|2,3,5|] */
-```
-
-## diff
-
-```re sig
-let diff: (t('value, 'id), t('value, 'id)) => t('value, 'id);
-```
-
-Returns elements from first set, not existing in second set.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.fromArray([|5,2,3,5,6|], ~id=(module IntCmp));
-let s1 = Belt.MutableSet.fromArray([|5,2,3,1,5,4|], ~id=(module IntCmp));
-Belt.MutableSet.toArray(Belt.MutableSet.diff(s0, s1)); /* [|6|] */
-Belt.MutableSet.toArray(Belt.MutableSet.diff(s1,s0)); /* [|1,4|] */
-```
-
-## subset
-
-```re sig
-let subset: (t('value, 'id), t('value, 'id)) => bool;
-```
-
-Checks if second set is subset of first set.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.fromArray([|5,2,3,5,6|], ~id=(module IntCmp));
-let s1 = Belt.MutableSet.fromArray([|5,2,3,1,5,4|], ~id=(module IntCmp));
-let s2 = Belt.MutableSet.intersect(s0, s1);
-Belt.MutableSet.subset(s2, s0); /* true */
-Belt.MutableSet.subset(s2, s1); /* true */
-Belt.MutableSet.subset(s1, s0); /* false */
-```
-
-## cmp
-
-```re sig
-let cmp: (t('value, 'id), t('value, 'id)) => int;
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```re sig
-let eq: (t('value, 'id), t('value, 'id)) => bool;
-```
-
-Checks if two sets are equal.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.fromArray([|5,2,3|], ~id=(module IntCmp));
-let s1 = Belt.MutableSet.fromArray([|3,2,5|], ~id=(module IntCmp));
-
-Belt.MutableSet.eq(s0, s1); /* true */
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t('value, 'id), [@bs] ('value => unit)) => unit;
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```re sig
-let forEach: (t('value, 'id), 'value => unit) => unit;
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.fromArray([|5,2,3,5,6|], ~id=(module IntCmp));
-let acc = ref([]);
-s0->Belt.MutableSet.forEach(x => {
-  acc := Belt.List.add(acc^, x)
-});
-acc; /* [6,5,3,2] */
-```
-
-## reduceU
-
-```re sig
-let reduceU: (t('value, 'id), 'a, [@bs] (('a, 'value) => 'a)) => 'a;
-```
-
-## reduce
-
-```re sig
-let reduce: (t('value, 'id), 'a, ('a, 'value) => 'a) => 'a;
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.fromArray([|5,2,3,5,6|], ~id=(module IntCmp));
-s0->Belt.MutableSet.reduce([], (acc, element) =>
-  acc->Belt.List.add(element)
-); /* [6,5,3,2] */
-```
-
-## everyU
-
-```re sig
-let everyU: (t('value, 'id), [@bs] ('value => bool)) => bool;
-```
-
-## every
-
-```re sig
-let every: (t('value, 'id), 'value => bool) => bool;
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let isEven = x => x mod 2 == 0;
-
-let s0 = Belt.MutableSet.fromArray([|2,4,6,8|], ~id=(module IntCmp));
-s0->Belt.MutableSet.every(isEven); /* true */
-```
-
-## someU
-
-```re sig
-let someU: (t('value, 'id), [@bs] ('value => bool)) => bool;
-```
-
-## some
-
-```re sig
-let some: (t('value, 'id), 'value => bool) => bool;
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let isOdd = x => x mod 2 != 0;
-
-let s0 = Belt.MutableSet.fromArray([|1,2,4,6,8|], ~id=(module IntCmp));
-s0->Belt.MutableSet.some(isOdd); /* true */
-```
-
-## keepU
-
-```re sig
-let keepU: (t('value, 'id), [@bs] ('value => bool)) => t('value, 'id);
-```
-
-## keep
-
-```re sig
-let keep: (t('value, 'id), 'value => bool) => t('value, 'id);
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let isEven = x => x mod 2 == 0;
-
-let s0 = Belt.MutableSet.fromArray([|1,2,3,4,5|], ~id=(module IntCmp));
-let s1 = s0->Belt.MutableSet.keep(isEven);
-
-s1->Belt.MutableSet.toArray; /* [|2, 4|] */
-```
-
-## partitionU
-
-```re sig
-let partitionU: (t('value, 'id), [@bs] ('value => bool)) => (t('value, 'id), t('value, 'id));
-```
-
-## partition
-
-```re sig
-let partition: (t('value, 'id), 'value => bool) => (t('value, 'id), t('value, 'id));
-```
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let isOdd = x => x mod 2 != 0;
-
-let s0 = Belt.MutableSet.fromArray([|1,2,3,4,5|], ~id=(module IntCmp));
-let (s1, s2) = s0->Belt.MutableSet.partition(isOdd);
-
-s1->Belt.MutableSet.toArray; /* [|1,3,5|] */
-s2->Belt.MutableSet.toArray; /* [|2,4|] */
-```
-
-## size
-
-```re sig
-let size: t('value, 'id) => int;
-```
-
-Returns size of the set.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.fromArray([|1,2,3,4|], ~id=(module IntCmp));
-
-s0->Belt.MutableSet.size; /* 4 */
-```
-
-## toList
-
-```re sig
-let toList: t('value, 'id) => list('value);
-```
-
-Returns list of ordered set elements.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.fromArray([|3,2,1,5|], ~id=(module IntCmp));
-
-s0->Belt.MutableSet.toList; /* [1,2,3,5] */
-```
-
-## toArray
-
-```re sig
-let toArray: t('value, 'id) => array('value);
-```
-
-Returns array of ordered set elements.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.fromArray([|3,2,1,5|], ~id=(module IntCmp));
-
-s0->Belt.MutableSet.toArray; /* [|1,2,3,5|] */
-```
-
-## minimum
-
-```re sig
-let minimum: t('value, 'id) => option('value);
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.make(~id=(module IntCmp));
-let s1 = Belt.MutableSet.fromArray([|3,2,1,5|], ~id=(module IntCmp));
-
-s0->Belt.MutableSet.minimum; /* None */
-s1->Belt.MutableSet.minimum; /* Some(1) */
-```
-
-## minUndefined
-
-```re sig
-let minUndefined: t('value, 'id) => Js.undefined('value);
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.make(~id=(module IntCmp));
-let s1 = Belt.MutableSet.fromArray([|3,2,1,5|], ~id=(module IntCmp));
-
-s0->Belt.MutableSet.minUndefined; /* undefined */
-s1->Belt.MutableSet.minUndefined; /* 1 */
-```
-
-## maximum
-
-```re sig
-let maximum: t('value, 'id) => option('value);
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.make(~id=(module IntCmp));
-let s1 = Belt.MutableSet.fromArray([|3,2,1,5|], ~id=(module IntCmp));
-
-s0->Belt.MutableSet.maximum; /* None */
-s1->Belt.MutableSet.maximum; /* Some(5) */
-```
-
-## maxUndefined
-
-```re sig
-let maxUndefined: t('value, 'id) => Js.undefined('value);
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.make(~id=(module IntCmp));
-let s1 = Belt.MutableSet.fromArray([|3,2,1,5|], ~id=(module IntCmp));
-
-s0->Belt.MutableSet.maxUndefined; /* undefined */
-s1->Belt.MutableSet.maxUndefined; /* 5 */
-```
-
-## get
-
-```re sig
-let get: (t('value, 'id), 'value) => option('value);
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.fromArray([|1,2,3,4,5|], ~id=(module IntCmp));
-
-s0->Belt.MutableSet.get(3); /* Some(3) */
-s0->Belt.MutableSet.get(20); /* None */
-```
-
-## getUndefined
-
-```re sig
-let getUndefined: (t('value, 'id), 'value) => Js.undefined('value);
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```re sig
-let getExn: (t('value, 'id), 'value) => 'value;
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```re sig
-let split: (t('value, 'id), 'value) => ((t('value, 'id), t('value, 'id)), bool);
-```
-
-Returns a tuple `((smaller, larger), present)`, `present` is true when element exist in set.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.MutableSet.fromArray([|1,2,3,4,5|], ~id=(module IntCmp));
-
-let ((smaller, larger), present) = s0->Belt.MutableSet.split(3);
-
-present; /* true */
-smaller->Belt.MutableSet.toArray; /* [|1,2|] */
-larger->Belt.MutableSet.toArray; /* [|4,5|] */
-
-```
-
-## checkInvariantInternal
-
-```re sig
-let checkInvariantInternal: t('a, 'b) => unit;
-```
-
-**raise** when invariant is not held
diff --git a/pages/docs/manual/v8.0.0/api/belt/mutable-stack.mdx b/pages/docs/manual/v8.0.0/api/belt/mutable-stack.mdx
deleted file mode 100644
index a28a3fe80..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/mutable-stack.mdx
+++ /dev/null
@@ -1,105 +0,0 @@
-# MutableStack
-
-<Intro>
-
-First in last out stack. This module implements stacks, with in-place modification.
-
-</Intro>
-
-## t
-
-```
-type t('a);
-```
-
-## make
-
-```
-let make: unit => t('a);
-```
-
-Returns a new stack, initially empty.
-
-## clear
-
-```
-let clear: t('a) => unit;
-```
-
-Discard all elements from the stack.
-
-## copy
-
-```
-let copy: t('a) => t('a);
-```
-
-`copy(x)` O(1) operation, return a new stack.
-
-## push
-
-```
-let push: (t('a), 'a) => unit;
-```
-
-## popUndefined
-
-```
-let popUndefined: t('a) => Js.undefined('a);
-```
-
-## pop
-
-```
-let pop: t('a) => option('a);
-```
-
-## topUndefined
-
-```
-let topUndefined: t('a) => Js.undefined('a);
-```
-
-## top
-
-```
-let top: t('a) => option('a);
-```
-
-## isEmpty
-
-```
-let isEmpty: t('a) => bool;
-```
-
-## size
-
-```
-let size: t('a) => int;
-```
-
-## forEachU
-
-```
-let forEachU: (t('a), [@bs] ('a => unit)) => unit;
-```
-
-## forEach
-
-```
-let forEach: (t('a), 'a => unit) => unit;
-```
-
-## dynamicPopIterU
-
-```
-let dynamicPopIterU: (t('a), [@bs] ('a => unit)) => unit;
-```
-
-## dynamicPopIter
-
-```
-let dynamicPopIter: (t('a), 'a => unit) => unit;
-```
-
-`dynamicPopIter(s, f)` apply `f` to each element of `s`. The item is poped before applying `f`, `s` will be empty after this opeartion. This function is useful for worklist algorithm.
diff --git a/pages/docs/manual/v8.0.0/api/belt/option.mdx b/pages/docs/manual/v8.0.0/api/belt/option.mdx
deleted file mode 100644
index 47da1aeeb..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/option.mdx
+++ /dev/null
@@ -1,256 +0,0 @@
-# Option
-
-<Intro>
-
-In Belt we represent the existence and nonexistence of a value by wrapping it
-with the `option` type.  In order to make it a bit more convenient to work with
-option-types, Belt provides utility-functions for it.
-
-The `option` type is a part of the Reason / OCaml standard library which is defined like this:
-
-</Intro>
-
-```re sig
-type option('a) = None | Some('a)
-```
-
-```re example
-let someString: option(string) = Some("foo");
-```
-
-## getExn
-
-```re sig
-let getExn: option('a) => 'a;
-```
-
-Raises an Error in case `None` is provided. Use with care.
-
-```re example
-Belt.Option.getExn(Some(3)); /* 3 */
-
-Belt.Option.getExn(None); /* Raises an Error */
-```
-
-## mapWithDefault
-
-```re sig
-let mapWithDefault: (option('a), 'b, 'a => 'b) => 'b;
-```
-
-If `optionValue` is of `Some(value)`,
-this function returns that value applied with `f`, in other words `f(value)`.
-
-If `optionValue` is `None`, the default is returned.
-
-```re example
-let someValue = Some(3);
-someValue->Belt.Option.mapWithDefault(0, x => x + 5); /* 8 */
-
-let noneValue = None;
-noneValue->Belt.Option.mapWithDefault(0, x => x + 5); /* 0 */
-```
-
-## mapWithDefaultU
-
-```re sig
-let mapWithDefaultU: (option('a), 'b, (.'a => 'b)) => 'b;
-```
-
-Uncurried version of [mapWithDefault](#mapWithDefault).
-
-## map
-
-```re sig
-let map: (option('a), 'a => 'b) => option('b);
-```
-
-If `optionValue` is `Some(value)` this returns `f(value)`, otherwise it returns `None`.
-
-```re example
-Belt.Option.map(Some(3), x => x * x); /* Some(9) */
-
-Belt.Option.map(None, x => x * x); /* None */
-```
-
-## mapU
-
-```re sig
-let mapU: (option('a), [@bs] ('a => 'b)) => option('b);
-```
-
-Uncurried version of [map](#map).
-
-## flatMap
-
-```re sig
-let flatMap: (option('a), 'a => option('b)) => option('b);
-```
-
-If `optionValue` is `Some(value)`, returns `f(value)`, otherwise returns
-`None`.<br/>
-The function `f` must have a return type of `option('a)`.
-
-```re example
-let addIfAboveOne = value =>
-  if (value > 1) {
-    Some(value + 1);
-  } else {
-    None;
-  };
-
-Belt.Option.flatMap(Some(2), addIfAboveOne); /* Some(3) */
-
-Belt.Option.flatMap(Some(-4), addIfAboveOne); /* None */
-
-Belt.Option.flatMap(None, addIfAboveOne); /* None */
-```
-
-## flatMapU
-
-```re sig
-let flatMapU: (option('a), [@bs] ('a => option('b))) => option('b);
-```
-
-Uncurried version of flatMap.
-
-## getWithDefault
-
-```re sig
-let getWithDefault: (option('a), 'a) => 'a;
-```
-
-If `optionalValue` is `Some(value)`, returns `value`, otherwise default.
-
-```re example
-Belt.Option.getWithDefault(None, "Banana"); /* Banana */
-
-Belt.Option.getWithDefault(Some("Apple"), "Banana"); /* Apple */
-```
-
-```re example
-let greet = (firstName: option(string)) =>
-  Belt.Option.("Greetings " ++ firstName->getWithDefault("Anonymous"));
-
-Some("Jane")->greet; /* "Greetings Jane" */
-
-None->greet; /* "Greetings Anonymous" */
-```
-
-```re example
-Belt.Option.getWithDefault(Some(1812), 1066); /* 1812 */
-
-Belt.Option.getWithDefault(None, 1066); /* 1066 */
-```
-
-## isSome
-
-```re sig
-let isSome: option('a) => bool;
-```
-
-Returns `true` if the argument is `Some(value)`, `false` otherwise.
-
-```re example
-Belt.Option.isSome(None); /* false */
-
-Belt.Option.isSome(Some(1)); /* true */
-```
-
-## isNone
-
-```re sig
-let isNone: option('a) => bool;
-```
-
-Returns `true` if the argument is `None`, `false` otherwise.
-
-```re example
-Belt.Option.isNone(None); /* true */
-
-Belt.Option.isNone(Some(1)); /* false */
-```
-
-## eq
-
-```re sig
-let eq: (option('a), option('b), ('a, 'b) => bool) => bool;
-```
-
-Evaluates two optional values for equality with respect to a predicate
-function. If both `optValue1` and `optValue2` are `None`, returns `true`.
-If one of the arguments is `Some(value)` and the other is `None`, returns
-`false`.
-
-If arguments are `Some(value1)` and `Some(value2)`, returns the result of
-`predicate(value1, value2)`; the predicate function must return a bool.
-
-```re example
-let clockEqual = (a, b) => a mod 12 == b mod 12;
-
-open Belt.Option;
-
-eq(Some(3), Some(15), clockEqual); /* true */
-
-eq(Some(3), None, clockEqual); /* false */
-
-eq(None, Some(3), clockEqual); /* false */
-
-eq(None, None, clockEqual); /* true */
-```
-
-## eqU
-
-```re sig
-let eqU: (option('a), option('b), (.'a, 'b) => bool) => bool;
-```
-
-Uncurried version of [eq](#eq).
-
-## cmp
-
-```re sig
-let cmp: (option('a), option('b), ('a, 'b) => int) => int;
-```
-
-`cmp(optValue1, optValue2, comparisonFunction)` compares two optional values
-with respect to given `comparisonFunction`.
-
-If both `optValue1` and `optValue2` are `None`, it returns `0`.
-
-If the first argument is `Some(value1)` and the second is `None`, returns `1`
-(something is greater than nothing).
-
-If the first argument is `None` and the second is `Some(value2)`, returns `-1`
-(nothing is less than something).
-
-If the arguments are `Some(value1)` and `Some(value2)`, returns the result of
-`comparisonFunction(value1, value2)`; comparisonFunction takes two arguments
-and returns `-1` if the first argument is less than the second, `0` if the
-arguments are equal, and `1` if the first argument is greater than the second.
-
-```re example
-let clockCompare = (a, b) => compare(a mod 12, b mod 12);
-
-open Belt.Option;
-
-cmp(Some(3), Some(15), clockCompare); /* 0 */
-
-cmp(Some(3), Some(14), clockCompare); /* 1 */
-
-cmp(Some(2), Some(15), clockCompare); /* (-1) */
-
-cmp(None, Some(15), clockCompare); /* (-1) */
-
-cmp(Some(14), None, clockCompare); /* 1 */
-
-cmp(None, None, clockCompare); /* 0 */
-```
-
-## cmpU
-
-```re sig
-let cmpU: (option('a), option('b), ((.'a, 'b) => int)) => int;
-```
-
-Uncurried version of [cmp](#cmp).
diff --git a/pages/docs/manual/v8.0.0/api/belt/range.mdx b/pages/docs/manual/v8.0.0/api/belt/range.mdx
deleted file mode 100644
index 08051b9fc..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/range.mdx
+++ /dev/null
@@ -1,130 +0,0 @@
-# Range
-
-<Intro>
-
-A small utility module to provide inclusive range operations for `[start,
-finish]`.  Internally it is relying on loops instead of creating new arrays,
-which makes it pretty performant and memory friendly.
-
-</Intro>
-
-## forEachU
-
-```re sig
-let forEachU: (int, int, [@bs] (int => unit)) => unit;
-```
-
-## forEach
-
-```re sig
-let forEach: (int, int, int => unit) => unit;
-```
-
-`forEach(start, finish, action);`
-
-equivalent to `Belt.Array.(forEach(range(start, finish), action));`
-
-```re example
-Belt.Range.forEach(0, 4, (i) => Js.log(i));
-
-/**
- * prints:
- *   0
- *   1
- *   2
- *   3
- *   4
- */
-```
-
-## everyU
-
-```re sig
-let everyU: (int, int, [@bs] (int => bool)) => bool;
-```
-
-## every
-
-```re sig
-let every: (int, int, int => bool) => bool;
-```
-
-`every(start, finish, p);`
-
-equivalent to `Belt.Array.(every(range(start, finish), p));`
-
-```re example
-Belt.Range.every(0, 4, (i) => i < 5); /* true */
-
-Belt.Range.every(0, 4, (i) => i < 4); /* false */
-```
-
-## everyByU
-
-```re sig
-let everyByU: (int, int, ~step: int, [@bs] (int => bool)) => bool;
-```
-
-## everyBy
-
-```re sig
-let everyBy: (int, int, ~step: int, int => bool) => bool;
-```
-
-`everyBy(start, finish, ~step, p);`
-
-See `Belt_Array.rangeBy`
-
-equivalent to `Belt.Array.(every(rangeBy(start, finish, ~step), p));`
-
-```re example
-Belt.Range.everyBy(0, 4, ~step=1, (i) => i mod 2 === 0); /* false */
-
-Belt.Range.everyBy(0, 4, ~step=2, (i) => i mod 2 === 0); /* true */
-```
-
-## someU
-
-```re sig
-let someU: (int, int, [@bs] (int => bool)) => bool;
-```
-
-## some
-
-```re sig
-let some: (int, int, int => bool) => bool;
-```
-
-`some(start, finish, p);`
-
-equivalent to `Belt.Array.(some(range(start, finish), p));`
-
-```re example
-Belt.Range.some(0, 4, (i) => i > 5); /* false */
-
-Belt.Range.some(0, 4, (i) => i > 2); /* true */
-```
-
-## someByU
-
-```re sig
-let someByU: (int, int, ~step: int, [@bs] (int => bool)) => bool;
-```
-
-## someBy
-
-```re sig
-let someBy: (int, int, ~step: int, int => bool) => bool;
-```
-
-`someBy(start, finish, ~step, p);`
-
-See `Belt_Array.rangeBy`
-
-equivalent to `Belt.Array.(some(rangeBy(start, finish, ~step), p));`
-
-```re example
-Belt.Range.someBy(1, 5, ~step=2, (i) => i mod 2 === 0); /* false */
-
-Belt.Range.someBy(0, 4, ~step=2, (i) => i mod 2 === 0); /* true */
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/result.mdx b/pages/docs/manual/v8.0.0/api/belt/result.mdx
deleted file mode 100644
index be9286410..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/result.mdx
+++ /dev/null
@@ -1,242 +0,0 @@
-# Result
-
-<Intro>
-
-Result types are really useful to describe the result of a certain operation
-without relying on exceptions or `option` types.
-
-This module gives you useful utilities to create and combine `Result` data.
-
-</Intro>
-
-## t
-
-```re sig
-type t('a, 'b) =
-  | Ok('a)
-  | Error('b);
-```
-
-The type `Result.t(result, err)` describes a variant of two states:
-`Ok(someResult)` represents a successful operation, whereby
-``Error(someError)` signals an erronous operation.
-
-In this concrete example, we are defining our own `Result` type to reflect an HTTP like
-query operation:
-
-```re example
-type responseError = NotAvailable | NotFound;
-type queryResult = Belt.Result.t(string, responseError);
-
-let failQueryUser = (username: string): queryResult => {
-  Error(NotAvailable)
-};
-```
-
-## getExn
-
-```re sig
-let getExn: t('a, 'b) => 'a;
-```
-
-`getExn(res)`: when `res` is `Ok(n)`, returns `n` when `res` is `Error(m)`, raise an exception
-
-```re example
-Belt.Result.getExn(Belt.Result.Ok(42)) == 42;
-
-Belt.Result.getExn(Belt.Result.Error("Invalid data")); /* raises exception */
-```
-
-## mapWithDefaultU
-
-```re sig
-let mapWithDefaultU: (t('a, 'c), 'b, (.'a => 'b)) => 'b;
-```
-
-## mapWithDefault
-
-```re sig
-let mapWithDefault: (t('a, 'c), 'b, 'a => 'b) => 'b;
-```
-
-`mapWithDefault(res, default, f);`: When res is `Ok(n)`, returns `f(n)`,
-otherwise `default`.
-
-```re example
-let ok = Belt.Result.Ok(42)
-Belt.Result.mapWithDefault(ok, 0, (x) => x / 2) == 21;
-
-let error = Belt.Result.Error("Invalid data")
-Belt.Result.mapWithDefault(error, 0, (x) => x / 2) == 0;
-```
-
-## mapU
-
-```re sig
-let mapU: (t('a, 'c), [@bs] ('a => 'b)) => t('b, 'c);
-```
-
-## map
-
-```re sig
-let map: (t('a, 'c), 'a => 'b) => t('b, 'c);
-```
-
-`map(res, f)`: When res is `Ok(n)`, returns `Ok(f(n))`. Otherwise returns res
-unchanged. Function `f` takes a value of the same type as `n` and returns an
-ordinary value.
-
-```re example
-let f = (x) => sqrt(float_of_int(x));
-
-Belt.Result.map(Ok(64), f) == Ok(8.0);
-
-Belt.Result.map(Error("Invalid data"), f) == Error("Invalid data");
-```
-
-## flatMapU
-
-```re sig
-let flatMapU: (t('a, 'c), [@bs] ('a => t('b, 'c))) => t('b, 'c);
-```
-
-## flatMap
-
-```re sig
-let flatMap: (t('a, 'c), 'a => t('b, 'c)) => t('b, 'c);
-```
-
-`flatMap(res, f)`: When res is `Ok(n)`, returns `f(n)`. Otherwise, returns res
-unchanged. Function `f` takes a value of the same type as `n` and returns a
-`Belt.Result`.
-
-```re example
-let recip = (x) =>
-  if (x !== 0.0) {
-    Belt.Result.Ok(1.0 /. x);
-  } else {
-    Belt.Result.Error("Divide by zero");
-  };
-
-Belt.Result.flatMap(Ok(2.0), recip) == Ok(0.5);
-
-Belt.Result.flatMap(Ok(0.0), recip) == Error("Divide by zero");
-
-Belt.Result.flatMap(Error("Already bad"), recip) == Error("Already bad");
-```
-
-## getWithDefault
-
-```re sig
-let getWithDefault: (t('a, 'b), 'a) => 'a;
-```
-
-`getWithDefault(res, defaultValue)`: If `res` is `Ok(n)`, returns `n`,
-otherwise `default`
-
-```re example
-Belt.Result.getWithDefault(Ok(42), 0) == 42;
-
-Belt.Result.getWithDefault(Error("Invalid Data"), 0) == 0;
-```
-
-## isOk
-
-```re sig
-let isOk: t('a, 'b) => bool;
-```
-
-`isOk(res)`: Returns `true` if `res` is of the form `Ok(n)`, `false` if it is
-the `Error(e)` variant.
-
-## isError
-
-```re sig
-let isError: t('a, 'b) => bool;
-```
-
-`isError(res)`: Returns `true` if `res` is of the form `Error(e)`, `false` if
-it is the `Ok(n)` variant.
-
-## eqU
-
-```re sig
-let eqU: (t('a, 'c), t('b, 'd), (.'a, 'b) => bool) => bool;
-```
-
-## eq
-
-```re sig
-let eq: (t('a, 'c), t('b, 'd), ('a, 'b) => bool) => bool;
-```
-
-`eq(res1, res2, f)`: Determine if two `Belt.Result` variables are equal with
-respect to an equality function. If `res1` and `res2` are of the form `Ok(n)`
-and `Ok(m)`, return the result of `f(n, m)`. If one of `res1` and `res2` are of
-the form `Error(e)`, return false If both `res1` and `res2` are of the form
-`Error(e)`, return true
-
-```re example
-let good1 = Belt.Result.Ok(42);
-
-let good2 = Belt.Result.Ok(32);
-
-let bad1 = Belt.Result.Error("invalid");
-
-let bad2 = Belt.Result.Error("really invalid");
-
-let mod10equal = (a, b) => a mod 10 === b mod 10;
-
-Belt.Result.eq(good1, good2, mod10equal) == true;
-
-Belt.Result.eq(good1, bad1, mod10equal) == false;
-
-Belt.Result.eq(bad2, good2, mod10equal) == false;
-
-Belt.Result.eq(bad1, bad2, mod10equal) == true;
-```
-
-## cmpU
-
-```re sig
-let cmpU: (t('a, 'c), t('b, 'd), (.'a, 'b) => int) => int;
-```
-
-## cmp
-
-```re sig
-let cmp: (t('a, 'c), t('b, 'd), ('a, 'b) => int) => int;
-```
-
-`cmp(res1, res2, f)`: Compare two `Belt.Result` variables with respect to a
-comparison function. The comparison function returns -1 if the first variable
-is "less than" the second, 0 if the two variables are equal, and 1 if the first
-is "greater than" the second.
-
-If `res1` and `res2` are of the form `Ok(n)` and `Ok(m)`, return the result of
-`f(n, m)`. If `res1` is of the form `Error(e)` and `res2` of the form `Ok(n)`,
-return -1 (nothing is less than something) If `res1` is of the form `Ok(n)` and
-`res2` of the form `Error(e)`, return 1 (something is greater than nothing) If
-both `res1` and `res2` are of the form `Error(e)`, return 0 (equal)
-
-```re example
-let good1 = Belt.Result.Ok(59);
-
-let good2 = Belt.Result.Ok(37);
-
-let bad1 = Belt.Result.Error("invalid");
-
-let bad2 = Belt.Result.Error("really invalid");
-
-let mod10cmp = (a, b) => Pervasives.compare(a mod 10, b mod 10);
-
-Belt.Result.cmp(Ok(39), Ok(57), mod10cmp) == 1;
-
-Belt.Result.cmp(Ok(57), Ok(39), mod10cmp) == (-1);
-
-Belt.Result.cmp(Ok(39), Error("y"), mod10cmp) == 1;
-
-Belt.Result.cmp(Error("x"), Ok(57), mod10cmp) == (-1);
-
-Belt.Result.cmp(Error("x"), Error("y"), mod10cmp) == 0;
-```
diff --git a/pages/docs/manual/v8.0.0/api/belt/set-dict.mdx b/pages/docs/manual/v8.0.0/api/belt/set-dict.mdx
deleted file mode 100644
index 43a783e79..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/set-dict.mdx
+++ /dev/null
@@ -1,708 +0,0 @@
-# SetDict
-
-<Intro>
-
-This module seprate identity from data, it is a bit more verboe but slightly more efficient due to the fact that there is no need to pack identity and data back after each operation
-
-</Intro>
-
-## t
-
-```re sig
-type t('value, 'identity);
-```
-
-`'value` is the element type
-
-`'identity` the identity of the collection
-
-## cmp
-
-```re sig
-type cmp('value, 'id) = BeltId.cmp('value, 'id);
-```
-
-Type of compare function.
-
-## empty
-
-```re sig
-let empty: t('value, 'id);
-```
-
-```re example
-let s0 = Belt.Set.Dict.empty;
-```
-
-## fromArray
-
-```re sig
-let fromArray: (array('value), ~cmp: cmp('value, 'id)) => t('value, 'id);
-```
-
-Creates new set from array of elements.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.fromArray([|1, 3, 2, 4|], ~cmp=IntCmp.cmp);
-
-s0->Belt.Set.Dict.toArray; /* [|1, 2, 3, 4|] */
-```
-
-## fromSortedArrayUnsafe
-
-```re sig
-let fromSortedArrayUnsafe: array('value) => t('value, 'id);
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## isEmpty
-
-```re sig
-let isEmpty: t('a, 'b) => bool;
-```
-
-Checks if set is empty.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let empty = Belt.Set.Dict.fromArray([||], ~cmp=IntCmp.cmp);
-let notEmpty = Belt.Set.Dict.fromArray([|1|], ~cmp=IntCmp.cmp);
-
-Belt.Set.Dict.isEmpty(empty); /* true */
-Belt.Set.Dict.isEmpty(notEmpty); /* false */
-```
-
-## has
-
-```re sig
-let has: (t('value, 'id), 'value, ~cmp: cmp('value, 'id)) => bool;
-```
-
-Checks if element exists in set.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let set = Belt.Set.Dict.fromArray([|1, 4, 2, 5|], ~cmp=IntCmp.cmp);
-
-set->Belt.Set.Dict.has(3) /* false */
-set->Belt.Set.Dict.has(1) /* true */
-```
-
-## add
-
-```re sig
-let add: (t('value, 'id), 'value, ~cmp: cmp('value, 'id)) => t('value, 'id);
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.empty;
-let s1 = s0->Belt.Set.Dict.add(1, ~cmp=IntCmp.cmp);
-let s2 = s1->Belt.Set.Dict.add(2, ~cmp=IntCmp.cmp);
-let s3 = s2->Belt.Set.Dict.add(2, ~cmp=IntCmp.cmp);
-s0->Belt.Set.Dict.toArray; /* [||] */
-s1->Belt.Set.Dict.toArray; /* [|1|] */
-s2->Belt.Set.Dict.toArray; /* [|1, 2|] */
-s3->Belt.Set.Dict.toArray; /* [|1,2 |] */
-s2 == s3; /* true */
-```
-
-## mergeMany
-
-```re sig
-let mergeMany: (t('value, 'id), array('value), ~cmp: cmp('value, 'id)) => t('value, 'id);
-```
-
-Adds each element of array to set. Unlike [add](#add), the reference of return value might be changed even if all values in array already exist in set
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let set = Belt.Set.Dict.empty;
-
-let newSet = set->Belt.Set.Dict.mergeMany([|5, 4, 3, 2, 1|], ~cmp=IntCmp.cmp);
-newSet->Belt.Set.Dict.toArray; /* [|1, 2, 3, 4, 5|] */
-```
-
-## remove
-
-```re sig
-let remove: (t('value, 'id), 'value, ~cmp: cmp('value, 'id)) => t('value, 'id);
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.fromArray([|2,3,1,4,5|], ~cmp=IntCmp.cmp);
-let s1 = s0->Belt.Set.Dict.remove(1, ~cmp=IntCmp.cmp);
-let s2 = s1->Belt.Set.Dict.remove(3, ~cmp=IntCmp.cmp);
-let s3 = s2->Belt.Set.Dict.remove(3, ~cmp=IntCmp.cmp);
-
-s1->Belt.Set.Dict.toArray; /* [|2,3,4,5|] */
-s2->Belt.Set.Dict.toArray; /* [|2,4,5|] */
-s2 == s3; /* true */
-```
-
-## removeMany
-
-```re sig
-let removeMany: (t('value, 'id), array('value), ~cmp: cmp('value, 'id)) => t('value, 'id);
-```
-
-Removes each element of array from set. Unlike [remove](#remove), the reference of return value might be changed even if any values in array not existed in set.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let set = Belt.Set.Dict.fromArray([|1, 2, 3, 4|],~cmp=IntCmp.cmp);
-
-let newSet = set->Belt.Set.Dict.removeMany([|5, 4, 3, 2, 1|], ~cmp=IntCmp.cmp);
-newSet->Belt.Set.Dict.toArray; /* [||] */
-```
-
-## union
-
-```re sig
-let union: (t('value, 'id), t('value, 'id), ~cmp: cmp('value, 'id)) => t('value, 'id);
-```
-
-Returns union of two sets.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.fromArray([|5,2,3,5,6|], ~cmp=IntCmp.cmp);
-let s1 = Belt.Set.Dict.fromArray([|5,2,3,1,5,4|], ~cmp=IntCmp.cmp);
-let union = Belt.Set.Dict.union(s0, s1, ~cmp=IntCmp.cmp);
-union->Belt.Set.Dict.toArray; /* [|1,2,3,4,5,6|] */
-```
-
-## intersect
-
-```re sig
-let intersect: (t('value, 'id), t('value, 'id), ~cmp: cmp('value, 'id)) => t('value, 'id);
-```
-
-Returns intersection of two sets.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.fromArray([|5,2,3,5,6|], ~cmp=IntCmp.cmp);
-let s1 = Belt.Set.Dict.fromArray([|5,2,3,1,5,4|], ~cmp=IntCmp.cmp);
-let intersect = Belt.Set.Dict.intersect(s0, s1, ~cmp=IntCmp.cmp);
-intersect->Belt.Set.Dict.toArray; /* [|2,3,5|] */
-```
-
-## diff
-
-```re sig
-let diff: (t('value, 'id), t('value, 'id), ~cmp: cmp('value, 'id)) => t('value, 'id);
-```
-
-Returns elements from first set, not existing in second set.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.fromArray([|5,2,3,5,6|], ~cmp=IntCmp.cmp);
-let s1 = Belt.Set.Dict.fromArray([|5,2,3,1,5,4|], ~cmp=IntCmp.cmp);
-
-let diff1 = Belt.Set.Dict.diff(s0, s1, ~cmp=IntCmp.cmp);
-let diff2 = Belt.Set.Dict.diff(s1,s0, ~cmp=IntCmp.cmp);
-
-diff1->Belt.Set.Dict.toArray; /* [|6|] */
-diff2->Belt.Set.Dict.toArray; /* [|1,4|] */
-```
-
-## subset
-
-```re sig
-let subset: (t('value, 'id), t('value, 'id), ~cmp: cmp('value, 'id)) => bool;
-```
-
-Checks if second set is subset of first set.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.fromArray([|5,2,3,5,6|], ~cmp=IntCmp.cmp);
-let s1 = Belt.Set.Dict.fromArray([|5,2,3,1,5,4|], ~cmp=IntCmp.cmp);
-let s2 = Belt.Set.Dict.intersect(s0, s1, ~cmp=IntCmp.cmp);
-Belt.Set.Dict.subset(s2, s0, ~cmp=IntCmp.cmp); /* true */
-Belt.Set.Dict.subset(s2, s1, ~cmp=IntCmp.cmp); /* true */
-Belt.Set.Dict.subset(s1, s0, ~cmp=IntCmp.cmp); /* false */
-```
-
-## cmp
-
-```re sig
-let cmp: (t('value, 'id), t('value, 'id), ~cmp: cmp('value, 'id)) => int;
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```re sig
-let eq: (t('value, 'id), t('value, 'id), ~cmp: cmp('value, 'id)) => bool;
-```
-
-Checks if two sets are equal.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.fromArray([|5,2,3|], ~cmp=IntCmp.cmp);
-let s1 = Belt.Set.Dict.fromArray([|3,2,5|], ~cmp=IntCmp.cmp);
-
-Belt.Set.Dict.eq(s0, s1, ~cmp=IntCmp.cmp); /* true */
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t('value, 'id), [@bs] ('value => unit)) => unit;
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```re sig
-let forEach: (t('value, 'id), 'value => unit) => unit;
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.fromArray([|5,2,3,5,6|], ~cmp=IntCmp.cmp);
-let acc = ref([]);
-s0->Belt.Set.Dict.forEach(x => {
-  acc := Belt.List.add(acc^, x)
-});
-acc; /* [6,5,3,2] */
-```
-
-## reduceU
-
-```re sig
-let reduceU: (t('value, 'id), 'a, [@bs] (('a, 'value) => 'a)) => 'a;
-```
-
-## reduce
-
-```re sig
-let reduce: (t('value, 'id), 'a, ('a, 'value) => 'a) => 'a;
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.fromArray([|5,2,3,5,6|], ~cmp=IntCmp.cmp);
-s0->Belt.Set.Dict.reduce([], (acc, element) =>
-  acc->Belt.List.add(element)
-); /* [6,5,3,2] */
-```
-
-## everyU
-
-```re sig
-let everyU: (t('value, 'id), [@bs] ('value => bool)) => bool;
-```
-
-## every
-
-```re sig
-let every: (t('value, 'id), 'value => bool) => bool;
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let isEven = x => x mod 2 == 0;
-
-let s0 = Belt.Set.Dict.fromArray([|2,4,6,8|], ~cmp=IntCmp.cmp);
-s0->Belt.Set.Dict.every(isEven); /* true */
-```
-
-## someU
-
-```re sig
-let someU: (t('value, 'id), [@bs] ('value => bool)) => bool;
-```
-
-## some
-
-```re sig
-let some: (t('value, 'id), 'value => bool) => bool;
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let isOdd = x => x mod 2 != 0;
-
-let s0 = Belt.Set.Dict.fromArray([|1,2,4,6,8|], ~cmp=IntCmp.cmp);
-s0->Belt.Set.Dict.some(isOdd); /* true */
-```
-
-## keepU
-
-```re sig
-let keepU: (t('value, 'id), [@bs] ('value => bool)) => t('value, 'id);
-```
-
-## keep
-
-```re sig
-let keep: (t('value, 'id), 'value => bool) => t('value, 'id);
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let isEven = x => x mod 2 == 0;
-
-let s0 = Belt.Set.Dict.fromArray([|1,2,3,4,5|], ~cmp=IntCmp.cmp);
-let s1 = s0->Belt.Set.Dict.keep(isEven);
-
-s1->Belt.Set.Dict.toArray; /* [|2,4|] */
-```
-
-## partitionU
-
-```re sig
-let partitionU: (t('value, 'id), [@bs] ('value => bool)) => (t('value, 'id), t('value, 'id));
-```
-
-## partition
-
-```re sig
-let partition: (t('value, 'id), 'value => bool) => (t('value, 'id), t('value, 'id));
-```
-
-Returns a pair of sets, where first is the set of all the elements of set that satisfy the predicate, and second is the set of all the elements of set that do not satisfy the predicate.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let isOdd = x => x mod 2 != 0;
-
-let s0 = Belt.Set.Dict.fromArray([|1,2,3,4,5|], ~cmp=IntCmp.cmp);
-let (s1, s2) = s0->Belt.Set.Dict.partition(isOdd);
-
-s1->Belt.Set.Dict.toArray; /* [|1,3,5|] */
-s2->Belt.Set.Dict.toArray; /* [|2,4|] */
-```
-
-## size
-
-```re sig
-let size: t('value, 'id) => int;
-```
-
-Returns size of the set.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.fromArray([|1,2,3,4|], ~cmp=IntCmp.cmp);
-
-s0->Belt.Set.Dict.size; /* 4 */
-```
-
-## toList
-
-```re sig
-let toList: t('value, 'id) => list('value);
-```
-
-Returns list of ordered set elements.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.fromArray([|3,2,1,5|], ~cmp=IntCmp.cmp);
-
-s0->Belt.Set.Dict.toList; /* [1,2,3,5] */
-```
-
-## toArray
-
-```re sig
-let toArray: t('value, 'id) => array('value);
-```
-
-Returns array of ordered set elements.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.fromArray([|3,2,1,5|], ~cmp=IntCmp.cmp);
-
-s0->Belt.Set.Dict.toArray; /* [|1,2,3,5|] */
-```
-
-## minimum
-
-```re sig
-let minimum: t('value, 'id) => option('value);
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.empty;
-let s1 = Belt.Set.Dict.fromArray([|3,2,1,5|], ~cmp=IntCmp.cmp);
-
-s0->Belt.Set.Dict.minimum; /* None */
-s1->Belt.Set.Dict.minimum; /* Some(1) */
-```
-
-## minUndefined
-
-```re sig
-let minUndefined: t('value, 'id) => Js.undefined('value);
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.empty;
-let s1 = Belt.Set.Dict.fromArray([|3,2,1,5|], ~cmp=IntCmp.cmp);
-
-s0->Belt.Set.Dict.minUndefined; /* undefined */
-s1->Belt.Set.Dict.minUndefined; /* 1 */
-```
-
-## maximum
-
-```re sig
-let maximum: t('value, 'id) => option('value);
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.empty;
-let s1 = Belt.Set.Dict.fromArray([|3,2,1,5|], ~cmp=IntCmp.cmp);
-
-s0->Belt.Set.Dict.maximum; /* None */
-s1->Belt.Set.Dict.maximum; /* Some(5) */
-```
-
-## maxUndefined
-
-```re sig
-let maxUndefined: t('value, 'id) => Js.undefined('value);
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.empty;
-let s1 = Belt.Set.Dict.fromArray([|3,2,1,5|], ~cmp=IntCmp.cmp);
-
-s0->Belt.Set.Dict.maxUndefined; /* undefined */
-s1->Belt.Set.Dict.maxUndefined; /* 5 */
-```
-
-## get
-
-```re sig
-let get: (t('value, 'id), 'value, ~cmp: cmp('value, 'id)) => option('value);
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.fromArray([|1,2,3,4,5|], ~cmp=IntCmp.cmp);
-
-s0->Belt.Set.Dict.get(3, ~cmp=IntCmp.cmp); /* Some(3) */
-s0->Belt.Set.Dict.get(20, ~cmp=IntCmp.cmp); /* None */
-```
-
-## getUndefined
-
-```re sig
-let getUndefined: (t('value, 'id), 'value, ~cmp: cmp('value, 'id)) => Js.undefined('value);
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```re sig
-let getExn: (t('value, 'id), 'value, ~cmp: cmp('value, 'id)) => 'value;
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```re sig
-let split: (t('value, 'id), 'value, ~cmp: cmp('value, 'id)) => ((t('value, 'id), t('value, 'id)), bool);
-```
-
-Returns a tuple `((smaller, larger), present)`, `present` is true when element exist in set.
-
-```re example
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-
-let s0 = Belt.Set.Dict.fromArray([|1,2,3,4,5|], ~cmp=IntCmp.cmp);
-
-let ((smaller, larger), present) =
-  s0->Belt.Set.Dict.split(3, ~cmp=IntCmp.cmp);
-
-present; /* true */
-smaller->Belt.Set.Dict.toArray; /* [|1,2|] */
-larger->Belt.Set.Dict.toArray; /* [|4,5|] */
-
-```
-
-## checkInvariantInternal
-
-```re sig
-let checkInvariantInternal: t('a, 'b) => unit;
-```
-
-**raise** when invariant is not held
diff --git a/pages/docs/manual/v8.0.0/api/belt/set-int.mdx b/pages/docs/manual/v8.0.0/api/belt/set-int.mdx
deleted file mode 100644
index 451661041..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/set-int.mdx
+++ /dev/null
@@ -1,541 +0,0 @@
-# SetInt
-
-<Intro>
-
-Specalized when value type is `int`, more efficient than the generic type, its compare behavior is fixed using the built-in comparison.
-
-</Intro>
-
-## value
-
-```re sig
-type value = int;
-```
-
-The type of the set elements.
-
-## t
-
-```re sig
-type t;
-```
-
-Type of the sets.
-
-## empty
-
-```re sig
-let empty: t;
-```
-
-Empty set
-
-```re example
-let s0 = Belt.Set.Int.empty;
-```
-
-## fromArray
-
-```re sig
-let fromArray: array(value) => t;
-```
-
-Creates new set from array of elements.
-
-```re example
-let s0 = Belt.Set.Int.fromArray([|1, 3, 2, 4|])
-
-s0->Belt.Set.Int.toArray; /* [|1, 2, 3, 4|] */
-```
-
-## fromSortedArrayUnsafe
-
-```re sig
-let fromSortedArrayUnsafe: array(value) => t;
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## isEmpty
-
-```re sig
-let isEmpty: t => bool;
-```
-
-Checks if set is empty.
-
-```re example
-let empty = Belt.Set.Int.fromArray([||]);
-let notEmpty = Belt.Set.Int.fromArray([|1|]);
-
-Belt.Set.Int.isEmpty(empty); /* true */
-Belt.Set.Int.isEmpty(notEmpty); /* false */
-```
-
-## has
-
-```re sig
-let has: (t, value) => bool;
-```
-
-Checks if element exists in set.
-
-```re example
-let set = Belt.Set.Int.fromArray([|1, 4, 2, 5|]);
-
-set->Belt.Set.Int.has(3) /* false */
-set->Belt.Set.Int.has(1) /* true */
-```
-
-## add
-
-```re sig
-let add: (t, value) => t;
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```re example
-let s0 = Belt.Set.Int.empty;
-let s1 = s0->Belt.Set.Int.add(1);
-let s2 = s1->Belt.Set.Int.add(2);
-let s3 = s2->Belt.Set.Int.add(2);
-s0->Belt.Set.Int.toArray; /* [||] */
-s1->Belt.Set.Int.toArray; /* [|1|] */
-s2->Belt.Set.Int.toArray; /* [|1, 2|] */
-s3->Belt.Set.Int.toArray; /* [|1,2 |] */
-s2 == s3; /* true */
-```
-
-## mergeMany
-
-```re sig
-let mergeMany: (t, array(value)) => t;
-```
-
-Adds each element of array to set. Unlike [add](#add), the reference of return value might be changed even if all values in array already exist in set
-
-```re example
-let set = Belt.Set.Int.empty;
-
-let newSet = set->Belt.Set.Int.mergeMany([|5, 4, 3, 2, 1|]);
-newSet->Belt.Set.Int.toArray; /* [|1, 2, 3, 4, 5|] */
-```
-
-## remove
-
-```re sig
-let remove: (t, value) => t;
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```re example
-let s0 = Belt.Set.Int.fromArray([|2,3,1,4,5|]);
-let s1 = s0->Belt.Set.Int.remove(1);
-let s2 = s1->Belt.Set.Int.remove(3);
-let s3 = s2->Belt.Set.Int.remove(3);
-
-s1->Belt.Set.Int.toArray; /* [|2,3,4,5|] */
-s2->Belt.Set.Int.toArray; /* [|2,4,5|] */
-s2 == s3; /* true */
-```
-
-## removeMany
-
-```re sig
-let removeMany: (t, array(value)) => t;
-```
-
-Removes each element of array from set. Unlike [remove](#remove), the reference of return value might be changed even if any values in array not existed in set.
-
-```re example
-let set = Belt.Set.Int.fromArray([|1, 2, 3, 4|]);
-
-let newSet = set->Belt.Set.Int.removeMany([|5, 4, 3, 2, 1|]);
-newSet->Belt.Set.Int.toArray; /* [||] */
-```
-
-## union
-
-```re sig
-let union: (t, t) => t;
-```
-
-Returns union of two sets.
-
-```re example
-let s0 = Belt.Set.Int.fromArray([|5,2,3,5,6|]);
-let s1 = Belt.Set.Int.fromArray([|5,2,3,1,5,4|]);
-let union = Belt.Set.Int.union(s0, s1);
-union->Belt.Set.Int.toArray; /* [|1,2,3,4,5,6|] */
-```
-
-## intersect
-
-```re sig
-let intersect: (t, t) => t;
-```
-
-Returns intersection of two sets.
-
-```re example
-
-let s0 = Belt.Set.Int.fromArray([|5,2,3,5,6|]);
-let s1 = Belt.Set.Int.fromArray([|5,2,3,1,5,4|]);
-let intersect = Belt.Set.Int.intersect(s0, s1);
-intersect->Belt.Set.Int.toArray; /* [|2,3,5|] */
-```
-
-## diff
-
-```re sig
-let diff: (t, t) => t;
-```
-
-Returns elements from first set, not existing in second set.
-
-```re example
-let s0 = Belt.Set.Int.fromArray([|5,2,3,5,6|]);
-let s1 = Belt.Set.Int.fromArray([|5,2,3,1,5,4|]);
-Belt.Set.Int.toArray(Belt.Set.Int.diff(s0, s1)); /* [|6|] */
-Belt.Set.Int.toArray(Belt.Set.Int.diff(s1,s0)); /* [|1,4|] */
-```
-
-## subset
-
-```re sig
-let subset: (t, t) => bool;
-```
-
-Checks if second set is subset of first set.
-
-```re example
-let s0 = Belt.Set.Int.fromArray([|5,2,3,5,6|]);
-let s1 = Belt.Set.Int.fromArray([|5,2,3,1,5,4|]);
-let s2 = Belt.Set.Int.intersect(s0, s1);
-Belt.Set.Int.subset(s2, s0); /* true */
-Belt.Set.Int.subset(s2, s1); /* true */
-Belt.Set.Int.subset(s1, s0); /* false */
-```
-
-## cmp
-
-```re sig
-let cmp: (t, t) => int;
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```re sig
-let eq: (t, t) => bool;
-```
-
-Checks if two sets are equal.
-
-```re example
-let s0 = Belt.Set.Int.fromArray([|5,2,3|]);
-let s1 = Belt.Set.Int.fromArray([|3,2,5|]);
-
-Belt.Set.Int.eq(s0, s1); /* true */
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t, [@bs] (value => unit)) => unit;
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```re sig
-let forEach: (t, value => unit) => unit;
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```re example
-let s0 = Belt.Set.Int.fromArray([|5,2,3,5,6|]);
-let acc = ref([]);
-s0->Belt.Set.Int.forEach(x => {
-  acc := Belt.List.add(acc^, x)
-});
-acc; /* [6,5,3,2] */
-```
-
-## reduceU
-
-```re sig
-let reduceU: (t, 'a, [@bs] (('a, value) => 'a)) => 'a;
-```
-
-## reduce
-
-```re sig
-let reduce: (t, 'a, ('a, value) => 'a) => 'a;
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```re example
-let s0 = Belt.Set.Int.fromArray([|5,2,3,5,6|]);
-s0->Belt.Set.Int.reduce([], (acc, element) =>
-  acc->Belt.List.add(element)
-); /* [6,5,3,2] */
-```
-
-## everyU
-
-```re sig
-let everyU: (t, [@bs] (value => bool)) => bool;
-```
-
-## every
-
-```re sig
-let every: (t, value => bool) => bool;
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```re example
-let isEven = x => x mod 2 == 0;
-
-let s0 = Belt.Set.Int.fromArray([|2,4,6,8|]);
-s0->Belt.Set.Int.every(isEven); /* true */
-```
-
-## someU
-
-```re sig
-let someU: (t, [@bs] (value => bool)) => bool;
-```
-
-## some
-
-```re sig
-let some: (t, value => bool) => bool;
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```re example
-let isOdd = x => x mod 2 != 0;
-
-let s0 = Belt.Set.Int.fromArray([|1,2,4,6,8|]);
-s0->Belt.Set.Int.some(isOdd); /* true */
-```
-
-## keepU
-
-```re sig
-let keepU: (t, [@bs] (value => bool)) => t;
-```
-
-## keep
-
-```re sig
-let keep: (t, value => bool) => t;
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```re example
-let isEven = x => x mod 2 == 0;
-
-let s0 = Belt.Set.Int.fromArray([|1,2,3,4,5|]);
-let s1 = s0->Belt.Set.Int.keep(isEven);
-
-s1->Belt.Set.Int.toArray; /* [|2,4|] */
-```
-
-## partitionU
-
-```re sig
-let partitionU: (t, [@bs] (value => bool)) => (t, t);
-```
-
-## partition
-
-```re sig
-let partition: (t, value => bool) => (t, t);
-```
-
-Returns a pair of sets, where first is the set of all the elements of set that satisfy the predicate, and second is the set of all the elements of set that do not satisfy the predicate.
-
-```re example
-let isOdd = x => x mod 2 != 0;
-
-let s0 = Belt.Set.Int.fromArray([|1,2,3,4,5|]);
-let (s1, s2) = s0->Belt.Set.Int.partition(isOdd);
-
-s1->Belt.Set.Int.toArray; /* [|1,3,5|] */
-s2->Belt.Set.Int.toArray; /* [|2,4|] */
-```
-
-## size
-
-```re sig
-let size: t => int;
-```
-
-Returns size of the set.
-
-```re example
-let s0 = Belt.Set.Int.fromArray([|1,2,3,4|]);
-
-s0->Belt.Set.Int.size; /* 4 */
-```
-
-## toList
-
-```re sig
-let toList: t => list(value);
-```
-
-Returns list of ordered set elements.
-
-```re example
-let s0 = Belt.Set.Int.fromArray([|3,2,1,5|]);
-
-s0->Belt.Set.Int.toList; /* [1,2,3,5] */
-```
-
-## toArray
-
-```re sig
-let toArray: t => array(value);
-```
-
-Returns array of ordered set elements.
-
-```re example
-let s0 = Belt.Set.Int.fromArray([|3,2,1,5|]);
-
-s0->Belt.Set.Int.toArray; /* [|1,2,3,5|] */
-```
-
-## minimum
-
-```re sig
-let minimum: t => option(value);
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```re example
-let s0 = Belt.Set.Int.empty;
-let s1 = Belt.Set.Int.fromArray([|3,2,1,5|]);
-
-s0->Belt.Set.Int.minimum; /* None */
-s1->Belt.Set.Int.minimum; /* Some(1) */
-```
-
-## minUndefined
-
-```re sig
-let minUndefined: t => Js.undefined(value);
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```re example
-let s0 = Belt.Set.Int.empty;
-let s1 = Belt.Set.Int.fromArray([|3,2,1,5|]);
-
-s0->Belt.Set.Int.minUndefined; /* undefined */
-s1->Belt.Set.Int.minUndefined; /* 1 */
-```
-
-## maximum
-
-```re sig
-let maximum: t => option(value);
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```re example
-let s0 = Belt.Set.Int.empty;
-let s1 = Belt.Set.Int.fromArray([|3,2,1,5|]);
-
-s0->Belt.Set.Int.maximum; /* None */
-s1->Belt.Set.Int.maximum; /* Some(5) */
-```
-
-## maxUndefined
-
-```re sig
-let maxUndefined: t => Js.undefined(value);
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```re example
-let s0 = Belt.Set.Int.empty;
-let s1 = Belt.Set.Int.fromArray([|3,2,1,5|]);
-
-s0->Belt.Set.Int.maxUndefined; /* undefined */
-s1->Belt.Set.Int.maxUndefined; /* 5 */
-```
-
-## get
-
-```re sig
-let get: (t, value) => option(value);
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```re example
-let s0 = Belt.Set.Int.fromArray([|1,2,3,4,5|]);
-
-s0->Belt.Set.Int.get(3); /* Some(3) */
-s0->Belt.Set.Int.get(20); /* None */
-```
-
-## getUndefined
-
-```re sig
-let getUndefined: (t, value) => Js.undefined(value);
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```re sig
-let getExn: (t, value) => value;
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```re sig
-let split: (t, value) => ((t, t), bool);
-```
-
-Returns a tuple `((l, r), present)`, where `l` is the set of elements of set that are strictly less than value, `r` is the set of elements of set that are strictly greater than value, `present` is `false` if set contains no element equal to value, or `true` if set contains an element equal to value.
-
-```re example
-let s0 = Belt.Set.Int.fromArray([|1,2,3,4,5|]);
-
-let ((smaller, larger), present) = s0->Belt.Set.Int.split(3);
-
-present; /* true */
-smaller->Belt.Set.Int.toArray; /* [|1,2|] */
-larger->Belt.Set.Int.toArray; /* [|4,5|] */
-```
-
-## checkInvariantInternal
-
-```re sig
-let checkInvariantInternal: t => unit;
-```
-
-**raise** when invariant is not held
diff --git a/pages/docs/manual/v8.0.0/api/belt/set-string.mdx b/pages/docs/manual/v8.0.0/api/belt/set-string.mdx
deleted file mode 100644
index e4494bed5..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/set-string.mdx
+++ /dev/null
@@ -1,542 +0,0 @@
-# SetString
-
-<Intro>
-
-Specalized when value type is `string`, more efficient than the generic type, its compare behavior is fixed using the built-in comparison.
-
-</Intro>
-
-## value
-
-```re sig
-type value = string;
-```
-
-The type of the set elements.
-
-## t
-
-```re sig
-type t;
-```
-
-The type of sets.
-
-## empty
-
-```re sig
-let empty: t;
-```
-
-Empty set
-
-```re example
-let s0 = Belt.Set.String.empty;
-```
-
-## fromArray
-
-```re sig
-let fromArray: array(value) => t;
-```
-
-Creates new set from array of elements.
-
-```re example
-let s0 = Belt.Set.String.fromArray([|"apple", "orange", "banana"|])
-
-s0->Belt.Set.String.toArray; /* [|"apple", "banana", "orange"|] */
-```
-
-## fromSortedArrayUnsafe
-
-```re sig
-let fromSortedArrayUnsafe: array(value) => t;
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## isEmpty
-
-```re sig
-let isEmpty: t => bool;
-```
-
-Checks if set is empty.
-
-```re example
-let empty = Belt.Set.String.fromArray([||]);
-let notEmpty = Belt.Set.String.fromArray([|"apple"|]);
-
-Belt.Set.String.isEmpty(empty); /* true */
-Belt.Set.String.isEmpty(notEmpty); /* false */
-```
-
-## has
-
-```re sig
-let has: (t, value) => bool;
-```
-
-Checks if element exists in set.
-
-```re example
-let set = Belt.Set.String.fromArray([|"apple", "orange", "banana"|]);
-
-set->Belt.Set.String.has("strawberry") /* false */
-set->Belt.Set.String.has("apple") /* true */
-```
-
-## add
-
-```re sig
-let add: (t, value) => t;
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```re example
-let s0 = Belt.Set.String.empty;
-let s1 = s0->Belt.Set.String.add("apple");
-let s2 = s1->Belt.Set.String.add("banana");
-let s3 = s2->Belt.Set.String.add("banana");
-s0->Belt.Set.String.toArray; /* [||] */
-s1->Belt.Set.String.toArray; /* [|"apple"|] */
-s2->Belt.Set.String.toArray; /* [|"apple", "banana"|] */
-s3->Belt.Set.String.toArray; /* [|"apple", "banana"|] */
-s2 == s3; /* true */
-```
-
-## mergeMany
-
-```re sig
-let mergeMany: (t, array(value)) => t;
-```
-
-Adds each element of array to set. Unlike [add](#add), the reference of return value might be changed even if all values in array already exist in set
-
-```re example
-let set = Belt.Set.String.empty;
-
-let newSet =
-  set->Belt.Set.String.mergeMany([|"apple", "banana", "orange", "strawberry"|]);
-
-newSet->Belt.Set.String.toArray; /* [|"apple", "banana", "orange", "strawberry"|] */
-```
-
-## remove
-
-```re sig
-let remove: (t, value) => t;
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```re example
-let s0 = Belt.Set.String.fromArray([|"orange", "banana", "apple"|]);
-let s1 = s0->Belt.Set.String.remove("apple");
-let s2 = s1->Belt.Set.String.remove("banana");
-let s3 = s2->Belt.Set.String.remove("banana");
-
-s1->Belt.Set.String.toArray; /* [|"orange", "banana"|] */
-s2->Belt.Set.String.toArray; /* [|"orange"|] */
-s2 == s3; /* true */
-```
-
-## removeMany
-
-```re sig
-let removeMany: (t, array(value)) => t;
-```
-
-Removes each element of array from set. Unlike [remove](#remove), the reference of return value might be changed even if any values in array not existed in set.
-
-```re example
-let set = Belt.Set.String.fromArray([|"apple", "banana", "orange"|]);
-
-let newSet = set->Belt.Set.String.removeMany([|"strawberry", "apple", "banana", "orange"|]);
-newSet->Belt.Set.String.toArray; /* [||] */
-```
-
-## union
-
-```re sig
-let union: (t, t) => t;
-```
-
-Returns union of two sets.
-
-```re example
-let s0 = Belt.Set.String.fromArray([|"apple", "banana", "orange", "carrot"|]);
-let s1 = Belt.Set.String.fromArray([|"apple", "banana", "orange", "strawberry"|]);
-let union = Belt.Set.String.union(s0, s1);
-union->Belt.Set.String.toArray; /* [|"apple", "banana", "carrot", "orange", "strawberry"|] */
-```
-
-## intersect
-
-```re sig
-let intersect: (t, t) => t;
-```
-
-Returns intersection of two sets.
-
-```re example
-let s0 = Belt.Set.String.fromArray([|"apple", "banana", "orange", "carrot"|]);
-let s1 = Belt.Set.String.fromArray([|"apple", "banana", "orange", "strawberry"|]);
-let intersect = Belt.Set.String.intersect(s0, s1);
-intersect->Belt.Set.String.toArray; /* [|"apple", "banana", "orange"|] */
-```
-
-## diff
-
-```re sig
-let diff: (t, t) => t;
-```
-
-Returns elements from first set, not existing in second set.
-
-```re example
-let s0 = Belt.Set.String.fromArray([|"apple", "banana", "orange", "carrot"|]);
-let s1 = Belt.Set.String.fromArray([|"apple", "banana", "orange", "strawberry"|]);
-Belt.Set.String.toArray(Belt.Set.String.diff(s0, s1)); /* [|"carrot"|] */
-Belt.Set.String.toArray(Belt.Set.String.diff(s1, s0)); /* [|"strawberry"|] */
-```
-
-## subset
-
-```re sig
-let subset: (t, t) => bool;
-```
-
-Checks if second set is subset of first set.
-
-```re example
-let s0 = Belt.Set.String.fromArray([|"5", "2", "3", "5", "6"|]);
-let s1 = Belt.Set.String.fromArray([|"5", "2", "3", "1", "5", "4"|]);
-let s2 = Belt.Set.String.intersect(s0, s1);
-Belt.Set.String.subset(s2, s0); /* true */
-Belt.Set.String.subset(s2, s1); /* true */
-Belt.Set.String.subset(s1, s0); /* false */
-```
-
-## cmp
-
-```re sig
-let cmp: (t, t) => int;
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```re sig
-let eq: (t, t) => bool;
-```
-
-Checks if two sets are equal.
-
-```re example
-let s0 = Belt.Set.String.fromArray([|"apple", "orange"|]);
-let s1 = Belt.Set.String.fromArray([|"orange", "apple"|]);
-
-Belt.Set.String.eq(s0, s1); /* true */
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t, [@bs] (value => unit)) => unit;
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```re sig
-let forEach: (t, value => unit) => unit;
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```re example
-let s0 = Belt.Set.String.fromArray([|"banana", "orange", "apple"|]);
-let acc = ref([]);
-s0->Belt.Set.String.forEach(x => {
-  acc := Belt.List.add(acc^, x)
-});
-acc; /* ["orange", "banana", "apple"] */
-```
-
-## reduceU
-
-```re sig
-let reduceU: (t, 'a, [@bs] (('a, value) => 'a)) => 'a;
-```
-
-## reduce
-
-```re sig
-let reduce: (t, 'a, ('a, value) => 'a) => 'a;
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```re example
-let s0 = Belt.Set.String.fromArray([|"apple", "orange"|]);
-s0->Belt.Set.String.reduce(0, (acc, element) =>
-  acc + String.length(element)
-); /* 11 */
-```
-
-## everyU
-
-```re sig
-let everyU: (t, [@bs] (value => bool)) => bool;
-```
-
-## every
-
-```re sig
-let every: (t, value => bool) => bool;
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```re example
-let hasAtLeastFiveChars = x => String.length(x) >= 5;
-
-let s0 = Belt.Set.String.fromArray([|"apple", "carrot"|]);
-s0->Belt.Set.String.every(hasAtLeastFiveChars); /* true */
-```
-
-## someU
-
-```re sig
-let someU: (t, [@bs] (value => bool)) => bool;
-```
-
-## some
-
-```re sig
-let some: (t, value => bool) => bool;
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```re example
-let hasFiveChars = x => String.length(x) == 5;
-
-let s0 = Belt.Set.String.fromArray([|"strawberry", "apple"|]);
-s0->Belt.Set.String.some(hasFiveChars); /* true */
-```
-
-## keepU
-
-```re sig
-let keepU: (t, [@bs] (value => bool)) => t;
-```
-
-## keep
-
-```re sig
-let keep: (t, value => bool) => t;
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```re example
-let hasFiveChars = x => String.length(x) == 5;
-
-let s0 = Belt.Set.String.fromArray([|"apple", "orange", "banana"|]);
-let s1 = s0->Belt.Set.String.keep(hasFiveChars);
-
-s1->Belt.Set.String.toArray; /* [|"apple"|] */
-```
-
-## partitionU
-
-```re sig
-let partitionU: (t, [@bs] (value => bool)) => (t, t);
-```
-
-## partition
-
-```re sig
-let partition: (t, value => bool) => (t, t);
-```
-
-Returns a pair of sets, where first is the set of all the elements of set that satisfy the predicate, and second is the set of all the elements of set that do not satisfy the predicate.
-
-```re example
-let hasFiveChars = x => String.length(x) == 5;
-
-let s0 = Belt.Set.String.fromArray([|"apple", "carrot"|]);
-let (s1, s2) = s0->Belt.Set.String.partition(hasFiveChars);
-
-s1->Belt.Set.String.toArray; /* [|"apple"|] */
-s2->Belt.Set.String.toArray; /* [|"carrot"|] */
-```
-
-## size
-
-```re sig
-let size: t => int;
-```
-
-Returns size of the set.
-
-```re example
-let s0 = Belt.Set.String.fromArray([|"apple"|]);
-
-s0->Belt.Set.String.size; /* 1 */
-```
-
-## toList
-
-```re sig
-let toList: t => list(value);
-```
-
-Returns list of ordered set elements.
-
-```re example
-let s0 = Belt.Set.String.fromArray([|"apple", "watermelon"|]);
-
-s0->Belt.Set.String.toList; /* ["apple", "watermelon"] */
-```
-
-## toArray
-
-```re sig
-let toArray: t => array(value);
-```
-
-Returns array of ordered set elements.
-
-```re example
-let s0 = Belt.Set.String.fromArray([|"apple", "watermelon"|]);
-
-s0->Belt.Set.String.toArray; /* [|"apple", "watermelon"|] */
-```
-
-## minimum
-
-```re sig
-let minimum: t => option(value);
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```re example
-let s0 = Belt.Set.String.empty;
-let s1 = Belt.Set.String.fromArray([|"apple", "orange"|]);
-
-s0->Belt.Set.String.minimum; /* None */
-s1->Belt.Set.String.minimum; /* Some("apple") */
-```
-
-## minUndefined
-
-```re sig
-let minUndefined: t => Js.undefined(value);
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```re example
-let s0 = Belt.Set.String.empty;
-let s1 = Belt.Set.String.fromArray([|"apple", "orange"|]);
-
-s0->Belt.Set.String.minUndefined; /* undefined */
-s1->Belt.Set.String.minUndefined; /* "apple" */
-```
-
-## maximum
-
-```re sig
-let maximum: t => option(value);
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```re example
-let s0 = Belt.Set.String.empty;
-let s1 = Belt.Set.String.fromArray([|"apple", "orange"|]);
-
-s0->Belt.Set.String.maximum; /* None */
-s1->Belt.Set.String.maximum; /* Some("orange") */
-```
-
-## maxUndefined
-
-```re sig
-let maxUndefined: t => Js.undefined(value);
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```re example
-let s0 = Belt.Set.String.empty;
-let s1 = Belt.Set.String.fromArray([|"apple", "orange"|]);
-
-s0->Belt.Set.String.maxUndefined; /* undefined */
-s1->Belt.Set.String.maxUndefined; /* orange */
-```
-
-## get
-
-```re sig
-let get: (t, value) => option(value);
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```re example
-let s0 = Belt.Set.String.fromArray([|"apple", "carrot"|]);
-
-s0->Belt.Set.String.get("carrot"); /* Some("carrot") */
-s0->Belt.Set.String.get("watermelon"); /* None */
-```
-
-## getUndefined
-
-```re sig
-let getUndefined: (t, value) => Js.undefined(value);
-```
-
-See [get](#get) - returns `undefined` when element does not exist.
-
-## getExn
-
-```re sig
-let getExn: (t, value) => value;
-```
-
-See [get](#get) - raise when element does not exist.
-
-## split
-
-```re sig
-let split: (t, value) => ((t, t), bool);
-```
-
-Returns a triple `((l, r), present)`, where `l` is the set of elements of set that are strictly less than value, `r` is the set of elements of set that are strictly greater than value, `present` is `false` if set contains no element equal to value, or `true` if set contains an element equal to value.
-
-```re example
-let s0 = Belt.Set.String.fromArray([|"apple", "banana", "orange"|]);
-
-let ((smaller, larger), present) = s0->Belt.Set.String.split("banana");
-
-present; /* true */
-smaller->Belt.Set.String.toArray; /* [|"apple"|] */
-larger->Belt.Set.String.toArray; /* [|"orange"|] */
-```
-
-## checkInvariantInternal
-
-```re sig
-let checkInvariantInternal: t => unit;
-```
-
-**raise** when invariant is not held
diff --git a/pages/docs/manual/v8.0.0/api/belt/set.mdx b/pages/docs/manual/v8.0.0/api/belt/set.mdx
deleted file mode 100644
index 40849ba50..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/set.mdx
+++ /dev/null
@@ -1,590 +0,0 @@
-# Set
-
-<Intro>
-
-A **immutable** sorted set module which allows customize compare behavior.
-The implementation uses balanced binary trees, and therefore searching and insertion take time logarithmic in the size of the map.
-
-It also has three specialized inner modules [Belt.Set.Int](./set-int), [Belt.Set.String](./set-string) and [Belt.Set.Dict](./set-dict) - This module separates data from function which is more verbose but slightly more efficient
-
-</Intro>
-
-```re example
-module PairComparator =
-  Belt.Id.MakeComparable({
-    type t = (int, int);
-    let cmp = ((a0, a1), (b0, b1)) =>
-      switch (Pervasives.compare(a0, b0)) {
-      | 0 => Pervasives.compare(a1, b1)
-      | c => c
-      };
-  });
-
-let mySet = Belt.Set.make(~id=(module PairComparator));
-let mySet2 = Belt.Set.add(mySet, (1, 2));
-```
-
-**Note:** This module's examples will assume a predeclared module for integers
-called `IntCmp`. It is declared like this:
-
-```re prelude
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int;
-    let cmp = Pervasives.compare;
-  });
-```
-
-## t
-
-```re sig
-type t('value, 'identity);
-```
-
-`'value` is the element type
-
-`'identity` the identity of the collection
-
-## id
-
-```re sig
-type id('value, 'id) = Belt_Id.comparable('value, 'id);
-```
-
-The identity needed for making a set from scratch
-
-## make
-
-```re sig
-let make: (~id: id('value, 'id)) => t('value, 'id);
-```
-
-Creates a new set by taking in the comparator
-
-```re example
-let set = Belt.Set.make(~id=(module IntCmp));
-```
-
-## fromArray
-
-```re sig
-let fromArray: (array('value), ~id: id('value, 'id)) => t('value, 'id);
-```
-
-Creates new set from array of elements.
-
-```re example
-let s0 = Belt.Set.fromArray([|1, 3, 2, 4|], ~id=(module IntCmp))
-
-s0->Belt.Set.toArray; /* [|1, 2, 3, 4|] */
-```
-
-## fromSortedArrayUnsafe
-
-```re sig
-let fromSortedArrayUnsafe: (array('value), ~id: id('value, 'id)) => t('value, 'id);
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## isEmpty
-
-```re sig
-let isEmpty: t('a, 'b) => bool;
-```
-
-Checks if set is empty.
-
-```re example
-let empty = Belt.Set.fromArray([||], ~id=(module IntCmp));
-let notEmpty = Belt.Set.fromArray([|1|],~id=(module IntCmp));
-
-Belt.Set.isEmpty(empty); /* true */
-Belt.Set.isEmpty(notEmpty); /* false */
-```
-
-## has
-
-```re sig
-let has: (t('value, 'id), 'value) => bool;
-```
-
-Checks if element exists in set.
-
-```re example
-let set = Belt.Set.fromArray([|1, 4, 2, 5|], ~id=(module IntCmp));
-
-set->Belt.Set.has(3) /* false */
-set->Belt.Set.has(1) /* true */
-```
-
-## add
-
-```re sig
-let add: (t('value, 'id), 'value) => t('value, 'id);
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```re example
-let s0 = Belt.Set.make(~id=(module IntCmp));
-let s1 = s0->Belt.Set.add(1);
-let s2 = s1->Belt.Set.add(2);
-let s3 = s2->Belt.Set.add(2);
-s0->Belt.Set.toArray; /* [||] */
-s1->Belt.Set.toArray; /* [|1|] */
-s2->Belt.Set.toArray; /* [|1, 2|] */
-s3->Belt.Set.toArray; /* [|1,2 |] */
-s2 == s3; /* true */
-```
-
-## mergeMany
-
-```re sig
-let mergeMany: (t('value, 'id), array('value)) => t('value, 'id);
-```
-
-Adds each element of array to set. Unlike [add](#add), the reference of return value might be changed even if all values in array already exist in set
-
-```re example
-let set = Belt.Set.make(~id=(module IntCmp));
-
-let newSet = set->Belt.Set.mergeMany([|5, 4, 3, 2, 1|]);
-newSet->Belt.Set.toArray; /* [|1, 2, 3, 4, 5|] */
-```
-
-## remove
-
-```re sig
-let remove: (t('value, 'id), 'value) => t('value, 'id);
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```re example
-let s0 = Belt.Set.fromArray([|2,3,1,4,5|], ~id=(module IntCmp));
-let s1 = s0->Belt.Set.remove(1);
-let s2 = s1->Belt.Set.remove(3);
-let s3 = s2->Belt.Set.remove(3);
-
-s1->Belt.Set.toArray; /* [|2,3,4,5|] */
-s2->Belt.Set.toArray; /* [|2,4,5|] */
-s2 == s3; /* true */
-```
-
-## removeMany
-
-```re sig
-let removeMany: (t('value, 'id), array('value)) => t('value, 'id);
-```
-
-Removes each element of array from set. Unlike [remove](#remove), the reference of return value might be changed even if any values in array not existed in set.
-
-```re example
-let set = Belt.Set.fromArray([|1, 2, 3, 4|],~id=(module IntCmp));
-
-let newSet = set->Belt.Set.removeMany([|5, 4, 3, 2, 1|]);
-newSet->Belt.Set.toArray; /* [||] */
-```
-
-## union
-
-```re sig
-let union: (t('value, 'id), t('value, 'id)) => t('value, 'id);
-```
-
-Returns union of two sets.
-
-```re example
-let s0 = Belt.Set.fromArray([|5,2,3,5,6|], ~id=(module IntCmp));
-let s1 = Belt.Set.fromArray([|5,2,3,1,5,4|], ~id=(module IntCmp));
-let union = Belt.Set.union(s0, s1);
-union->Belt.Set.toArray; /* [|1,2,3,4,5,6|] */
-```
-
-## intersect
-
-```re sig
-let intersect: (t('value, 'id), t('value, 'id)) => t('value, 'id);
-```
-
-Returns intersection of two sets.
-
-```re example
-let s0 = Belt.Set.fromArray([|5,2,3,5,6|], ~id=(module IntCmp));
-let s1 = Belt.Set.fromArray([|5,2,3,1,5,4|], ~id=(module IntCmp));
-let intersect = Belt.Set.intersect(s0, s1);
-intersect->Belt.Set.toArray; /* [|2,3,5|] */
-```
-
-## diff
-
-```re sig
-let diff: (t('value, 'id), t('value, 'id)) => t('value, 'id);
-```
-
-Returns elements from first set, not existing in second set.
-
-```re example
-let s0 = Belt.Set.fromArray([|5,2,3,5,6|], ~id=(module IntCmp));
-let s1 = Belt.Set.fromArray([|5,2,3,1,5,4|], ~id=(module IntCmp));
-Belt.Set.toArray(Belt.Set.diff(s0, s1)); /* [|6|] */
-Belt.Set.toArray(Belt.Set.diff(s1,s0)); /* [|1,4|] */
-```
-
-## subset
-
-```re sig
-let subset: (t('value, 'id), t('value, 'id)) => bool;
-```
-
-Checks if second set is subset of first set.
-
-```re example
-let s0 = Belt.Set.fromArray([|5,2,3,5,6|], ~id=(module IntCmp));
-let s1 = Belt.Set.fromArray([|5,2,3,1,5,4|], ~id=(module IntCmp));
-let s2 = Belt.Set.intersect(s0, s1);
-Belt.Set.subset(s2, s0); /* true */
-Belt.Set.subset(s2, s1); /* true */
-Belt.Set.subset(s1, s0); /* false */
-```
-
-## cmp
-
-```re sig
-let cmp: (t('value, 'id), t('value, 'id)) => int;
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```re sig
-let eq: (t('value, 'id), t('value, 'id)) => bool;
-```
-
-Checks if two sets are equal.
-
-```re example
-let s0 = Belt.Set.fromArray([|5,2,3|], ~id=(module IntCmp));
-let s1 = Belt.Set.fromArray([|3,2,5|], ~id=(module IntCmp));
-
-Belt.Set.eq(s0, s1); /* true */
-```
-
-## forEachU
-
-```re sig
-let forEachU: (t('value, 'id), [@bs] ('value => unit)) => unit;
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```re sig
-let forEach: (t('value, 'id), 'value => unit) => unit;
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```re example
-let s0 = Belt.Set.fromArray([|5,2,3,5,6|], ~id=(module IntCmp));
-let acc = ref([]);
-s0->Belt.Set.forEach(x => {
-  acc := Belt.List.add(acc^, x)
-});
-acc; /* [6,5,3,2] */
-```
-
-## reduceU
-
-```re sig
-let reduceU: (t('value, 'id), 'a, [@bs] (('a, 'value) => 'a)) => 'a;
-```
-
-## reduce
-
-```re sig
-let reduce: (t('value, 'id), 'a, ('a, 'value) => 'a) => 'a;
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```re example
-let s0 = Belt.Set.fromArray([|5,2,3,5,6|], ~id=(module IntCmp));
-s0->Belt.Set.reduce([], (acc, element) =>
-  acc->Belt.List.add(element)
-); /* [6,5,3,2] */
-```
-
-## everyU
-
-```re sig
-let everyU: (t('value, 'id), [@bs] ('value => bool)) => bool;
-```
-
-## every
-
-```re sig
-let every: (t('value, 'id), 'value => bool) => bool;
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```re example
-let isEven = x => x mod 2 == 0;
-
-let s0 = Belt.Set.fromArray([|2,4,6,8|], ~id=(module IntCmp));
-s0->Belt.Set.every(isEven); /* true */
-```
-
-## someU
-
-```re sig
-let someU: (t('value, 'id), [@bs] ('value => bool)) => bool;
-```
-
-## some
-
-```re sig
-let some: (t('value, 'id), 'value => bool) => bool;
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```re example
-let isOdd = x => x mod 2 != 0;
-
-let s0 = Belt.Set.fromArray([|1,2,4,6,8|], ~id=(module IntCmp));
-s0->Belt.Set.some(isOdd); /* true */
-```
-
-## keepU
-
-```re sig
-let keepU: (t('value, 'id), [@bs] ('value => bool)) => t('value, 'id);
-```
-
-## keep
-
-```re sig
-let keep: (t('value, 'id), 'value => bool) => t('value, 'id);
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```re example
-let isEven = x => x mod 2 == 0;
-
-let s0 = Belt.Set.fromArray([|1,2,3,4,5|], ~id=(module IntCmp));
-let s1 = s0->Belt.Set.keep(isEven);
-
-s1->Belt.Set.toArray; /* [|2,4|] */
-```
-
-## partitionU
-
-```re sig
-let partitionU: (t('value, 'id), [@bs] ('value => bool)) => (t('value, 'id), t('value, 'id));
-```
-
-## partition
-
-```re sig
-let partition: (t('value, 'id), 'value => bool) => (t('value, 'id), t('value, 'id));
-```
-
-Returns a pair of sets, where first is the set of all the elements of set that satisfy the predicate, and second is the set of all the elements of set that do not satisfy the predicate.
-
-```re example
-let isOdd = x => x mod 2 != 0;
-
-let s0 = Belt.Set.fromArray([|1,2,3,4,5|], ~id=(module IntCmp));
-let (s1, s2) = s0->Belt.Set.partition(isOdd);
-
-s1->Belt.Set.toArray; /* [|1,3,5|] */
-s2->Belt.Set.toArray; /* [|2,4|] */
-```
-
-## size
-
-```re sig
-let size: t('value, 'id) => int;
-```
-
-Returns size of the set.
-
-```re example
-let s0 = Belt.Set.fromArray([|1,2,3,4|], ~id=(module IntCmp));
-
-s0->Belt.Set.size; /* 4 */
-```
-
-## toArray
-
-```re sig
-let toArray: t('value, 'id) => array('value);
-```
-
-Returns array of ordered set elements.
-
-```re example
-let s0 = Belt.Set.fromArray([|3,2,1,5|], ~id=(module IntCmp));
-
-s0->Belt.Set.toArray; /* [|1,2,3,5|] */
-```
-
-## toList
-
-```re sig
-let toList: t('value, 'id) => list('value);
-```
-
-Returns list of ordered set elements.
-
-```re example
-let s0 = Belt.Set.fromArray([|3,2,1,5|], ~id=(module IntCmp));
-
-s0->Belt.Set.toList; /* [1,2,3,5] */
-```
-
-## minimum
-
-```re sig
-let minimum: t('value, 'id) => option('value);
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```re example
-let s0 = Belt.Set.make(~id=(module IntCmp));
-let s1 = Belt.Set.fromArray([|3,2,1,5|], ~id=(module IntCmp));
-
-s0->Belt.Set.minimum; /* None */
-s1->Belt.Set.minimum; /* Some(1) */
-```
-
-## minUndefined
-
-```re sig
-let minUndefined: t('value, 'id) => Js.undefined('value);
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```re example
-let s0 = Belt.Set.make(~id=(module IntCmp));
-let s1 = Belt.Set.fromArray([|3,2,1,5|], ~id=(module IntCmp));
-
-s0->Belt.Set.minUndefined; /* undefined */
-s1->Belt.Set.minUndefined; /* 1 */
-```
-
-## maximum
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```re example
-let s0 = Belt.Set.make(~id=(module IntCmp));
-let s1 = Belt.Set.fromArray([|3,2,1,5|], ~id=(module IntCmp));
-
-s0->Belt.Set.maximum; /* None */
-s1->Belt.Set.maximum; /* Some(5) */
-```
-
-## maxUndefined
-
-```re sig
-let maxUndefined: t('value, 'id) => Js.undefined('value);
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```re example
-let s0 = Belt.Set.make(~id=(module IntCmp));
-let s1 = Belt.Set.fromArray([|3,2,1,5|], ~id=(module IntCmp));
-
-s0->Belt.Set.maxUndefined; /* undefined */
-s1->Belt.Set.maxUndefined; /* 5 */
-```
-
-## get
-
-```re sig
-let get: (t('value, 'id), 'value) => option('value);
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```re example
-let s0 = Belt.Set.fromArray([|1,2,3,4,5|], ~id=(module IntCmp));
-
-s0->Belt.Set.get(3); /* Some(3) */
-s0->Belt.Set.get(20); /* None */
-```
-
-## getUndefined
-
-```re sig
-let getUndefined: (t('value, 'id), 'value) => Js.undefined('value);
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```re sig
-let getExn: (t('value, 'id), 'value) => 'value;
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```re sig
-let split: (t('value, 'id), 'value) => ((t('value, 'id), t('value, 'id)), bool);
-```
-
-Returns a tuple `((smaller, larger), present)`, `present` is true when element exist in set.
-
-```re example
-let s0 = Belt.Set.fromArray([|1,2,3,4,5|], ~id=(module IntCmp));
-
-let ((smaller, larger), present) = s0->Belt.Set.split(3);
-
-present; /* true */
-smaller->Belt.Set.toArray; /* [|1,2|] */
-larger->Belt.Set.toArray; /* [|4,5|] */
-
-```
-
-## getData
-
-```re sig
-let getData: t('value, 'id) => Belt_SetDict.t('value, 'id);
-```
-
-**Advanced usage only**
-
-Returns the raw data (detached from comparator), but its type is still manifested, so that user can pass identity directly without boxing.
-
-## getId
-
-```re sig
-let getId: t('value, 'id) => id('value, 'id);
-```
-
-**Advanced usage only**
-
-Returns the identity of set.
-
-## packIdData
-
-```re sig
-let packIdData: (~id: id('value, 'id), ~data: Belt_SetDict.t('value, 'id)) => t('value, 'id);
-```
-
-**Advanced usage only**
-
-Returns the packed collection.
diff --git a/pages/docs/manual/v8.0.0/api/belt/sort-array-int.mdx b/pages/docs/manual/v8.0.0/api/belt/sort-array-int.mdx
deleted file mode 100644
index 615e6d847..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/sort-array-int.mdx
+++ /dev/null
@@ -1,59 +0,0 @@
-# SortArrayInt
-
-<Intro>
-
-This is a specialized module for `Belt.SortArray`, the docs in that module also applies here, except the comparator is fixed and inlined.
-
-</Intro>
-
-## element
-
-```re sig
-type element = int;
-```
-
-## strictlySortedLength
-
-```re sig
-let strictlySortedLength: array(element) => int;
-```
-
-The same as `Belt.SortArray.strictlySortedLength` except the comparator is fixed.
-
-Returns `+n` means increasing order `-n` means negative order.
-
-## isSorted
-
-```re sig
-let isSorted: array(element) => bool;
-```
-
-`sorted(xs)` return true if `xs` is in non strict increasing order.
-
-## stableSortInPlace
-
-```re sig
-let stableSortInPlace: array(element) => unit;
-```
-
-The same as `Belt.SortArray.stableSortInPlaceBy` except the comparator is fixed.
-
-## stableSort
-
-```re sig
-let stableSort: array(element) => array(element);
-```
-
-The same as `Belt.SortArray.stableSortBy` except the comparator is fixed.
-
-## binarySearch
-
-```re sig
-let binarySearch: (array(element), element) => int;
-```
-
-If value is not found and value is less than one or more elements in array, the negative number returned is the bitwise complement of the index of the first element that is larger than value.
-
-If value is not found and value is greater than all elements in array, the negative number returned is the bitwise complement of (the index of the last element plus 1)
-
-for example, if `key` is smaller than all elements return `-1` since `lnot(-1) = 0` if `key` is larger than all elements return `- (len + 1)` since `lnot(-(len+1)) = len`.
diff --git a/pages/docs/manual/v8.0.0/api/belt/sort-array-string.mdx b/pages/docs/manual/v8.0.0/api/belt/sort-array-string.mdx
deleted file mode 100644
index 1633802de..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/sort-array-string.mdx
+++ /dev/null
@@ -1,59 +0,0 @@
-# SortArrayString
-
-<Intro>
-
-This is a specialized module for `Belt.SortArray`, the docs in that module also applies here, except the comparator is fixed and inlined.
-
-</Intro>
-
-## element
-
-```re sig
-type element = string;
-```
-
-## strictlySortedLength
-
-```re sig
-let strictlySortedLength: array(element) => int;
-```
-
-The same as `Belt.SortArray.strictlySortedLength` except the comparator is fixed.
-
-Returns `+n` means increasing order `-n` means negative order.
-
-## isSorted
-
-```re sig
-let isSorted: array(element) => bool;
-```
-
-`sorted(xs)` return true if `xs` is in non strict increasing order.
-
-## stableSortInPlace
-
-```re sig
-let stableSortInPlace: array(element) => unit;
-```
-
-The same as `Belt.SortArray.stableSortInPlaceBy` except the comparator is fixed.
-
-## stableSort
-
-```re sig
-let stableSort: array(element) => array(element);
-```
-
-The same as `Belt.SortArray.stableSortBy` except the comparator is fixed.
-
-## binarySearch
-
-```re sig
-let binarySearch: (array(element), element) => int;
-```
-
-If value is not found and value is less than one or more elements in array, the negative number returned is the bitwise complement of the index of the first element that is larger than value.
-
-If value is not found and value is greater than all elements in array, the negative number returned is the bitwise complement of (the index of the last element plus 1)
-
-for example, if `key` is smaller than all elements return `-1` since `lnot(-1) = 0` if `key` is larger than all elements return `- (len + 1)` since `lnot(-(len+1)) = len`.
diff --git a/pages/docs/manual/v8.0.0/api/belt/sort-array.mdx b/pages/docs/manual/v8.0.0/api/belt/sort-array.mdx
deleted file mode 100644
index 7722f42d7..000000000
--- a/pages/docs/manual/v8.0.0/api/belt/sort-array.mdx
+++ /dev/null
@@ -1,111 +0,0 @@
-# SortArray
-
-## SortArrayInt
-
-```re sig
-module Int : Belt_SortArrayInt
-```
-
-Specalized when key type is `int`, more efficient than the generic type
-
-## SortArrayString
-
-```re sig
-module String: Belt_SortArrayString
-```
-
-Specalized when key type is `string`, more efficient than the generic type
-
-## strictlySortedLengthU
-
-```re sig
-let strictlySortedLengthU: (array('a), [@bs] (('a, 'a) => bool)) => int;
-```
-
-## strictlySortedLength
-
-```re sig
-let strictlySortedLength: (array('a), ('a, 'a) => bool) => int;
-```
-
-`strictlySortedLenght(xs, cmp);` return `+n` means increasing order `-n` means negative order
-
-```re example
-Belt.SortArray.strictlySortedLength([|1, 2, 3, 4, 3|], (x, y) => x < y) == 4;
-
-Belt.SortArray.strictlySortedLength([||], (x, y) => x < y) == 0;
-
-Belt.SortArray.strictlySortedLength([|1|], (x, y) => x < y) == 1;
-
-Belt.SortArray.strictlySortedLength([|4, 3, 2, 1|], (x, y) => x < y) == (-4);
-```
-
-## isSortedU
-
-```re sig
-let isSortedU: (array('a), [@bs] (('a, 'a) => int)) => bool;
-```
-
-## isSorted
-
-```re sig
-let isSorted: (array('a), ('a, 'a) => int) => bool;
-```
-
-`isSorted(arr, cmp)`: Returns true if array is increasingly sorted (equal is okay)
-
-## stableSortInPlaceByU
-
-```re sig
-let stableSortInPlaceByU: (array('a), [@bs] (('a, 'a) => int)) => unit;
-```
-
-## stableSortInPlaceBy
-
-```re sig
-let stableSortInPlaceBy: (array('a), ('a, 'a) => int) => unit;
-```
-
-## stableSortByU
-
-```re sig
-let stableSortByU: (array('a), [@bs] (('a, 'a) => int)) => array('a);
-```
-
-## stableSortBy
-
-```re sig
-let stableSortBy: (array('a), ('a, 'a) => int) => array('a);
-```
-
-`stableSortBy(xs, cmp)`: Returns a fresh array Sort `xs` in place using
-comparator `cmp`, the stable means if the elements are equal, their order will
-be preserved
-
-## binarySearchByU
-
-```re sig
-let binarySearchByU: (array('a), 'a, [@bs] (('a, 'a) => int)) => int;
-```
-
-## binarySearchBy
-
-```re sig
-let binarySearchBy: (array('a), 'a, ('a, 'a) => int) => int;
-```
-
-If value is not found and value is less than one or more elements in array, the
-negative number returned is the bitwise complement of the index of the first
-element that is larger than value.
-
-If value is not found and value is greater
-than all elements in array, the negative number returned is the bitwise
-complement of (the index of the last element plus 1)for example, if `key` is
-smaller than all elements return `-1` since `lnot(-1) == 0` if `key` is larger
-than all elements return `lnot(-1) == 0` since `lnot(- (len + 1)) == len`
-
-```re example
-Belt.SortArray.binarySearchBy([|1, 2, 3, 4, 33, 35, 36|], 33, Pervasives.compare) == 4;
-
-lnot(Belt.SortArray.binarySearchBy([|1, 3, 5, 7|], 4, Pervasives.compare)) == 2;
-```
diff --git a/pages/docs/manual/v8.0.0/api/dom.mdx b/pages/docs/manual/v8.0.0/api/dom.mdx
deleted file mode 100644
index 7ed577be7..000000000
--- a/pages/docs/manual/v8.0.0/api/dom.mdx
+++ /dev/null
@@ -1,855 +0,0 @@
-# Dom
-
-<Intro>
-
-The Dom module offers a canonical set of dom related types that third party libraries can depend on. It only provides types, no functions to manipulate the values of certain types whatsoever.
-
-</Intro>
-
-## animation
-
-```re sig
-type animation
-```
-
-## cssStyleDeclaration
-
-```re sig
-type cssStyleDeclaration
-```
-
-## cssStyleSheet
-
-```re sig
-type cssStyleSheet
-```
-
-## node
-
-```re sig
-type node
-```
-
-## characterData
-
-```re sig
-type characterData
-```
-
-## cdataSection
-
-```re sig
-type cdataSection
-```
-
-## comment
-
-```re sig
-type comment
-```
-
-## document
-
-```re sig
-type document
-```
-
-## documentType
-
-```re sig
-type documentType
-```
-
-## domImplementation
-
-```re sig
-type domImplementation
-```
-
-## element
-
-```re sig
-type element
-```
-
-## htmlCollection
-
-```re sig
-type htmlCollection
-```
-
-## htmlFormControlsCollection
-
-```re sig
-type htmlFormControlsCollection
-```
-
-## htmlOptionsCollection
-
-```re sig
-type htmlOptionsCollection
-```
-
-## intersectionObserver
-
-```re sig
-type intersectionObserver
-```
-
-## intersectionObserverEntry
-
-```re sig
-type intersectionObserverEntry
-```
-
-## mutationObserver
-
-```re sig
-type mutationObserver
-```
-
-## mutationRecord
-
-```re sig
-type mutationRecord
-```
-
-## performanceObserver
-
-```re sig
-type performanceObserver
-```
-
-## performanceObserverEntryList
-
-```re sig
-type performanceObserverEntryList
-```
-
-## reportingObserver
-
-```re sig
-type reportingObserver
-```
-
-## reportingObserverOptions
-
-```re sig
-type reportingObserverOptions
-```
-
-## resizeObserver
-
-```re sig
-type resizeObserver
-```
-
-## resizeObserverEntry
-
-```re sig
-type resizeObserverEntry
-```
-
-## namedNodeMap
-
-```re sig
-type namedNodeMap
-```
-
-## nodeList
-
-```re sig
-type nodeList
-```
-
-## radioNodeList
-
-```re sig
-type radioNodeList
-```
-
-## processingInstruction
-
-```re sig
-type processingInstruction
-```
-
-## shadowRoot
-
-```re sig
-type shadowRoot
-```
-
-## text
-
-```re sig
-type text
-```
-
-## domRect
-
-```re sig
-type domRect
-```
-
-## dataTransfer
-
-```re sig
-type dataTransfer
-```
-
-## domStringMap
-
-```re sig
-type domStringMap
-```
-
-## history
-
-```re sig
-type history
-```
-
-## htmlDocument
-
-```re sig
-type htmlDocument
-```
-
-## htmlElement
-
-```re sig
-type htmlElement
-```
-
-## htmlAnchorElement
-
-```re sig
-type htmlAnchorElement
-```
-
-## htmlAreaElement
-
-```re sig
-type htmlAreaElement
-```
-
-## htmlAudioElement
-
-```re sig
-type htmlAudioElement
-```
-
-## htmlBaseElement
-
-```re sig
-type htmlBaseElement
-```
-
-## htmlBodyElement
-
-```re sig
-type htmlBodyElement
-```
-
-## htmlBrElement
-
-```re sig
-type htmlBrElement
-```
-
-## htmlButtonElement
-
-```re sig
-type htmlButtonElement
-```
-
-## htmlCanvasElement
-
-```re sig
-type htmlCanvasElement
-```
-
-## htmlDataElement
-
-```re sig
-type htmlDataElement
-```
-
-## htmlDataListElement
-
-```re sig
-type htmlDataListElement
-```
-
-## htmlDialogElement
-
-```re sig
-type htmlDialogElement
-```
-
-## htmlDivElement
-
-```re sig
-type htmlDivElement
-```
-
-## htmlDlistElement
-
-```re sig
-type htmlDlistElement
-```
-
-## htmlEmbedElement
-
-```re sig
-type htmlEmbedElement
-```
-
-## htmlFieldSetElement
-
-```re sig
-type htmlFieldSetElement
-```
-
-## htmlFormElement
-
-```re sig
-type htmlFormElement
-```
-
-## htmlHeadElement
-
-```re sig
-type htmlHeadElement
-```
-
-## htmlHeadingElement
-
-```re sig
-type htmlHeadingElement
-```
-
-## htmlHrElement
-
-```re sig
-type htmlHrElement
-```
-
-## htmlHtmlElement
-
-```re sig
-type htmlHtmElement
-```
-
-## htmlIframeElement
-
-```re sig
-type htmlIframeElement
-```
-
-## htmlImageElement
-
-```re sig
-type htmlImageElement
-```
-
-## htmlInputElement
-
-```re sig
-type htmlInputElement
-```
-
-## htmlLabelElement
-
-```re sig
-type htmlLabelElement
-```
-
-## htmlLegendElement
-
-```re sig
-type htmlLegendElement
-```
-
-## htmlLiElement
-
-```re sig
-type htmlLiElement
-```
-
-## htmlLinkElement
-
-```re sig
-type htmlLinkElement
-```
-
-## htmlMapElement
-
-```re sig
-type htmlMapElement
-```
-
-## htmlMediaElement
-
-```re sig
-type htmlMediaElement
-```
-
-## htmlMenuElement
-
-```re sig
-type htmlMenuElement
-```
-
-## htmlMetaElement
-
-```re sig
-type htmlMetaElement
-```
-
-## htmlMeterElement
-
-```re sig
-type htmlMeterElement
-```
-
-## htmlModElement
-
-```re sig
-type htmlModElement
-```
-
-## htmlOListElement
-
-```re sig
-type htmlOListElement
-```
-
-## htmlObjectElement
-
-```re sig
-type htmlObjectElement
-```
-
-## htmlOptGroupElement
-
-```re sig
-type htmlOptGroupElement
-```
-
-## htmlOptionElement
-
-```re sig
-type htmlOptionElement
-```
-
-## htmlOutputElement
-
-```re sig
-type htmlOutputElement
-```
-
-## htmlParagraphElement
-
-```re sig
-type htmlParagraphElement
-```
-
-## htmlParamElement
-
-```re sig
-type htmlParamElement
-```
-
-## htmlPreElement
-
-```re sig
-type htmlPreElement
-```
-
-## htmlProgressElement
-
-```re sig
-type htmlProgressElement 
-```
-
-## htmlQuoteElement
-
-```re sig
-type  htmlQuoteElement
-```
-
-## htmlScriptElement
-
-```re sig
-type htmlScriptElement
-```
-
-## htmlSelectElement
-
-```re sig
-type htmlSelectElement 
-```
-
-## htmlSlotElement
-
-```re sig
-type htmlSlotElement
-```
-
-## htmlSourceElement
-
-```re sig
-type htmlSourceElement
-```
-
-## htmlSpanElement
-
-```re sig
-type htmlSpanElement
-```
-
-## htmlStyleElement
-
-```re sig
-type htmlStyleElement
-```
-
-## htmlTableCaptionElement
-
-```re sig
-type htmlTableCaptionElement
-```
-
-## htmlTableCellElement
-
-```re sig
-type htmlTableCellElement
-```
-
-## htmlTableColElement
-
-```re sig
-type htmlTableColElement
-```
-
-## htmlTableDataCellElement
-
-```re sig
-type htmlTableDataCellElement
-```
-
-## htmlTableElement
-
-```re sig
-type htmlTableElement
-```
-
-## htmlTableHeaderCellElement
-
-```re sig
-type htmlTableHeaderCellElement
-```
-
-## htmlTableRowElement
-
-```re sig
-type htmlTableRowElement
-```
-
-## htmlTableSectionElement
-
-```re sig
-type htmlTableSectionElement
-```
-
-## htmlTextAreaElement
-
-```re sig
-type htmlTextAreaElement
-```
-
-## htmlTimeElement
-
-```re sig
-type htmlTimeElement
-```
-
-## htmlTitleElement
-
-```re sig
-type htmlTitleElement
-```
-
-## htmlTrackElement
-
-```re sig
-type htmlTrackElement
-```
-
-## htmlUlistElement
-
-```re sig
-type htmlUlistElement
-```
-
-## htmlUnknownElement
-
-```re sig
-type htmlUnknownElement
-```
-
-## htmlVideoElement
-
-```re sig
-type htmlVideoElement
-```
-
-## location
-
-```re sig
-type location
-```
-
-## window
-
-```re sig
-type window
-```
-
-## xmlDocument
-
-```re sig
-type xmlDocument
-```
-
-## event
-
-```re sig
-type event
-```
-
-## uiEvent 
-
-```re sig
-type uiEvent
-```
-
-## animationEvent
-
-```re sig
-type animationEvent
-```
-
-## beforeUnloadEvent
-
-```re sig
-type beforeUnloadEvent
-```
-
-## clipboardEvent
-
-```re sig
-type clipboardEvent
-```
-
-## closeEvent
-
-```re sig
-type closeEvent
-```
-
-## compositionEvent
-
-```re sig
-type compositionEvent
-```
-
-## customEvent
-
-```re sig
-type customEvent
-```
-
-## dragEvent
-
-```re sig
-type dragEvent
-```
-
-## errorEvent
-
-```re sig
-type errorEvent
-```
-
-## focusEvent
-
-```re sig
-type focusEvent
-```
-
-## idbVersionChangeEvent
-
-```re sig
-type idbVersionChangeEvent
-```
-
-## inputEvent
-
-```re sig
-type inputEvent
-```
-
-## keyboardEvent
-
-```re sig
-type keyboardEvent
-```
-
-## mouseEvent
-
-```re sig
-type mouseEvent
-```
-
-## pageTransitionEvent
-
-```re sig
-type pageTransitionEvent
-```
-
-## pointerEvent
-
-```re sig
-type pointerEvent
-```
-
-## popStateEvent
-
-```re sig
-type popStateEvent
-```
-
-## progressEvent
-
-```re sig
-type progressEvent
-```
-
-## relatedEvent
-
-```re sig
-type relatedEvent
-```
-
-## storageEvent
-
-```re sig
-type storageEvent
-```
-
-## svgZoomEvent
-
-```re sig
-type svgZoomEvent
-```
-
-## timeEvent
-
-```re sig
-type timeEvent
-```
-
-## touchEvent
-
-```re sig
-type touchEvent
-```
-
-## trackEvent
-
-```re sig
-type trackEvent
-```
-
-## transitionEvent
-
-```re sig
-type transitionEvent
-```
-
-## webGlContextEvent
-
-```re sig
-type webGlContextEvent
-```
-
-## wheelEvent
-
-```re sig
-type wheelEvent
-```
-
-## range
-
-```re sig
-type range
-```
-
-## selection
-
-```re sig
-type selection
-```
-
-## domTokenList
-
-```re sig
-type domTokenList
-```
-
-## domSettableTokenList
-
-```re sig
-type domSettableTokenList
-```
-
-## nodeFilter
-
-```re sig
-type nodeFilter = {
-  acceptNode: (Dom.element) => int
-}
-```
-
-## nodeIterator
-
-```re sig
-type nodeIterator
-```
-
-## treeWalker
-
-```re sig
-type treeWalker
-```
-
-## svgRect
-
-```re sig
-type svgRect
-```
-
-## svgPoint
-
-```re sig
-type svgPoint
-```
-
-## eventPointerId
-
-```re sig
-type eventPointerId
-```
diff --git a/pages/docs/manual/v8.0.0/api/dom/storage.mdx b/pages/docs/manual/v8.0.0/api/dom/storage.mdx
deleted file mode 100644
index 5c79ca0bd..000000000
--- a/pages/docs/manual/v8.0.0/api/dom/storage.mdx
+++ /dev/null
@@ -1,55 +0,0 @@
-# Storage
-
-## t
-
-```re prelude sig
-type t
-```
-
-## getItem
-
-```re sig
-external getItem: (string, t) => option<string> = "getItem"
-```
-
-## setItem
-
-```re sig
-external setItem: (string, string, t) => unit = "setItem"
-```
-
-## removeItem
-
-```re sig
-external removeItem: (string, t) => unit = "removeItem"
-```
-
-## clear
-
-```re sig
-external clear: t => unit = "clear"
-```
-
-## key
-
-```re sig
-external key: (int, t) => option<string> = "key"
-```
-
-## length
-
-```re sig
-external length: t => int = "length"
-```
-
-## localStorage
-
-```re sig
-[@bs.val] external localStorage: t = "localStorage"
-```
-
-## sessionStorage
-
-```re sig
-[@bs.val] external sessionStorage: t = "sessionStorage"
-```
diff --git a/pages/docs/manual/v8.0.0/api/dom/storage2.mdx b/pages/docs/manual/v8.0.0/api/dom/storage2.mdx
deleted file mode 100644
index 3719686f9..000000000
--- a/pages/docs/manual/v8.0.0/api/dom/storage2.mdx
+++ /dev/null
@@ -1,61 +0,0 @@
-# Storage2
-
-<Intro>
-
-The same as [Dom.Storage](./storage2), but with `t` on first argument position for proper `->` usage.
-
-</Intro>
-
-## t
-
-```re prelude sig
-type t
-```
-
-## getItem
-
-```re sig
-external getItem: (t, string) => option(string) = "getItem"
-```
-
-## setItem
-
-```re sig
-external setItem: (t, string, string) => unit = "setItem"
-```
-
-## removeItem
-
-```re sig
-external removeItem: (t, string) => unit = "removeItem"
-```
-
-## clear
-
-```re sig
-external clear: t => unit = "clear"
-```
-
-## key
-
-```re sig
-external key: (t, int) => option(string) = "key"
-```
-
-## length
-
-```re sig
-external length: t => int = "length"
-```
-
-## localStorage
-
-```re sig
-[@bs.val] external localStorage: t = "localStorage"
-```
-
-## sessionStorage
-
-```re sig
-[@bs.val] external sessionStorage: t = "sessionStorage"
-```
diff --git a/pages/docs/manual/v8.0.0/api/js.mdx b/pages/docs/manual/v8.0.0/api/js.mdx
deleted file mode 100644
index 27660939d..000000000
--- a/pages/docs/manual/v8.0.0/api/js.mdx
+++ /dev/null
@@ -1,183 +0,0 @@
-# Js
-
-The Js module mostly contains ReScript bindings to _standard JavaScript APIs_
-like [console.log](https://developer.mozilla.org/en-US/docs/Web/API/Console/log),
-or the JavaScript
-[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String),
-[Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date), and
-[Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
-classes.
-
-It is meant as a zero-abstraction interop layer and directly exposes JavaScript functions as they are. If you can find your API in this module, prefer this over an equivalent Belt helper. For example, prefer [Js.Array2](js/array-2) over [Belt.Array](belt/array)
-
-## Argument Order
-
-For historical reasons, some APIs in the Js namespace (e.g. [Js.String](./js/string)) are
-using the data-last argument order whereas others (e.g. [Js.Date](./js/date)) are using data-first.
-
-For more information about these argument orders and the trade-offs between them, see
-[this blog post](https://www.javierchavarri.com/data-first-and-data-last-a-comparison/).
-
-_Eventually, all modules in the Js namespace are going to be migrated to data-first though._
-
-In the meantime, there are several options for dealing with the data-last APIs:
-
-```re example
-/* Js.String (data-last API used with pipe last operator) */
-Js.log("2019-11-10" |> Js.String.split("-"));
-Js.log("ReScript" |> Js.String.startsWith("Re"));
-
-/* Js.String (data-last API used with pipe first operator) */
-Js.log("2019-11-10"->Js.String.split("-", _));
-Js.log("ReScript"->Js.String.startsWith("Re", _));
-
-/* Js.String (data-last API used without any piping) */
-Js.log(Js.String.split("-", "2019-11-10"));
-Js.log(Js.String.startsWith("Re", "ReScript"));
-```
-
-## Js.Xxx2 Modules
-
-Prefer `Js.Array2` over `Js.Array`, `Js.String2` over `Js.String`, etc. The latters are old modules.
-
-## Object
-
-```re
-type t(+'a);
-```
-
-Js object type.
-
-```re
-let x: {
-  .
-  "x": int,
-  "y": int,
-} = [%obj {x: 1, y: 2}];
-```
-
-## Nullable and Undefined
-
-```re
-type null(+'a);
-```
-
-nullable, value of this type can be either null or 'a this type is the same as type t in Js.Null
-
-```re
-type undefined(+'a);
-```
-
-value of this type can be either undefined or 'a this type is the same as type t in Js.Undefined
-
-```re
-type nullable(+'a);
-```
-
-value of this type can be undefined, null or 'a this type is the same as type t n Js.Null_undefined
-
-```re
-type null_undefined('a) = Js.nullable('a);
-```
-
-```re
-let toOption: Js.nullable('a) => option('a);
-```
-
-```re
-let undefinedToOption: Js.undefined('a) => option('a);
-```
-
-```re
-let nullToOption: Js.null('a) => option('a);
-```
-
-```re
-let test: Js.nullable('a) => bool;
-```
-
-```re
-let isNullable: Js.nullable('a) => bool;
-```
-
-```re
-let testAny: 'a => bool;
-```
-
-The same as `Js.test` except that it is more permissive on the types of input.
-
-```re
-type promise(+'a, +'e);
-```
-
-Deprecated. please use `Js.Promise`.
-The promise type, defined here for interoperation across packages.
-
-```re
-let null: Js.null('a);
-```
-
-The same as empty in `Js.Null`. Will be compiled as `null`.
-
-```re
-let undefined: Js.undefined('a);
-```
-
-The same as empty `Js.Undefined`. Will be compiled as `undefined`.
-
-## TypeOf
-
-```re
-let typeof: 'a => string;
-```
-
-`typeof x` will be compiled as `typeof x` in JS. Please consider functions in `Js.Types` for a type safe way of reflection.
-
-## Logging
-
-```re
-let log: 'a => unit;
-let log2: ('a, 'b) => unit;
-let log3: ('a, 'b, 'c) => unit;
-let log4: ('a, 'b, 'c, 'd) => unit;
-```
-
-A convenience function to log everything.
-
-```re
-let logMany: array('a) => unit;
-```
-
-A convenience function to log more than 4 arguments
-
-## Comparison
-
-```re
-let eqNull: ('a, null('a)) => bool;
-let eqUndefined: ('a, undefined('a)) => bool;
-let eqNullable: ('a, nullable('a)) => bool;
-```
-
-```re
-let unsafe_lt: ('a, 'a) => bool;
-```
-
-`unsafe_lt a b` will be compiled as `a < b`. It is marked as unsafe, since it is impossible to give a proper semantics for comparision which applies to any type.
-
-```re
-let unsafe_le: ('a, 'a) => bool;
-```
-
-`unsafe_le a b` will be compiled as `a <= b`. See also `Js.unsafe_lt`.
-
-```re
-let unsafe_gt: ('a, 'a) => bool;
-```
-
-`unsafe_gt a b` will be compiled as `a > b`. See also `Js.unsafe_lt`.
-
-```re
-let unsafe_ge: ('a, 'a) => bool;
-```
-
-`unsafe_ge a b` will be compiled as `a >= b`. See also `Js.unsafe_lt`.
diff --git a/pages/docs/manual/v8.0.0/api/js/array-2.mdx b/pages/docs/manual/v8.0.0/api/js/array-2.mdx
deleted file mode 100644
index dda2ebfcb..000000000
--- a/pages/docs/manual/v8.0.0/api/js/array-2.mdx
+++ /dev/null
@@ -1,866 +0,0 @@
-# Array2
-
-<Intro>
-
-Provides bindings to JavaScript’s `Array` functions. These bindings are optimized for pipe-first (`->`), where the array to be processed is the first parameter in the function.
-
-Here is an example to find the sum of squares of all even numbers in an array.
-Without pipe first, we must call the functions in reverse order:
-
-```re example
-let isEven = (x) => {x mod 2 == 0};
-let square = (x) => {x * x};
-let result = Js.Array2.(
-  reduce(map(filter([|5, 2, 3, 4, 1|], isEven), square), (+), 0)
-  );
-```
-
-With pipe first, we call the functions in the “natural” order:
-
-```re example
-let isEven = (x) => {x mod 2 == 0};
-let square = (x) => {x * x};
-let result = Js.Array2.(
-    [|5, 2, 3, 4, 1|] ->
-  	filter(isEven) ->
-    map(square) ->
-    reduce((+), 0)
-  );
-```
-</Intro>
-
-## t
-
-```re sig
-type t('a) = array('a);
-```
-
-The type used to describe a JavaScript array.
-
-## array_like
-
-```re sig
-type array_like('a);
-```
-
-A type used to describe JavaScript objects that are like an array or are iterable.
-
-## from
-
- ```re sig
-let from: array_like('a) => array('b);
-```
-
-Creates a shallow copy of an array from an array-like object. See [`Array.from`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from) on MDN. 
-
-```re example
-let strArr = Js.String.castToArrayLike("abcd");
-Js.Array2.from(strArr) == [|"a", "b", "c", "d"|];
-```
-
-## fromMap
-
- ```re sig
-let fromMap: (array_like('a), 'a => 'b) => array('b);
-```
-
-Creates a new array by applying a function (the second argument) to each item in the `array_like` first argument.  See [`Array.from`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from) on MDN.
-
-```re example
-let strArr = Js.String.castToArrayLike("abcd");
-let code = (s) => {Js.String.charCodeAt(0, s)};
-Js.Array2.fromMap(strArr, code) == [|97.0, 98.0, 99.0, 100.0|];
-```
-
-## isArray
-
- ```re sig
-let isArray: 'a => bool;
-```
-
-Returns `true` if its argument is an array; `false` otherwise. This is a runtime check, which is why the second example returns `true`---a list is internally represented as a nested JavaScript array.
-
-```re example
-Js.Array2.isArray([|5, 2, 3, 1, 4|]) == true;
-Js.Array2.isArray([5, 2, 3, 1, 4]) == true;
-Js.Array2.isArray("abcd") == false;
-```
-
-## length
-
- ```re sig
-let length: array('a) => int;
-```
-
-Returns the number of elements in the array. See [`Array.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length) on MDN.
-
-## copyWithin
-
- ```re sig
-let copyWithin: (t('a), ~to_: int) => t('a);
-```
-
-Copies from the first element in the given array to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104|];
-Js.Array2.copyWithin(arr, ~to_=2)
-  == [|100, 101, 100, 101, 102|];
-arr == [|100, 101, 100, 101, 102|];
-```
-
-## copyWithinFrom
-
- ```re sig
-let copyWithinFrom: (t('a), ~to_: int, ~from: int) => t('a);
-```
-
-Copies starting at element `~from` in the given array to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104|];
-Js.Array2.copyWithinFrom(arr, ~from=2, ~to_=0)
-  == [|102, 103, 104, 103, 104|];
-arr == [|102, 103, 104, 103, 104|];
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (t('a), ~to_: int, ~start: int, ~end_: int) => t('a);
-```
-
-Copies starting at element `~start` in the given array up to but not including `~end_` to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104, 105|];
-Js.Array2.copyWithinFromRange(arr, ~start=2, ~end_=5, ~to_=1)
-  == [|100, 102, 103, 104, 104, 105|];
-arr == [|100, 102, 103, 104, 104, 105|];
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (t('a), 'a) => t('a);
-```
-Sets all elements of the given array (the first arumgent) to the designated value (the secon argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104|];
-Js.Array2.fillInPlace(arr, 99)
-   == [|99, 99, 99, 99, 99|];
-arr == [|99, 99, 99, 99, 99|];
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (t('a), 'a, ~from: int) => t('a);
-```
-Sets all elements of the given array (the first arumgent) from position `~from` to the end to the designated value (the second argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104|];
-Js.Array2.fillFromInPlace(arr, 99, ~from=2)
-   == [|100, 101, 99, 99, 99|];
-arr == [|100, 101, 99, 99, 99|];
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (t('a), 'a, ~start: int, ~end_: int) => t('a);
-```
-Sets the elements of the given array (the first arumgent) from position `~start` up to but not including position `~end_` to the designated value (the second argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104|];
-Js.Array2.fillRangeInPlace(arr, 99, ~start=1, ~end_=4)
-  == [|100, 99, 99, 99, 104|];
-arr == [|100, 99, 99, 99, 104|];
-```                                           
-
-## pop
-
-```re sig
-let pop: t('a) => option('a);
-```
-If the array is not empty, removes the last element and returns it as `Some(value)`; returns `None` if the array is empty. *This function modifies the original array.* See [`Array.pop`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104|];
-Js.Array2.pop(arr) == Some(104);
-arr == [|100, 101, 102, 103|];
-
-let empty: array(int) = [| |];
-Js.Array2.pop(empty) == None;
-```
-
-## push
-
-```re sig
-let push: (t('a), 'a) => int;
-```
-Appends the given value to the array, returning the number of elements in the updated array. *This function modifies the original array.* See [`Array.push`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) on MDN.
-
-```re example
-let arr = [|"ant", "bee", "cat"|];
-Js.Array2.push(arr, "dog") == 4;
-arr == [|"ant", "bee", "cat", "dog"|];
-```
-
-## pushMany
-
-```re sig
-let pushMany: (t('a), array('a)) => int;
-```
-Appends the values from one array (the second argument) to another (the first argument), returning the number of elements in the updated array. *This function modifies the original array.* See [`Array.push`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) on MDN.
-
-```re example
-let arr = [|"ant", "bee", "cat"|];
-Js.Array2.pushMany(arr, [|"dog", "elk"|]) == 5;
-arr == [|"ant", "bee", "cat", "dog", "elk"|];
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t('a) => t('a);
-```
-Returns an array with the elements of the input array in reverse order. *This function modifies the original array.* See [`Array.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse) on MDN.
-
-```re example
-let arr = [|"ant", "bee", "cat"|];
-Js.Array2.reverseInPlace(arr) == [|"cat", "bee", "ant"|];
-arr == [|"cat", "bee", "ant"|];
-```
-
-## shift
-
-```re sig
-let shift: t('a) => option('a);
-```
-If the array is not empty, removes the first element and returns it as `Some(value)`; returns `None` if the array is empty. *This function modifies the original array.* See [`Array.shift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104|];
-Js.Array2.shift(arr) == Some(100);
-arr == [|101, 102, 103, 104|];
-
-let empty: array(int) = [| |];
-Js.Array2.shift(empty) == None;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t('a) => t('a);
-```
-Sorts the given array in place and returns the sorted array. JavaScript sorts the array by converting the arguments to UTF-16 strings and sorting them. See the second example with sorting numbers, which does not do a numeric sort. *This function modifies the original array.* See [`Array.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) on MDN.
-
-```re example
-let words = [|"bee", "dog", "ant", "cat"|];
-Js.Array2.sortInPlace(words) == [|"ant", "bee", "cat", "dog"|];
-words == [|"ant", "bee", "cat", "dog"|];
-
-let numbers = [|3, 30, 10, 1, 20, 2|];
-Js.Array2.sortInPlace(numbers) == [|1, 10, 2, 20, 3, 30|];
-numbers == [|1, 10, 2, 20, 3, 30|];
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: (t('a), ('a, 'a) => int) => t('a);
-```
-Sorts the given array in place and returns the sorted array. *This function modifies the original array.*
-
-The first argument to `sortInPlaceWith()` is a function that compares two items from the array and returns:
-
-* an integer less than zero if the first item is less than the second item
-* zero if the items are equal
-* an integer greater than zero if the first item is greater than the second item
-
-See [`Array.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) on MDN.
-
-```re example
-// sort by word length
-let words = [|"horse", "aardvark", "dog", "camel"|];
-let byLength = (s1, s2) => {
-  Js.String.length(s1) - Js.String.length(s2);
-};
-
-Js.Array2.sortInPlaceWith(words, byLength)
-  == [|"dog", "horse", "camel", "aardvark"|];
-  
-// sort in reverse numeric order
-let numbers = [|3, 30, 10, 1, 20, 2|];
-let reverseNumeric = (n1, n2) => {n2 - n1};
-Js.Array2.sortInPlaceWith(numbers, reverseNumeric)
-  == [|30, 20, 10, 3, 2, 1|];
-```
-
-## spliceInPlace
-
-```re sig
-let spliceInPlace: (t('a), ~pos: int, ~remove: int, ~add: array('a)) => t('a);
-```
-Starting at position `~pos`, remove `~remove` elements and then add the elements from the `~add` array. Returns an array consisting of the removed items. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```re example
-let arr = [|"a", "b", "c", "d", "e", "f"|];
-Js.Array2.spliceInPlace(arr, ~pos=2, ~remove=2, ~add=[|"x", "y", "z"|]) == [|"c", "d"|];
-arr == [|"a", "b", "x", "y", "z", "e", "f"|];
-
-let arr2 = [|"a", "b", "c", "d"|];
-Js.Array2.spliceInPlace(arr2, ~pos=3, ~remove=0, ~add=[|"x", "y"|]) == [||];
-arr2 == [|"a", "b", "c", "x", "y", "d"|];
-
-let arr3 = [|"a", "b", "c", "d", "e", "f"|];
-Js.Array2.spliceInPlace(arr3, ~pos=9, ~remove=2, ~add=[|"x", "y", "z"|]) == [||];
-arr3 == [|"a", "b", "c", "d", "e", "f", "x", "y", "z"|];
-```
-
-## removeFromInPlace
-
-```re sig
-let removeFromInPlace: (t('a), ~pos: int) => t('a);
-```
-Removes elements from the given array starting at position `~pos` to the end of the array, returning the removed elements. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```re example
-let arr = [|"a", "b", "c", "d", "e", "f"|];
-Js.Array2.removeFromInPlace(arr, ~pos=4) == [|"e", "f"|];
-arr == [|"a", "b", "c", "d"|];
-```
-
-## removeCountInPlace
-
-```re sig
-let removeCountInPlace: (t('a), ~pos: int, ~count: int) => t('a);
-```
-Removes `~count` elements from the given array starting at position `~pos`, returning the removed elements. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```re example
-let arr = [|"a", "b", "c", "d", "e", "f"|];
-Js.Array2.removeCountInPlace(arr, ~pos=2, ~count=3) == [|"c", "d", "e"|];
-arr == [|"a", "b", "f"|];
-```
-
-## unshift
-
-```re sig
-let unshift: (t('a), 'a) => int;
-```
-Adds the given element to the array, returning the new number of elements in the array. *This function modifies the original array.* See [`Array.unshift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) on MDN.
-
-```re example
-let arr = [|"b", "c", "d"|];
-Js.Array2.unshift(arr, "a") == 4;
-arr == [|"a", "b", "c", "d"|];
-```
-
-## unshiftMany
-
-```re sig
-let unshiftMany: (t('a), array('a)) => int;
-```
-Adds the elements in the second array argument at the beginning of the first array argument, returning the new number of elements in the array. *This function modifies the original array.* See [`Array.unshift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) on MDN.
-
-```re example
-let arr = [|"d", "e"|];
-Js.Array2.unshiftMany(arr, [|"a", "b", "c"|]) == 5;
-arr == [|"a", "b", "c", "d", "e"|];
-```
-
-## append
-
-```re sig
-let append: (t('a), 'a) => t('a);
-```
-Deprecated. `append()` is not type-safe. Use `concat()` instead.
-
-## concat
-
-```re sig
-let concat: (t('a), t('a)) => t('a);
-```
-Concatenates the second array argument to the first array argument, returning a new array. The original arrays are not modified. See [`Array.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat) on MDN.
-
-```re example
-Js.Array2.concat([|"a", "b"|], [|"c", "d", "e"|])
-  == [|"a", "b", "c", "d", "e"|];
-```
-
-## concatMany
-
-```re sig
-let concatMany: (t('a), array(t('a))) => t('a);
-```
-The second argument to `concatMany()` is an array of arrays; these are added at the end of the first argument, returning a new array. See [`Array.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat) on MDN.
-
-```re example
-Js.Array2.concatMany([|"a", "b", "c"|], [| [|"d", "e"|], [|"f", "g", "h"|] |])
-  == [|"a", "b", "c", "d", "e", "f", "g", "h"|];
-```
-
-## includes
-
-```re sig
-let includes: (t('a), 'a) => bool;
-```
-Returns true if the given value is in the array, `false` otherwise. See [`Array.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes) on MDN.
-
-```re example
-Js.Array2.includes([|"a", "b", "c"|], "b") == true;
-Js.Array2.includes([|"a", "b", "c"|], "x") == false;
-```
-
-## indexOf
-
-```re sig
-let indexOf: (t('a), 'a) => int;
-```
-Returns the index of the first element in the array that has the given value. If the value is not in the array, returns -1. See [`Array.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf) on MDN.
-
-```re example
-Js.Array2.indexOf([|100, 101, 102, 103|], 102) == 2;
-Js.Array2.indexOf([|100, 101, 102, 103|], 999) == -1;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (t('a), 'a, ~from: int) => int;
-```
-Returns the index of the first element in the array with the given value. The search starts at position `~from`. See [`Array.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf) on MDN.
-
-```re example
-Js.Array2.indexOfFrom([|"a", "b", "a", "c", "a"|], "a", ~from=2) == 2;
-Js.Array2.indexOfFrom([|"a", "b", "a", "c", "a"|], "a", ~from=3) == 4;
-Js.Array2.indexOfFrom([|"a", "b", "a", "c", "a"|], "b", ~from=2) == -1;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (t('a), string) => string;
-```
-This function converts each element of the array to a string (via JavaScript) and concatenates them, separated by the string given in the first argument, into a single string. See [`Array.join`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join) on MDN.
-
-```re example
-Js.Array2.joinWith([|"ant", "bee", "cat"|], "--") == "ant--bee--cat";
-Js.Array2.joinWith([|"door", "bell"|], "") == "doorbell";
-Js.Array2.joinWith([|2020, 9, 4|], "/") == "2020/9/4";
-Js.Array2.joinWith([|2.5, 3.6, 3e-2|], ";") == "2.5;3.6;0.03";
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (t('a), 'a) => int;
-```
-Returns the index of the last element in the array that has the given value. If the value is not in the array, returns -1. See [`Array.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) on MDN.
-
-```re example
-Js.Array2.lastIndexOf([|"a", "b", "a", "c"|], "a") == 2;
-Js.Array2.lastIndexOf([|"a", "b", "a", "c"|], "x") == -1;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (t('a), 'a, ~from: int) => int;
-```
-Returns the index of the last element in the array that has the given value, searching from position `~from` down to the start of the array. If the value is not in the array, returns -1. See [`Array.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) on MDN.
-
-```re example
-Js.Array2.lastIndexOfFrom([|"a", "b", "a", "c", "a", "d"|], "a", ~from=3) == 2;
-Js.Array2.lastIndexOfFrom([|"a", "b", "a", "c", "a", "d"|], "c", ~from=2) == -1;
-```
-
-## slice
-
-```re sig
-let slice: (t('a), ~start: int, ~end_: int) => t('a);
-```
-Returns a shallow copy of the given array from the `~start` index up to but not including the `~end_` position. Negative numbers indicate an offset from the end of the array. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104, 105, 106|];
-Js.Array2.slice(arr, ~start=2, ~end_=5) == [|102, 103, 104|];
-Js.Array2.slice(arr, ~start=-3, ~end_=-1) == [|104, 105|];
-Js.Array2.slice(arr, ~start=9, ~end_=10) == [| |];
-```
-
-## copy
-
-```re sig
-let copy: t('a) => t('a);
-```
-Returns a copy of the entire array. Same as `Js.Array2.Slice(arr, ~start=0, ~end_=Js.Array2.length(arr))`. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-## sliceFrom
-
-```re sig
-let sliceFrom: (t('a), int) => t('a);
-```
-Returns a shallow copy of the given array from the given index to the end. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-
-```re example
-Js.Array2.sliceFrom([|100, 101, 102, 103, 104|], 2) == [|102, 103, 104|];
-```
-
-## toString
-
-```re sig
-let toString: t('a) => string;
-```
-Converts the array to a string. Each element is converted to a string using JavaScript. Unlike the JavaScript `Array.toString()`, all elements in a ReasonML array must have the same type. See [`Array.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString) on MDN.
-
-```re example
-Js.Array2.toString([|3.5, 4.6, 7.8|]) == "3.5,4.6,7.8";
-Js.Array2.toString([|"a", "b", "c"|]) == "a,b,c";
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t('a) => string;
-```
-Converts the array to a string using the conventions of the current locale. Each element is converted to a string using JavaScript. Unlike the JavaScript `Array.toLocaleString()`, all elements in a ReasonML array must have the same type. See [`Array.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toLocaleString) on MDN.
-
-```re example
-Js.Array2.toLocaleString([|Js.Date.make()|]);
-// returns "3/19/2020, 10:52:11 AM" for locale en_US.utf8
-// returns "2020-3-19 10:52:11" for locale de_DE.utf8
-```
-
-## every
-
-```re sig
-let every: (t('a), 'a => bool) => bool;
-```
-The first argument to `every()` is an array. The second argument is a predicate function that returns a boolean. The `every()` function returns `true` if the predicate function is true for all items in the given array. If given an empty array, returns `true`. See [`Array.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) on MDN.
-
-```re example
-let isEven = (x) => {x mod 2 == 0};
-Js.Array2.every( [|6, 22, 8, 4|], isEven) == true;
-Js.Array2.every([|6, 22, 7, 4|], isEven) == false;
-```
-
-## everyi
-
-```re sig
-let everyi: (t('a), ('a, int) => bool) => bool;
-The first argument to `everyi()` is an array. The second argument is a predicate function with two arguments: an array element and that element’s index; it returns a boolean. The `everyi()` function returns `true` if the predicate function is true for all items in the given array. If given an empty array, returns `true`. See [`Array.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) on MDN.
-
-```re example
-// determine if all even-index items are positive
-let evenIndexPositive = (item, index) => 
-  {(index mod 2 == 0) ? item > 0 : true;};
-
-Js.Array2.everyi([|6, -3, 5, 8|], evenIndexPositive) == true;
-Js.Array2.everyi([|6, 3, -5, 8|], evenIndexPositive) == false;
-```
-
-## filter
-
-```re sig
-let filter: (t('a), 'a => bool) => t('a);
-```
-Applies the given predicate function (the second argument) to each element in the array; the result is an array of those elements for which the predicate function returned `true`. See [`Array.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) on MDN.
-
-```re example
-let nonEmpty = (s) => {s != ""};
-Js.Array2.filter( [|"abc", "", "", "def", "ghi"|], nonEmpty)
-  == [|"abc", "def", "ghi"|];
-```
-
-## filteri
-
-```re sig
-let filteri: (t('a), ('a, int) => bool) => t('a);
-```
-Each element of the given array are passed to the predicate function. The return value is an array of all those elements for which the predicate function returned `true`.  See [`Array.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) on MDN.
-
-```re example
-// keep only positive elements at odd indices
-let positiveOddElement = (item, index) => 
-  {(index mod 2 == 1) && (item > 0)};
-
-Js.Array2.filteri([|6, 3, 5, 8, 7, -4, 1|],
-  positiveOddElement) == [|3, 8|];
-```
-
-## find
-
-```re sig
-let find: (t('a), 'a => bool) => option('a);
-```
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```re example
-// find first negative element
-Js.Array2.find([|33, 22, -55, 77, -44|], (x) => {x < 0}) == Some(-55);
-Js.Array2.find([|33, 22, 55, 77, 44|], (x) => {x < 0}) == None;
-```
-
-## findi
-
-```re sig
-let findi: (t('a), ('a, int) => bool) => option('a);
-```
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. The predicate function takes an array element and an index as its parameters. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```re example
-// find first positive item at an odd index
-let positiveOddElement = (item, index) => 
-  {(index mod 2 == 1) && (item > 0)};
-
-Js.Array2.findi([|66, -33, 55, 88, 22|], positiveOddElement) == Some(88);
-Js.Array2.findi([|66, -33, 55, -88, 22|], positiveOddElement) == None;
-```
-
-## findIndex
-
-```re sig
-let findIndex: (t('a), 'a => bool) => int;
-```
-Returns the index of the first element in the array that satisifies the given predicate function, or -1 if no element satisifies the predicate. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```re example
-Js.Array2.findIndex([|33, 22, -55, 77, -44|], (x) => {x < 0}) == 2;
-Js.Array2.findIndex([|33, 22, 55, 77, 44|], (x) => {x < 0}) == -1;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: (t('a), ('a, int) => bool) => int;
-```
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. The predicate function takes an array element and an index as its parameters. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```re example
-// find index of first positive item at an odd index
-let positiveOddElement = (item, index) => 
-  {(index mod 2 == 1) && (item > 0)};
-
-Js.Array2.findIndexi([|66, -33, 55, 88, 22|], positiveOddElement) == 3;
-Js.Array2.findIndexi([|66, -33, 55, -88, 22|], positiveOddElement) == -1;
-```
-
-## forEach
-
-```re sig
-let forEach: (t('a), 'a => unit) => unit;
-```
-The `forEach()` function applies the function given as the second argument to each element in the array. The function you provide returns `unit`, and the `forEach()` function also returns `unit`. You use `forEach()` when you need to process each element in the array but not return any new array or value; for example, to print the items in an array. See [`Array.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) on MDN.
-
-```re example
-// display all elements in an array
-Js.Array2.forEach([|"a", "b", "c"|], (x) => {Js.log(x)}) == ();
-```
-
-## forEachi
-
-```re sig
-let forEachi: (t('a), ('a, int) => unit) => unit;
-```
-The `forEachi()` function applies the function given as the second argument to each element in the array. The function you provide takes an item in the array and its index number, and returns `unit`. The `forEachi()` function also returns `unit`. You use `forEachi()` when you need to process each element in the array but not return any new array or value; for example, to print the items in an array. See [`Array.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) on MDN.
-
-```re example
-// display all elements in an array as a numbered list
-Js.Array2.forEachi([|"a", "b", "c"|], (item, index) => {Js.log2((index + 1), item)}) == ();
-```
-
-## map
-
-```re sig
-let map: (t('a), 'a => 'b) => t('b);
-```
-Applies the function (the second argument) to each item in the array, returning a new array. The result array does not have to have elements of the same type as the input array. See [`Array.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) on MDN.
-
-```re example
-Js.Array2.map([|12, 4, 8|], (x) => {x * x}) == [|144, 16, 64|];
-Js.Array2.map([|"animal", "vegetable", "mineral"|], Js.String.length)
-  == [|6, 9, 7|];
-```
-
-## mapi
-
-```re sig
-let mapi: (t('a), ('a, int) => 'b) => t('b);
-```
-Applies the function (the second argument) to each item in the array, returning a new array. The function acceps two arguments: an item from the array and its index number. The result array does not have to have elements of the same type as the input array. See [`Array.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) on MDN.
-
-```re example
-// multiply each item in array by its position
-let product = (item, index) => {item * index};
-Js.Array2.mapi([|10, 11, 12|], product) == [|0, 11, 24|];
-```
-
-## reduce
-
-```re sig
-let reduce: (t('a), ('b, 'a) => 'b, 'b) => 'b;
-```
-The `reduce()` function takes three parameters: an array, a *reducer function*,  and a beginning accumulator value. The reducer function has two parameters: an accumulated value and an element of the array.
-
-`reduce()` first calls the reducer function with the beginning value and the first element in the array. The result becomes the new accumulator value, which is passed in to the reducer function along with the second element in the array. `reduce()` proceeds through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduce()`. See [`Array.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) on MDN.
-
-```re example
-let sumOfSquares = (accumulator, item) => {
-  accumulator + (item * item);
-};
-
-Js.Array2.reduce([|10, 2, 4|], sumOfSquares, 0) == 120;
-Js.Array2.reduce([|10, 2, 4|], (*), 1) == 80;
-Js.Array2.reduce([|"animal", "vegetable", "mineral"|],
-  (acc, item) => acc + Js.String.length(item), 0) == 22; // 6 + 9 + 7
-Js.Array2.reduce([|2.0, 4.0|],
-  (acc, item) => {item /. acc}, 1.0) == 2.0; // 4.0 / (2.0 / 1.0)
-```
-
-## reducei
-
-```re sig
-let reducei: (t('a), ('b, 'a, int) => 'b, 'b) => 'b;
-```
-The `reducei()` function takes three parameters: an array, a *reducer function*, and a beginning accumulator value. The reducer function has three parameters: an accumulated value, an element of the array, and the index of that element. 
-
-`reducei()` first calls the reducer function with the beginning value, the first element in the array, and zero (its index). The result becomes the new accumulator value, which is passed to the reducer function along with the second element in the array and one (its index). `reducei()` proceeds from left to right through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reducei()`. See [`Array.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) on MDN.
-
-```re example
-// find sum of even-index elements in array
-let sumOfEvens = (accumulator, item, index) => {
-  if (index mod 2 == 0) {
-    accumulator + item;
-  } else {
-    accumulator;
-  }
-};
-
-Js.Array2.reducei([|2, 5, 1, 4, 3|], sumOfEvens, 0) == 6;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: (t('a), ('b, 'a) => 'b, 'b) => 'b;
-```
-The `reduceRight()` function takes three parameters: an array, a *reducer function*, and a beginning accumulator value. The reducer function has two parameters: an accumulated value and an element of the array.
-
-`reduceRight()` first calls the reducer function with the beginning value and the last element in the array. The result becomes the new accumulator value, which is passed in to the reducer function along with the next-to-last element in the array. `reduceRight()` proceeds from right to left through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduceRight()`.  See [`Array.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight) on MDN.
-
-**NOTE:** In many cases, `reduce()` and `reduceRight()` give the same result. However, see the last example here and compare it to the example from `reduce()`, where order makes a difference.
-
-```re example
-let sumOfSquares = (accumulator, item) => {
-  accumulator + (item * item);
-};
-
-Js.Array2.reduceRight([|10, 2, 4|], sumOfSquares, 0) == 120;
-Js.Array2.reduceRight([|2.0, 4.0|],
-  (acc, item) => {item /. acc}, 1.0) == 0.5; // 2.0 / (4.0 / 1.0)
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: (t('a), ('b, 'a, int) => 'b, 'b) => 'b;
-```
-The `reduceRighti()` function takes three parameters: an array, a *reducer function*, and a beginning accumulator value. The reducer function has three parameters: an accumulated value, an element of the array, and the index of that element. `reduceRighti()` first calls the reducer function with the beginning value, the last element in the array, and its index (length of array minus one). The result becomes the new accumulator value, which is passed in to the reducer function along with the second element in the array and one (its index). `reduceRighti()` proceeds from right to left through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduceRighti()`. See [`Array.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight) on MDN.
-
-**NOTE:** In many cases, `reducei()` and `reduceRighti()` give the same result. However, there are cases where the order in which items are processed makes a difference.
-
-```re example
-// find sum of even-index elements in array
-let sumOfEvens = (accumulator, item, index) => {
-  if (index mod 2 == 0) {
-    accumulator + item;
-  } else {
-    accumulator;
-  }
-};
-
-Js.Array2.reduceRighti([|2, 5, 1, 4, 3|], sumOfEvens, 0) == 6;
-```
-
-## some
-
-```re sig
-let some: (t('a), 'a => bool) => bool;
-```
-Returns `true` if the predicate function given as the second argument to `some()` returns `true` for any element in the array; `false` otherwise.
-
-```re example
-let isEven = (x) => {x mod 2 == 0};
-
-Js.Array2.some([|3, 7, 5, 2, 9|], isEven) == true;
-Js.Array2.some([|3, 7, 5, 1, 9|], isEven) == false;
-```
-
-## somei
-
-```re sig
-let somei: (t('a), ('a, int) => bool) => bool;
-```
-Returns `true` if the predicate function given as the second argument to `somei()` returns `true` for any element in the array; `false` otherwise. The predicate function has two arguments: an item from the array and the index value
-
-```re example
-// Does any string in the array
-// have the same length as its index?
-
-let sameLength = (str, index) => {
-  Js.String.length(str) == index;
-}
-
-// "ef" has length 2 and is it at index 2
-Js.Array2.somei([|"ab", "cd", "ef", "gh"|], sameLength) == true;
-// no item has the same length as its index
-Js.Array2.somei([|"a", "bc", "def", "gh"|], sameLength) == false;
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (array('a), int) => 'a;
-```
-Returns the value at the given position in the array if the position is in bounds; returns the JavaScript value `undefined` otherwise.
-
-```re example
-let arr = [|100, 101, 102, 103|];
-Js.Array2.unsafe_get(arr, 3) == 103;
-Js.Array2.unsafe_get(arr, 4); // returns undefined
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (array('a), int, 'a) => unit;
-```
-Sets the value at the given position in the array if the position is in bounds. If the index is out of bounds, well, “here there be dragons.“ *This function modifies the original array.*
-
-```re example
-let arr = [|100, 101, 102, 103|];
-Js.Array2.unsafe_set(arr, 3, 99);
-// result is [|100, 101, 102, 99|];
-
-Js.Array2.unsafe_set(arr, 4, 88);
-// result is [|100, 101, 102, 99, 88|]
-
-Js.Array2.unsafe_set(arr, 6, 77);
-// result is [|100, 101, 102, 99, 88, <1 empty item>, 77|]
-
-Js.Array2.unsafe_set(arr, -1, 66);
-// you don't want to know.
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/array.mdx b/pages/docs/manual/v8.0.0/api/js/array.mdx
deleted file mode 100644
index 29e47e346..000000000
--- a/pages/docs/manual/v8.0.0/api/js/array.mdx
+++ /dev/null
@@ -1,944 +0,0 @@
-# Array
-
-<Intro>
-
-Provides bindings to JavaScript’s `Array` functions. These bindings are optimized for pipe-last (`|>`), where the array to be processed is the last parameter in the function.
-
-Here is an example to find the sum of squares of all even numbers in an array.
-Without pipe last, we must call the functions in reverse order:
-
-```re example
-let isEven = (x) => {x mod 2 == 0};
-let square = (x) => {x * x};
-let result = Js.Array.(
-  reduce((+), 0, map(square, filter(isEven,[|5, 2, 3, 4, 1|])))
-  );
-```
-
-With pipe last, we call the functions in the “natural” order:
-
-```re example
-let isEven = (x) => {x mod 2 == 0};
-let square = (x) => {x * x};
-let result = Js.Array.(
-    [|5, 2, 3, 4, 1|] |>
-  	filter(isEven) |>
-    map(square) |>
-    reduce((+), 0)
-  );
-```
-
-</Intro>
-
-## t
-
-```re sig
-type t('a) = array('a);
-```
-
-The type used to describe a JavaScript array.
-
-## array_like
-
-```re sig
-type array_like('a) = Js_array2.array_like('a);
-```
-
-A type used to describe JavaScript objects that are like an array or are iterable.
-
-## from
-
-```re sig
-let from: array_like('a) => array('b);
-```
-
-Creates a shallow copy of an array from an array-like object. See [`Array.from`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from) on MDN. 
-
-```re example
-let strArr = Js.String.castToArrayLike("abcd");
-Js.Array.from(strArr) == [|"a", "b", "c", "d"|];
-```
-
-## fromMap
-
-```re sig
-let fromMap: (array_like('a), 'a => 'b) => array('b);
-```
-
-Creates a new array by applying a function (the second argument) to each item in the `array_like` first argument.  See [`Array.from`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from) on MDN.
-
-```re example
-let strArr = Js.String.castToArrayLike("abcd");
-let code = (s) => {Js.String.charCodeAt(0, s)};
-Js.Array.fromMap(strArr, code) == [|97.0, 98.0, 99.0, 100.0|];
-```
-
-## isArray
-
-```re sig
-let isArray: 'a => bool;
-```
-
-Returns `true` if its argument is an array; `false` otherwise. This is a runtime check, which is why the second example returns `true`---a list is internally represented as a nested JavaScript array.
-
-```re example
-Js.Array.isArray([|5, 2, 3, 1, 4|]) == true;
-Js.Array.isArray([5, 2, 3, 1, 4]) == true;
-Js.Array.isArray("abcd") == false;
-```
-
-## length
-
-```re sig
-let length: array('a) => int;
-```
-
-Returns the number of elements in the array. See [`Array.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length) on MDN.
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t('a)) => t('a);
-```
-
-Copies from the first element in the given array to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104|];
-Js.Array.copyWithin(~to_=2, arr)
-  == [|100, 101, 100, 101, 102|];
-arr == [|100, 101, 100, 101, 102|];
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t('a)) => t('a);
-```
-
-Copies starting at element `~from` in the given array to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104|];
-Js.Array.copyWithinFrom(~from=2, ~to_=0, arr)
-  == [|102, 103, 104, 103, 104|];
-arr == [|102, 103, 104, 103, 104|];
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t('a)) => t('a);
-```
-
-Copies starting at element `~start` in the given array up to but not including `~end_` to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104, 105|];
-Js.Array.copyWithinFromRange(~start=2, ~end_=5, ~to_=1, arr)
-  == [|100, 102, 103, 104, 104, 105|];
-arr == [|100, 102, 103, 104, 104, 105|];
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: ('a, t('a)) => t('a);
-```
-Sets all elements of the given array (the second arumgent) to the designated value (the first argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104|];
-Js.Array.fillInPlace(99, arr)
-   == [|99, 99, 99, 99, 99|];
-arr == [|99, 99, 99, 99, 99|];
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: ('a, ~from: int, t('a)) => t('a);
-```
-Sets all elements of the given array (the last arumgent) from position `~from` to the end to the designated value (the first argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104|];
-Js.Array.fillFromInPlace(99, ~from=2, arr)
-   == [|100, 101, 99, 99, 99|];
-arr == [|100, 101, 99, 99, 99|];
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: ('a, ~start: int, ~end_: int, t('a)) => t('a);
-```
-
-Sets the elements of the given array (the last arumgent) from position `~start` up to but not including position `~end_` to the designated value (the first argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104|];
-Js.Array.fillRangeInPlace(99, ~start=1, ~end_=4, arr)
-  == [|100, 99, 99, 99, 104|];
-arr == [|100, 99, 99, 99, 104|];
-```                                           
-
-## pop
-
-```re sig
-let pop: t('a) => option('a);
-```
-
-If the array is not empty, removes the last element and returns it as `Some(value)`; returns `None` if the array is empty. *This function modifies the original array.* See [`Array.pop`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104|];
-Js.Array.pop(arr) == Some(104);
-arr == [|100, 101, 102, 103|];
-
-let empty: array(int) = [| |];
-Js.Array.pop(empty) == None;
-```
-
-## push
-
-```re sig
-let push: ('a, t('a)) => int;
-```
-
-Appends the given value to the array, returning the number of elements in the updated array. *This function modifies the original array.* See [`Array.push`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) on MDN.
-
-```re example
-let arr = [|"ant", "bee", "cat"|];
-Js.Array.push("dog", arr) == 4;
-arr == [|"ant", "bee", "cat", "dog"|];
-```
-
-## pushMany
-
-```re sig
-let pushMany: (array('a), t('a)) => int;
-```
-
-Appends the values from one array (the first argument) to another (the second argument), returning the number of elements in the updated array. *This function modifies the original array.* See [`Array.push`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) on MDN.
-
-```re example
-let arr = [|"ant", "bee", "cat"|];
-Js.Array.pushMany([|"dog", "elk"|], arr) == 5;
-arr == [|"ant", "bee", "cat", "dog", "elk"|];
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t('a) => t('a);
-```
-
-Returns an array with the elements of the input array in reverse order. *This function modifies the original array.* See [`Array.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse) on MDN.
-
-```re example
-let arr = [|"ant", "bee", "cat"|];
-Js.Array.reverseInPlace(arr) == [|"cat", "bee", "ant"|];
-arr == [|"cat", "bee", "ant"|];
-```
-
-## shift
-
-```re sig
-let shift: t('a) => option('a);
-```
-If the array is not empty, removes the first element and returns it as `Some(value)`; returns `None` if the array is empty. *This function modifies the original array.* See [`Array.shift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104|];
-Js.Array.shift(arr) == Some(100);
-arr == [|101, 102, 103, 104|];
-
-let empty: array(int) = [| |];
-Js.Array.shift(empty) == None;
-```
-## sortInPlace
-
-```re sig
-let sortInPlace: t('a) => t('a);
-```
-
-Sorts the given array in place and returns the sorted array. JavaScript sorts the array by converting the arguments to UTF-16 strings and sorting them. See the second example with sorting numbers, which does not do a numeric sort. *This function modifies the original array.* See [`Array.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) on MDN.
-
-```re example
-let words = [|"bee", "dog", "ant", "cat"|];
-Js.Array.sortInPlace(words) == [|"ant", "bee", "cat", "dog"|];
-words == [|"ant", "bee", "cat", "dog"|];
-
-let numbers = [|3, 30, 10, 1, 20, 2|];
-Js.Array.sortInPlace(numbers) == [|1, 10, 2, 20, 3, 30|];
-numbers == [|1, 10, 2, 20, 3, 30|];
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: (('a, 'a) => int, t('a)) => t('a);
-```
-
-Sorts the given array in place and returns the sorted array. *This function modifies the original array.*
-
-The first argument to `sortInPlaceWith()` is a function that compares two items from the array and returns:
-
-* an integer less than zero if the first item is less than the second item
-* zero if the items are equal
-* an integer greater than zero if the first item is greater than the second item
-
-See [`Array.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) on MDN.
-
-```re example
-// sort by word length
-let words = [|"horse", "aardvark", "dog", "camel"|];
-let byLength = (s1, s2) => {
-  Js.String.length(s1) - Js.String.length(s2);
-};
-
-Js.Array.sortInPlaceWith(byLength, words)
-  == [|"dog", "horse", "camel", "aardvark"|];
-  
-// sort in reverse numeric order
-let numbers = [|3, 30, 10, 1, 20, 2|];
-let reverseNumeric = (n1, n2) => {n2 - n1};
-Js.Array.sortInPlaceWith(reverseNumeric, numbers)
-  == [|30, 20, 10, 3, 2, 1|];
-```
-
-## spliceInPlace
-
-```re sig
-let spliceInPlace: (~pos: int, ~remove: int, ~add: array('a), t('a)) => t('a);
-```
-
-Starting at position `~pos`, remove `~remove` elements and then add the elements from the `~add` array. Returns an array consisting of the removed items. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```re example
-let arr = [|"a", "b", "c", "d", "e", "f"|];
-Js.Array.spliceInPlace(~pos=2, ~remove=2, ~add=[|"x", "y", "z"|], arr) == [|"c", "d"|];
-arr == [|"a", "b", "x", "y", "z", "e", "f"|];
-
-let arr2 = [|"a", "b", "c", "d"|];
-Js.Array.spliceInPlace(~pos=3, ~remove=0, ~add=[|"x", "y"|], arr2) == [||];
-arr2 == [|"a", "b", "c", "x", "y", "d"|];
-
-let arr3 = [|"a", "b", "c", "d", "e", "f"|];
-Js.Array.spliceInPlace(~pos=9, ~remove=2, ~add=[|"x", "y", "z"|], arr3) == [||];
-arr3 == [|"a", "b", "c", "d", "e", "f", "x", "y", "z"|];
-```
-
-## removeFromInPlace
-
-```re sig
-let removeFromInPlace: (~pos: int, t('a)) => t('a);
-```
-
-Removes elements from the given array starting at position `~pos` to the end of the array, returning the removed elements. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```re example
-let arr = [|"a", "b", "c", "d", "e", "f"|];
-Js.Array.removeFromInPlace(~pos=4, arr) == [|"e", "f"|];
-arr == [|"a", "b", "c", "d"|];
-```
-
-## removeCountInPlace
-
-```re sig
-let removeCountInPlace: (~pos: int, ~count: int, t('a)) => t('a);
-```
-
-Removes `~count` elements from the given array starting at position `~pos`, returning the removed elements. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```re example
-let arr = [|"a", "b", "c", "d", "e", "f"|];
-Js.Array.removeCountInPlace(~pos=2, ~count=3, arr) == [|"c", "d", "e"|];
-arr == [|"a", "b", "f"|];
-```
-
-## unshift
-
-```re sig
-let unshift: ('a, t('a)) => int;
-```
-
-Adds the given element to the array, returning the new number of elements in the array. *This function modifies the original array.* See [`Array.unshift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) on MDN.
-
-```re example
-let arr = [|"b", "c", "d"|];
-Js.Array.unshift("a", arr) == 4;
-arr == [|"a", "b", "c", "d"|];
-```
-
-## unshiftMany
-
-```re sig
-let unshiftMany: (array('a), t('a)) => int;
-```
-
-Adds the elements in the first array argument at the beginning of the second array argument, returning the new number of elements in the array. *This function modifies the original array.* See [`Array.unshift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) on MDN.
-
-```re example
-let arr = [|"d", "e"|];
-Js.Array.unshiftMany([|"a", "b", "c"|], arr) == 5;
-arr == [|"a", "b", "c", "d", "e"|];
-```
-
-## append
-
-```re sig
-let append: ('a, t('a)) => t('a);
-```
-
-Deprecated. `append()` is not type-safe. Use `concat()` instead.
-
-## concat
-
-```re sig
-let concat: (t('a), t('a)) => t('a);
-```
-
-Concatenates the first array argument to the second array argument, returning a new array. The original arrays are not modified. See [`Array.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat) on MDN.
-
-```re example
-Js.Array.concat([|"c", "d", "e"|], [|"a", "b"|])
-  == [|"a", "b", "c", "d", "e"|];
-```
-
-## concatMany
-
-```re sig
-let concatMany: (array(t('a)), t('a)) => t('a);
-```
-
-The first argument to `concatMany()` is an array of arrays; these are added at the end of the second argument, returning a new array. See [`Array.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat) on MDN.
-
-```re example
-Js.Array.concatMany([| [|"d", "e"|], [|"f", "g", "h"|] |], [|"a", "b", "c"|])
-  == [|"a", "b", "c", "d", "e", "f", "g", "h"|];
-```
-
-## includes
-
-```re sig
-let includes: ('a, t('a)) => bool;
-```
-
-Returns true if the given value is in the array, `false` otherwise. See [`Array.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes) on MDN.
-
-```re example
-Js.Array.includes("b", [|"a", "b", "c"|]) == true;
-Js.Array.includes("x", [|"a", "b", "c"|]) == false;
-```
-
-## indexOf
-
-```re sig
-let indexOf: ('a, t('a)) => int;
-```
-Returns the index of the first element in the array that has the given value. If the value is not in the array, returns -1. See [`Array.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf) on MDN.
-
-```re example
-Js.Array.indexOf(102, [|100, 101, 102, 103|]) == 2;
-Js.Array.indexOf(999, [|100, 101, 102, 103|]) == -1;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: ('a, ~from: int, t('a)) => int;
-```
-
-Returns the index of the first element in the array with the given value. The search starts
-at position `~from`. See [`Array.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf) on MDN.
-
-```re example
-Js.Array.indexOfFrom("a", ~from=2, [|"a", "b", "a", "c", "a"|]) == 2;
-Js.Array.indexOfFrom("a", ~from=3, [|"a", "b", "a", "c", "a"|]) == 4;
-Js.Array.indexOfFrom("b", ~from=2, [|"a", "b", "a", "c", "a"|]) == -1;
-```
-
-## join
-
-```re sig
-let join: t('a) => string;
-```
-Deprecated. Use `joinWith` instead.
-
-## joinWith
-
-```re sig
-let joinWith: (string, t('a)) => string;
-```
-This function converts each element of the array to a string (via JavaScript) and concatenates them, separated by the string given in the first argument, into a single string. See [`Array.join`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join) on MDN.
-
-```re example
-Js.Array.joinWith("--",[|"ant", "bee", "cat"|]) == "ant--bee--cat";
-Js.Array.joinWith("", [|"door", "bell"|]) == "doorbell";
-Js.Array.joinWith("/", [|2020, 9, 4|]) == "2020/9/4";
-Js.Array.joinWith(";", [|2.5, 3.6, 3e-2|]) == "2.5;3.6;0.03";
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: ('a, t('a)) => int;
-```
-
-Returns the index of the last element in the array that has the given value. If the value is not in the array, returns -1. See [`Array.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) on MDN.
-
-```re example
-Js.Array.lastIndexOf("a", [|"a", "b", "a", "c"|]) == 2;
-Js.Array.lastIndexOf("x", [|"a", "b", "a", "c"|]) == -1;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: ('a, ~from: int, t('a)) => int;
-```
-
-Returns the index of the last element in the array that has the given value, searching from position `~from` down to the start of the array. If the value is not in the array, returns -1. See [`Array.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) on MDN.
-
-```re example
-Js.Array.lastIndexOfFrom("a", ~from=3, [|"a", "b", "a", "c", "a", "d"|]) == 2;
-Js.Array.lastIndexOfFrom("c", ~from=2, [|"a", "b", "a", "c", "a", "d"|]) == -1;
-```
-
-## lastIndexOf_start
-
-```re sig
-let lastIndexOf_start: ('a, t('a)) => int;
-```
-
-Deprecated. Please use `lastIndexOf`.
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t('a)) => t('a);
-```
-
-Returns a shallow copy of the given array from the `~start` index up to but not including the `~end_` position. Negative numbers indicate an offset from the end of the array. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-
-```re example
-let arr = [|100, 101, 102, 103, 104, 105, 106|];
-Js.Array.slice(~start=2, ~end_=5, arr) == [|102, 103, 104|];
-Js.Array.slice(~start=-3, ~end_=-1, arr) == [|104, 105|];
-Js.Array.slice(~start=9, ~end_=10, arr) == [| |];
-```
-
-## copy
-
-```re sig
-let copy: t('a) => t('a);
-```
-
-Returns a copy of the entire array. Same as `Js.Array.Slice(~start=0, ~end_=Js.Array.length(arr), arr)`. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-
-## slice_copy
-
-```re sig
-let slice_copy: (unit, t('a)) => t('a);
-```
-
-Deprecated. Please use `copy`.
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t('a)) => t('a);
-```
-
-Returns a shallow copy of the given array from the given index to the end. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-
-```re example
-Js.Array.sliceFrom(2, [|100, 101, 102, 103, 104|]) == [|102, 103, 104|];
-```
-
-## slice_start
-
-```re sig
-let slice_start: (int, t('a)) => t('a);
-```
-
-Deprecated. Please `sliceFrom`.
-
-## toString
-
-```re sig
-let toString: t('a) => string;
-```
-
-Converts the array to a string. Each element is converted to a string using JavaScript. Unlike the JavaScript `Array.toString()`, all elements in a ReasonML array must have the same type. See [`Array.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString) on MDN.
-
-```re example
-Js.Array.toString([|3.5, 4.6, 7.8|]) == "3.5,4.6,7.8";
-Js.Array.toString([|"a", "b", "c"|]) == "a,b,c";
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t('a) => string;
-```
-
-Converts the array to a string using the conventions of the current locale. Each element is converted to a string using JavaScript. Unlike the JavaScript `Array.toLocaleString()`, all elements in a ReasonML array must have the same type. See [`Array.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toLocaleString) on MDN.
-
-```re example
-Js.Array.toLocaleString([|Js.Date.make()|]);
-// returns "3/19/2020, 10:52:11 AM" for locale en_US.utf8
-// returns "2020-3-19 10:52:11" for locale de_DE.utf8
-```
-
-## every
-
-```re sig
-let every: ('a => bool, t('a)) => bool;
-```
-
-The first argument to `every()` is a predicate function that returns a boolean. The `every()` function returns `true` if the predicate function is true for all items in the given array. If given an empty array, returns `true`. See [`Array.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) on MDN.
-
-```re example
-let isEven = (x) => {x mod 2 == 0};
-Js.Array.every(isEven, [|6, 22, 8, 4|]) == true;
-Js.Array.every(isEven, [|6, 22, 7, 4|]) == false;
-```
-
-## everyi
-
-```re sig
-let everyi: (('a, int) => bool, t('a)) => bool;
-```
-
-The first argument to `everyi()` is a predicate function with two arguments: an array element and that element’s index; it returns a boolean. The `everyi()` function returns `true` if the predicate function is true for all items in the given array. If given an empty array, returns `true`. See [`Array.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) on MDN.
-
-```re example
-// determine if all even-index items are positive
-let evenIndexPositive = (item, index) => 
-  {(index mod 2 == 0) ? item > 0 : true;};
-
-Js.Array.everyi(evenIndexPositive, [|6, -3, 5, 8|]) == true;
-Js.Array.everyi(evenIndexPositive, [|6, 3, -5, 8|]) == false;
-```
-
-## filter
-
-```re sig
-let filter: ('a => bool, t('a)) => t('a);
-```
-
-Applies the given predicate function to each element in the array; the result is an array of those elements for which the predicate function returned `true`. See [`Array.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) on MDN.
-
-```re example
-let nonEmpty = (s) => {s != ""};
-Js.Array.filter(nonEmpty, [|"abc", "", "", "def", "ghi"|])
-  == [|"abc", "def", "ghi"|];
-```
-
-
-## filteri
-
-```re sig
-let filteri: (('a, int) => bool, t('a)) => t('a);
-```
-
-Each element of the given array are passed to the predicate function. The return value is an array of all those elements for which the predicate function returned `true`.  See [`Array.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) on MDN.
-
-```re example
-// keep only positive elements at odd indices
-let positiveOddElement = (item, index) => 
-  {(index mod 2 == 1) && (item > 0)};
-
-Js.Array.filteri(positiveOddElement,
-  [|6, 3, 5, 8, 7, -4, 1|]) == [|3, 8|];
-```
-
-## find
-
-```re sig
-let find: ('a => bool, t('a)) => option('a);
-```
-
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```re example
-// find first negative element
-Js.Array.find((x) => {x < 0}, [|33, 22, -55, 77, -44|]) == Some(-55);
-Js.Array.find((x) => {x < 0}, [|33, 22, 55, 77, 44|]) == None;
-```
-
-## findi
-
-```re sig
-let findi: (('a, int) => bool, t('a)) => option('a);
-```
-
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. The predicate function takes an array element and an index as its parameters. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```re example
-// find first positive item at an odd index
-let positiveOddElement = (item, index) => 
-  {(index mod 2 == 1) && (item > 0)};
-
-Js.Array.findi(positiveOddElement, [|66, -33, 55, 88, 22|]) == Some(88);
-Js.Array.findi(positiveOddElement, [|66, -33, 55, -88, 22|]) == None;
-```
-
-## findIndex
-
-```re sig
-let findIndex: ('a => bool, t('a)) => int;
-```
-
-Returns the index of the first element in the array that satisifies the given predicate function, or -1 if no element satisifies the predicate. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```re example
-Js.Array.findIndex((x) => {x < 0}, [|33, 22, -55, 77, -44|]) == 2;
-Js.Array.findIndex((x) => {x < 0}, [|33, 22, 55, 77, 44|]) == -1;
-```
-## findIndexi
-
-```re sig
-let findIndexi: (('a, int) => bool, t('a)) => int;
-```
-
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. The predicate function takes an array element and an index as its parameters. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```re example
-// find index of first positive item at an odd index
-let positiveOddElement = (item, index) => 
-  {(index mod 2 == 1) && (item > 0)};
-
-Js.Array.findIndexi(positiveOddElement, [|66, -33, 55, 88, 22|]) == 3;
-Js.Array.findIndexi(positiveOddElement, [|66, -33, 55, -88, 22|]) == -1;
-```
-
-## forEach
-
-```re sig
-let forEach: ('a => unit, t('a)) => unit;
-```
-
-The `forEach()` function applies the function given as the first argument to each element in the array. The function you provide returns `unit`, and the `forEach()` function also returns `unit`. You use `forEach()` when you need to process each element in the array but not return any new array or value; for example, to print the items in an array. See [`Array.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) on MDN.
-
-```re example
-// display all elements in an array
-Js.Array.forEach((x) => Js.log(x), [|"a", "b", "c"|]) == ();
-```
-
-## forEachi
-
-```re sig
-let forEachi: (('a, int) => unit, t('a)) => unit;
-```
-
-The `forEachi()` function applies the function given as the first argument to each element in the array. The function you provide takes an item in the array and its index number, and returns `unit`. The `forEachi()` function also returns `unit`. You use `forEachi()` when you need to process each element in the array but not return any new array or value; for example, to print the items in an array. See [`Array.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) on MDN.
-
-```re example
-// display all elements in an array as a numbered list
-Js.Array.forEachi((item, index) => Js.log2((index + 1), item), [|"a", "b", "c"|]) == ();
-```
-
-## map
-
-```re sig
-let map: ('a => 'b, t('a)) => t('b);
-```
-
-Applies the function (given as the first argument) to each item in the array, returning a new array. The result array does not have to have elements of the same type as the input array. See [`Array.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) on MDN.
-
-```re example
-Js.Array.map((x) => x * x, [|12, 4, 8|]) == [|144, 16, 64|];
-Js.Array.map(Js.String.length, [|"animal", "vegetable", "mineral"|])
-  == [|6, 9, 7|];
-```
-
-## mapi
-
-```re sig
-let mapi: (('a, int) => 'b, t('a)) => t('b);
-```
-
-Applies the function (given as the first argument) to each item in the array, returning a new array. The function acceps two arguments: an item from the array and its index number. The result array does not have to have elements of the same type as the input array. See [`Array.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) on MDN.
-
-```re example
-// multiply each item in array by its position
-let product = (item, index) => {item * index};
-Js.Array.mapi(product, [|10, 11, 12|]) == [|0, 11, 24|];
-```
-
-## reduce
-
-```re sig
-let reduce: (('b, 'a) => 'b, 'b, t('a)) => 'b;
-```
-
-The `reduce()` function takes three parameters: a *reducer function*, a beginning accumulator value, and an array. The reducer function has two parameters: an accumulated value and an element of the array.
-
-`reduce()` first calls the reducer function with the beginning value and the first element in the array. The result becomes the new accumulator value, which is passed in to the reducer function along with the second element in the array. `reduce()` proceeds through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduce()`. See [`Array.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) on MDN.
-
-```re example
-let sumOfSquares = (accumulator, item) => {
-  accumulator + (item * item);
-};
-
-Js.Array.reduce(sumOfSquares, 0, [|10, 2, 4|]) == 120;
-Js.Array.reduce((*), 1, [|10, 2, 4|]) == 80;
-Js.Array.reduce((acc, item) => acc + Js.String.length(item), 0,
-  [|"animal", "vegetable", "mineral"|]) == 22; // 6 + 9 + 7
-Js.Array.reduce((acc, item) => {item /. acc}, 1.0,
-  [|2.0, 4.0|]) == 2.0; // 4.0 / (2.0 / 1.0)
-```
-
-## reducei
-
-```re sig
-let reducei: (('b, 'a, int) => 'b, 'b, t('a)) => 'b;
-```
-
-The `reducei()` function takes three parameters: a *reducer function*, a beginning accumulator value, and an array. The reducer function has three parameters: an accumulated value, an element of the array, and the index of that element. 
-
-`reducei()` first calls the reducer function with the beginning value, the first element in the array, and zero (its index). The result becomes the new accumulator value, which is passed to the reducer function along with the second element in the array and one (its index). `reducei()` proceeds from left to right through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reducei()`. See [`Array.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) on MDN.
-
-```re example
-// find sum of even-index elements in array
-let sumOfEvens = (accumulator, item, index) => {
-  if (index mod 2 == 0) {
-    accumulator + item;
-  } else {
-    accumulator;
-  }
-};
-
-Js.Array.reducei(sumOfEvens, 0, [|2, 5, 1, 4, 3|]) == 6;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: (('b, 'a) => 'b, 'b, t('a)) => 'b;
-```
-
-The `reduceRight()` function takes three parameters: a *reducer function*, a beginning accumulator value, and an array. The reducer function has two parameters: an accumulated value and an element of the array.
-
-`reduceRight()` first calls the reducer function with the beginning value and the last element in the array. The result becomes the new accumulator value, which is passed in to the reducer function along with the next-to-last element in the array. `reduceRight()` proceeds from right to left through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduceRight()`.  See [`Array.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight) on MDN.
-
-**NOTE:** In many cases, `reduce()` and `reduceRight()` give the same result. However, see the last example here and compare it to the example from `reduce()`, where order makes a difference.
-
-```re example
-let sumOfSquares = (accumulator, item) => {
-  accumulator + (item * item);
-};
-
-Js.Array.reduceRight(sumOfSquares, 0, [|10, 2, 4|]) == 120;
-Js.Array.reduceRight((acc, item) => {item /. acc}, 1.0,
-  [|2.0, 4.0|]) == 0.5; // 2.0 / (4.0 / 1.0)
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: (('b, 'a, int) => 'b, 'b, t('a)) => 'b;
-```
-
-The `reduceRighti()` function takes three parameters: a *reducer function*, a beginning accumulator value, and an array. The reducer function has three parameters: an accumulated value, an element of the array, and the index of that element. `reduceRighti()` first calls the reducer function with the beginning value, the last element in the array, and its index (length of array minus one). The result becomes the new accumulator value, which is passed in to the reducer function along with the second element in the array and one (its index). `reduceRighti()` proceeds from right to left through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduceRighti()`. See [`Array.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight) on MDN.
-
-**NOTE:** In many cases, `reducei()` and `reduceRighti()` give the same result. However, there are cases where the order in which items are processed makes a difference.
-
-```re example
-// find sum of even-index elements in array
-let sumOfEvens = (accumulator, item, index) => {
-  if (index mod 2 == 0) {
-    accumulator + item;
-  } else {
-    accumulator;
-  }
-};
-
-Js.Array.reduceRighti(sumOfEvens, 0, [|2, 5, 1, 4, 3|]) == 6;
-```
-
-## some
-
-```re sig
-let some: ('a => bool, t('a)) => bool;
-```
-
-Returns `true` if the predicate function given as the first argument to `some()` returns `true` for any element in the array; `false` otherwise.
-
-```re example
-let isEven = (x) => {x mod 2 == 0};
-
-Js.Array.some(isEven, [|3, 7, 5, 2, 9|]) == true;
-Js.Array.some(isEven, [|3, 7, 5, 1, 9|]) == false;
-```
-
-## somei
-
-```re sig
-let somei: (('a, int) => bool, t('a)) => bool;
-```
-
-Returns `true` if the predicate function given as the first argument to `somei()` returns `true` for any element in the array; `false` otherwise. The predicate function has two arguments: an item from the array and the index value
-
-```re example
-// Does any string in the array
-// have the same length as its index?
-
-let sameLength = (str, index) => {
-  Js.String.length(str) == index;
-}
-
-// "ef" has length 2 and is it at index 2
-Js.Array.somei(sameLength, [|"ab", "cd", "ef", "gh"|]) == true;
-// no item has the same length as its index
-Js.Array.somei(sameLength, [|"a", "bc", "def", "gh"|]) == false;
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (array('a), int) => 'a;
-```
-Returns the value at the given position in the array if the position is in bounds; returns
-the JavaScript value `undefined` otherwise.
-
-```re example
-let arr = [|100, 101, 102, 103|];
-Js.Array.unsafe_get(arr, 3) == 103;
-Js.Array.unsafe_get(arr, 4); // returns undefined
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (array('a), int, 'a) => unit;
-```
-
-Sets the value at the given position in the array if the position is in bounds. If the index is out of bounds, well, “here there be dragons.“ *This function modifies the original array.*
-
-```re example
-let arr = [|100, 101, 102, 103|];
-Js.Array.unsafe_set(arr, 3, 99);
-// result is [|100, 101, 102, 99|];
-
-Js.Array.unsafe_set(arr, 4, 88);
-// result is [|100, 101, 102, 99, 88|]
-
-Js.Array.unsafe_set(arr, 6, 77);
-// result is [|100, 101, 102, 99, 88, <1 empty item>, 77|]
-
-Js.Array.unsafe_set(arr, -1, 66);
-// you don't want to know.
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/console.mdx b/pages/docs/manual/v8.0.0/api/js/console.mdx
deleted file mode 100644
index 46fee0bf9..000000000
--- a/pages/docs/manual/v8.0.0/api/js/console.mdx
+++ /dev/null
@@ -1,114 +0,0 @@
-# Console
-
-<Intro>
-
-Provide console (logging) utilities.
-
-</Intro>
-
-
-## log
-
-```re sig
-let log: 'a => unit;
-```
-
-```re sig
-let log2: ('a, 'b) => unit;
-```
-
-```re sig
-let log3: ('a, 'b, 'c) => unit;
-```
-
-```re sig
-let log4: ('a, 'b, 'c, 'd) => unit;
-```
-
-```re sig
-let logMany: array('a) => unit;
-```
-
-## info
-
-```re sig
-let info: 'a => unit;
-```
-
-```re sig
-let info2: ('a, 'b) => unit;
-```
-
-```re sig
-let info3: ('a, 'b, 'c) => unit;
-```
-
-```re sig
-let info4: ('a, 'b, 'c, 'd) => unit;
-```
-
-```re sig
-let infoMany: array('a) => unit;
-```
-
-## warn
-
-```re sig
-let warn: 'a => unit;
-```
-
-```re sig
-let warn2: ('a, 'b) => unit;
-```
-
-```re sig
-let warn3: ('a, 'b, 'c) => unit;
-```
-
-```re sig
-let warn4: ('a, 'b, 'c, 'd) => unit;
-```
-
-```re sig
-let warnMany: array('a) => unit;
-```
-
-## error
-
-```re sig
-let error: 'a => unit;
-```
-
-```re sig
-let error2: ('a, 'b) => unit;
-```
-
-```re sig
-let error3: ('a, 'b, 'c) => unit;
-```
-
-```re sig
-let error4: ('a, 'b, 'c, 'd) => unit;
-```
-
-```re sig
-let errorMany: array('a) => unit;
-```
-
-## trace
-
-```re sig
-let trace: unit => unit;
-```
-
-## timeStart
-
-```re sig
-let timeStart: string => unit;
-```
-
-## timeEnd
-
-```re sig
-let timeEnd: string => unit;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/date.mdx b/pages/docs/manual/v8.0.0/api/js/date.mdx
deleted file mode 100644
index e8de680bc..000000000
--- a/pages/docs/manual/v8.0.0/api/js/date.mdx
+++ /dev/null
@@ -1,989 +0,0 @@
-# Date
-
-<Intro>
-
-Provide bindings to JS date. (See [`Date`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date) on MDN.) JavaScript stores dates as the number of milliseconds since
-the UNIX *epoch*, midnight 1 January 1970, UTC.
-</Intro>
-
-In these examples, we will be using this date:
-
-```re prelude
-let exampleDate = Js.Date.fromFloat(123456654321.0);
-```
-
-which is Thu, 29 Nov 1973 21:30:54 GMT. There is no particular significance to this date.
-The code used to access this date is running in the Europe/Austria time zone with the `en_US.utf8` locale.
-
-In all of these functions, month values are in the range 0-11, where January is month zero.
-
-
-## t
-
-```re sig
-type t;
-```
-
-## valueOf
-
-```re sig
-let valueOf: t => float;
-```
-Returns the primitive value of this date, equivalent to `getTime()`. (See [`Date.valueOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/valueOf) on MDN.)
-
-```re example
-Js.Date.valueOf(exampleDate) == 123456654321.0;
-```
-
-## make
-
-```re sig
-let make: unit => t;
-```
-Returns a date representing the current time. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-```re example
-let now = Js.Date.make();
-```
-
-## fromFloat
-
-```re sig
-let fromFloat: float => t;
-```
-
-Returns a date representing the given argument, which is a number of milliseconds since the epoch. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-```re example
-Js.Date.fromFloat(123456654321.0) == exampleDate;
-```
-
-## fromString
-
-```re sig
-let fromString: string => t;
-```
-
-Returns a `Js.Date.t` represented by the given string. The string can be in “IETF-compliant RFC 2822 timestamps, and also strings in a version of ISO8601.” Returns `NaN` if given an invalid date string. According to the [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) documentation on MDN, its use is discouraged.
-
-```re example
-Js.Date.fromString("Thu, 29 Nov 1973 21:30:54.321 GMT") == exampleDate
-Js.Date.fromString("1973-11-29T21:30:54.321Z00:00") == exampleDate
-Js.Date.fromString("Thor, 32 Lok -19 60:70:80 XYZ"); // returns NaN
-```
-
-## makeWithYM
-
-```re sig
-let makeWithYM: (~year: float, ~month: float, unit) => t;
-```
-Returns a date representing midnight of the first day of the given month and year in the current time zone. Fractional parts of arguments are ignored. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-```re example
-let november1 = Js.Date.makeWithYM(~year=2020.0, ~month=10.0, ());
-```
-
-## makeWithYMD
-
-```re sig
-let makeWithYMD: (~year: float, ~month: float, ~date: float, unit) => t;
-```
-Returns a date representing midnight of the given date of the given month and year in the current time zone. Fractional parts of arguments are ignored. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-## makeWithYMDH
-
-```re sig
-let makeWithYMDH: (~year: float, ~month: float, ~date: float, ~hours: float, unit) => t;
-```
-Returns a date representing the given date of the given month and year, at zero minutes and zero seconds past the given `hours`, in the current time zone. Fractional parts of arguments are ignored. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN. Fractional parts of the arguments are ignored.
-
-## makeWithYMDHM
-
-```re sig
-let makeWithYMDHM: (~year: float, ~month: float, ~date: float, ~hours: float, ~minutes: float, unit) => t;
-```
-Returns a date representing the given date of the given month and year, at zero seconds past the given time in hours and minutes in the current time zone.  Fractional parts of arguments are ignored. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-## makeWithYMDHMS
-
-```re sig
-let makeWithYMDHMS: (~year: float, ~month: float, ~date: float, ~hours: float, ~minutes: float, ~seconds: float, unit) => t;
-```
-Returns a date representing the given date of the given month and year, at the given time in hours, minutes, and seconds in the current time zone. Fractional parts of arguments are ignored. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-```re example
-Js.Date.makeWithYMDHMS(~year=1973.0, ~month=11.0, ~date=29.0,
-  ~hours=21.0, ~minutes=30.0, ~seconds=54.321, ()) == exampleDate;
-```
-
-## utcWithYM
-
-```re sig
-let utcWithYM: (~year: float, ~month: float, unit) => float;
-```
-Returns a float representing the number of milliseconds past the epoch for midnight of the first day of the given month and year in UTC. Fractional parts of arguments are ignored. See [`Date.UTC`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC) on MDN.
-
-```re example
-let november1 = Js.Date.utcWithYM(~year=2020.0, ~month=10.0, ());
-```
-
-## utcWithYMD
-
-```re sig
-let utcWithYMD: (~year: float, ~month: float, ~date: float, unit) => float;
-```
-Returns a float representing the number of milliseconds past the epoch for midnight of the given date of the given month and year in UTC. Fractional parts of arguments are ignored. See [`Date.UTC`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC) on MDN.
-
-## utcWithYMDH
-
-```re sig
-let utcWithYMDH: (~year: float, ~month: float, ~date: float, ~hours: float, unit) => float;
-```
-Returns a float representing the number of milliseconds past the epoch for midnight of the given date of the given month and year, at zero minutes and seconds past the given hours in UTC. Fractional parts of arguments are ignored. See [`Date.UTC`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC) on MDN.
-
-## utcWithYMDHM
-
-```re sig
-let utcWithYMDHM: (~year: float, ~month: float, ~date: float, ~hours: float, ~minutes: float, unit) => float;
-```
-Returns a float representing the number of milliseconds past the epoch for midnight of the given date of the given month and year, at zero seconds past the given number of minutes past the given hours in UTC. Fractional parts of arguments are ignored. See [`Date.UTC`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC) on MDN.
-
-## utcWithYMDHMS
-
-```re sig
-let utcWithYMDHMS: (~year: float, ~month: float, ~date: float, ~hours: float, ~minutes: float, ~seconds: float, unit) => float;
-```
-Returns a float representing the number of milliseconds past the epoch for midnight of the given date of the given month and year, at the given time in hours, minutes and seconds in UTC. Fractional parts of arguments are ignored. See [`Date.UTC`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC) on MDN.
-
-## now
-
-```re sig
-let now: unit => float;
-```
-Returns the current time as number of milliseconds since Unix epoch.
-
-## parse
-
-```re sig
-let parse: string => t;
-```
-Deprecated. Use [`fromString()`](#fromstring).
-
-## parseAsFloat
-
-```re sig
-let parseAsFloat: string => float;
-```
-Returns a float with the number of milliseconds past the epoch represented by the given string. The string can be in “IETF-compliant RFC 2822 timestamps, and also strings in a version of ISO8601.” Returns `NaN` if given an invalid date string. According to the [`Date.parse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/parse) documentation on MDN, its use is discouraged. Returns `NaN` if passed invalid date string.
-
-## getDate
-
-```re sig
-let getDate: t => float;
-```
-Returns the day of the month for its argument. The argument is evaluated in the current time zone. See [`Date.getDate`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getDate) on MDN.
-
-```re example
-Js.Date.getDate(exampleDate) == 29.0;
-```
-
-## getDay
-
-```re sig
-let getDay: t => float;
-```
-Returns the day of the week (0.0-6.0) for its argument, where 0.0 represents Sunday. The argument is evaluated in the current time zone.  See [`Date.getDay`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getDay) on MDN.
-
-```re example
-Js.Date.getDay(exampleDate) == 4.0;
-```
-
-## getFullYear
-
-```re sig
-let getFullYear: t => float;
-```
-Returns the full year (as opposed to the range 0-99) for its argument. The argument is evaluated in the current time zone. See [`Date.getFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getFullYear) on MDN.
-
-```re example
-Js.Date.getFullYear(exampleDate) == 1973.0;
-```
-
-## getHours
-
-```re sig
-let getHours: t => float;
-```
-Returns the hours for its argument, evaluated in the current time zone. See [`Date.getHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getHours) on MDN.
-
-```re example
-Js.Date.getHours(exampleDate) == 22.0; // Vienna is in GMT+01:00
-```
-
-## getMilliseconds
-
-```re sig
-let getMilliseconds: t => float;
-```
-Returns the number of milliseconds for its argument, evaluated in the current time zone. See [`Date.getMilliseconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds) on MDN.
-
-```re example
-Js.Date.getMilliseconds(exampleDate) == 321.0;
-```
-
-## getMinutes
-
-```re sig
-let getMinutes: t => float;
-```
-Returns the number of minutes for its argument, evaluated in the current time zone. See [`Date.getMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMinutes) on MDN.
-
-```re example
-Js.Date.getMinutes(exampleDate) == 30.0;
-```
-
-## getMonth
-
-```re sig
-let getMonth: t => float;
-```
-Returns the month (0.0-11.0) for its argument, evaluated in the current time zone. January is month zero.  See [`Date.getMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMonth) on MDN.
-
-```re example
-Js.Date.getMonth(exampleDate) == 10.0;
-```
-
-## getSeconds
-
-```re sig
-let getSeconds: t => float;
-```
-Returns the seconds for its argument, evaluated in the current time zone. See [`Date.getSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getSeconds) on MDN.
-
-```re example
-Js.Date.getSeconds(exampleDate) == 54.0;
-```
-
-## getTime
-
-```re sig
-let getTime: t => float;
-```
-Returns the number of milliseconds since Unix epoch, evaluated in UTC.  See [`Date.getTime`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTime) on MDN.
-
-```re example
-Js.Date.getTime(exampleDate) == 123456654321.0
-```
-
-## getTimezoneOffset
-
-```re sig
-let getTimezoneOffset: t => float;
-```
-
-Returns the time zone offset in minutes from the current time zone to UTC. See [`Date.getTimezoneOffset`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset) on MDN.
-
-```re example
-Js.Date.getTimezoneOffset(exampleDate) == -60.0;
-```
-
-## getUTCDate
-
-```re sig
-let getUTCDate: t => float;
-```
-Returns the day of the month of the argument, evaluated in UTC. See [`Date.getUTCDate`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCDate) on MDN.
-
-```re example
-Js.Date.getUTCDate(exampleDate) == 29.0;
-```
-
-## getUTCDay
-
-```re sig
-let getUTCDay: t => float;
-```
-Returns the day of the week of the argument, evaluated in UTC. The range of the return value is 0.0-6.0, where Sunday is zero. See [`Date.getUTCDay`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCDay) on MDN.
-
-```re example
-Js.Date.getUTCDay(exampleDate) == 4.0;
-```
-
-## getUTCFullYear
-
-```re sig
-let getUTCFullYear: t => float;
-```
-Returns the full year (as opposed to the range 0-99) for its argument. The argument is evaluated in UTC.  See [`Date.getUTCFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear) on MDN.
-
-```re example
-Js.Date.getUTCFullYear(exampleDate) == 1973.0;
-```
-
-## getUTCHours
-
-```re sig
-let getUTCHours: t => float;
-```
-Returns the hours for its argument, evaluated in the current time zone. See [`Date.getUTCHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCHours) on MDN.
-
-```re example
-Js.Date.getUTCHours(exampleDate) == 21.0;
-```
-
-## getUTCMilliseconds
-
-```re sig
-let getUTCMilliseconds: t => float;
-```
-Returns the number of milliseconds for its argument, evaluated in UTC. See [`Date.getUTCMilliseconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds) on MDN.
-
-```re example
-Js.Date.getUTCMilliseconds(exampleDate) == 321.0;
-```
-
-## getUTCMinutes
-
-```re sig
-let getUTCMinutes: t => float;
-```
-Returns the number of minutes for its argument, evaluated in UTC. See [`Date.getUTCMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes) on MDN.
-
-```re example
-Js.Date.getUTCMinutes(exampleDate) == 30.0;
-```
-
-## getUTCMonth
-
-```re sig
-let getUTCMonth: t => float;
-```
-Returns the month (0.0-11.0) for its argument, evaluated in UTC. January is month zero. See [`Date.getUTCMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth) on MDN.
-
-```re example
-Js.Date.getUTCMonth(exampleDate) == 10.0;
-```
-
-## getUTCSeconds
-
-```re sig
-let getUTCSeconds: t => float;
-```
-Returns the seconds for its argument, evaluated in UTC. See [`Date.getUTCSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds) on MDN.
-
-```re example
-Js.Date.getUTCSeconds(exampleDate) == 54.0;
-```
-
-## getYear
-
-```re sig
-let getYear: t => float;
-```
-Deprecated. Use `getFullYear()` instead.
-
-## setDate
-
-```re sig
-let setDate: (t, float) => float;
-```
-Sets the given `Date`’s day of month to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setDate`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setDate) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let twoWeeksBefore = Js.Date.setDate(date1, 15.0);
-date1 == Js.Date.fromString("1973-11-15T21:30:54.321Z00:00");
-twoWeeksBefore == Js.Date.getTime(date1);
-```
-
-## setFullYear
-
-```re sig
-let setFullYear: (t, float) => float;
-```
-Sets the given `Date`’s year to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setFullYear) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let nextYear = Js.Date.setFullYear(date1, 1974.0);
-date1 == Js.Date.fromString("1974-11-15T21:30:54.321Z00:00");
-nextYear == Js.Date.getTime(date1);
-```
-
-## setFullYearM
-
-```re sig
-let setFullYearM: (t, ~year: float, ~month: float, unit) => float;
-```
-
-Sets the given `Date`’s year and month to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setFullYear) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let future = Js.Date.setFullYearM(date1, ~year=1974.0, ~month=0.0, ());
-date1 == Js.Date.fromString("1974-01-22T21:30:54.321Z00:00");
-future == Js.Date.getTime(date1);
-```
-
-## setFullYearMD
-
-```re sig
-let setFullYearMD: (t, ~year: float, ~month: float, ~date: float, unit) => float;
-```
-Sets the given `Date`’s year, month, and day of month to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setFullYear) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let future = Js.Date.setFullYearMD(date1, ~year=1974.0, ~month=0.0, ~date=7.0, ());
-date1 == Js.Date.fromString("1974-01-07T21:30:54.321Z00:00");
-future == Js.Date.getTime(date1);
-```
-
-## setHours
-
-```re sig
-let setHours: (t, float) => float;
-```
-Sets the given `Date`’s hours to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setHours) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let nextHour = Js.Date.setHours(date1, 22.0);
-date1 == Js.Date.fromString("1973-11-29T22:30:54.321Z00:00");
-nextHour == Js.Date.getTime(date1);
-```
-
-## setHoursM
-
-```re sig
-let setHoursM: (t, ~hours: float, ~minutes: float, unit) => float;
-```
-Sets the given `Date`’s hours and minutes to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setHours) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setHoursM(date1, ~hours=22.0, ~minutes=46.0, ());
-date1 == Js.Date.fromString("1973-11-29T22:46:54.321Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setHoursMS
-
-```re sig
-let setHoursMS: (t, ~hours: float, ~minutes: float, ~seconds: float, unit) => float;
-```
-Sets the given `Date`’s hours, minutes, and seconds to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setHours) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setHoursMS(date1, ~hours=22.0, ~minutes=46.0, 
-  ~seconds=37.0, ());
-date1 == Js.Date.fromString("1973-11-29T22:46:37.321Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setHoursMSMs
-
-```re sig
-let setHoursMSMs: (t, ~hours: float, ~minutes: float, ~seconds: float, ~milliseconds: float, unit) => float;
-```
-Sets the given `Date`’s hours, minutes, seconds, and milliseconds to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setHours) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setHoursMSMs(date1, ~hours=22.0, ~minutes=46.0, 
-  ~seconds=37.0, ~milliseconds=494.0, ());
-date1 == Js.Date.fromString("1973-11-29T22:46:37.494Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setMilliseconds
-
-```re sig
-let setMilliseconds: (t, float) => float;
-```
-Sets the given `Date`’s milliseconds to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMilliseconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMilliseconds(date1, 494.0);
-date1 == Js.Date.fromString("1973-11-29T21:30:54.494Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setMinutes
-
-```re sig
-let setMinutes: (t, float) => float;
-```
-Sets the given `Date`’s minutes to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMinutes) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMinutes(date1, 34.0);
-date1 == Js.Date.fromString("1973-11-29T21:34:54.494Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setMinutesS
-
-```re sig
-let setMinutesS: (t, ~minutes: float, ~seconds: float, unit) => float;
-```
-Sets the given `Date`’s minutes and seconds to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMinutes) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMinutesS(date1, ~minutes=34.0, ~seconds=56.0, ());
-date1 == Js.Date.fromString("1973-11-29T21:34:56.494Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setMinutesSMs
-
-```re sig
-let setMinutesSMs: (t, ~minutes: float, ~seconds: float, ~milliseconds: float, unit) => float;
-```
-Sets the given `Date`’s minutes, seconds, and milliseconds to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMinutes) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMinutesSMs(date1, ~minutes=34.0, ~seconds=56.0,
-  ~milliseconds=789.0, ());
-date1 == Js.Date.fromString("1973-11-29T21:34:56.789Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setMonth
-
-```re sig
-let setMonth: (t, float) => float;
-```
-Sets the given `Date`’s month to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMonth) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMonth(date1, 11.0);
-date1 == Js.Date.fromString("1973-12-29T21:34:56.789Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setMonthD
-
-```re sig
-let setMonthD: (t, ~month: float, ~date: float, unit) => float;
-```
-Sets the given `Date`’s month and day of month to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMonth) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMonthD(date1, ~month=11.0, ~date=8.0, ());
-date1 == Js.Date.fromString("1973-12-08T21:34:56.789Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setSeconds
-
-```re sig
-let setSeconds: (t, float) => float;
-```
-Sets the given `Date`’s seconds to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setSeconds) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setSeconds(date1, 56.0);
-date1 == Js.Date.fromString("1973-12-29T21:30:56.321Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setSecondsMs
-
-```re sig
-let setSecondsMs: (t, ~seconds: float, ~milliseconds: float, unit) => float;
-```
-Sets the given `Date`’s seconds and milliseconds to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setSeconds) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setSecondsMs(date1, ~seconds=56.0,
-  ~milliseconds=789.0, ());
-date1 == Js.Date.fromString("1973-12-29T21:30:56.789Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setTime
-
-```re sig
-let setTime: (t, float) => float;
-```
-Sets the given `Date`’s value in terms of milliseconds since the epoch. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setTime`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setTime) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setTime(date1, 198765432101.0);
-
-date1 == Js.Date.fromString("1976-04-19T12:37:12.101Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setUTCDate
-
-```re sig
-let setUTCDate: (t, float) => float;
-```
-Sets the given `Date`’s day of month to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCDate`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCDate) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let twoWeeksBefore = Js.Date.setUTCDate(date1, 15.0);
-date1 == Js.Date.fromString("1973-11-15T21:30:54.321Z00:00");
-twoWeeksBefore == Js.Date.getTime(date1);
-```
-
-## setUTCFullYear
-
-```re sig
-let setUTCFullYear: (t, float) => float;
-```
-Sets the given `Date`’s year to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let nextYear = Js.Date.setUTCFullYear(date1, 1974.0);
-date1 == Js.Date.fromString("1974-11-15T21:30:54.321Z00:00");
-nextYear == Js.Date.getTime(date1);
-```
-
-## setUTCFullYearM
-
-```re sig
-let setUTCFullYearM: (t, ~year: float, ~month: float, unit) => float;
-```
-Sets the given `Date`’s year and month to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let future = Js.Date.setUTCFullYearM(date1, ~year=1974.0, ~month=0.0, ());
-date1 == Js.Date.fromString("1974-01-22T21:30:54.321Z00:00");
-future == Js.Date.getTime(date1);
-```
-
-## setUTCFullYearMD
-
-```re sig
-let setUTCFullYearMD: (t, ~year: float, ~month: float, ~date: float, unit) => float;
-```
-Sets the given `Date`’s year, month, and day of month to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let future = Js.Date.setUTCFullYearMD(date1, ~year=1974.0, ~month=0.0, ~date=7.0, ());
-date1 == Js.Date.fromString("1974-01-07T21:30:54.321Z00:00");
-future == Js.Date.getTime(date1);
-```
-
-## setUTCHours
-
-```re sig
-let setUTCHours: (t, float) => float;
-```
-Sets the given `Date`’s hours to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCHours) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let nextHour = Js.Date.setUTCHours(date1, 22.0);
-date1 == Js.Date.fromString("1973-11-29T22:30:54.321Z00:00");
-nextHour == Js.Date.getTime(date1);
-```
-
-## setUTCHoursM
-
-```re sig
-let setUTCHoursM: (t, ~hours: float, ~minutes: float, unit) => float;
-```
-Sets the given `Date`’s hours and minutes to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCHours) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCHoursM(date1, ~hours=22.0, ~minutes=46.0, ());
-date1 == Js.Date.fromString("1973-11-29T22:46:54.321Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setUTCHoursMS
-
-```re sig
-let setUTCHoursMS: (t, ~hours: float, ~minutes: float, ~seconds: float, unit) => float;
-```
-Sets the given `Date`’s hours, minutes, and seconds to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCHours) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCHoursMS(date1, ~hours=22.0, ~minutes=46.0, 
-  ~seconds=37.0, ());
-date1 == Js.Date.fromString("1973-11-29T22:46:37.321Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setUTCHoursMSMs
-
-```re sig
-let setUTCHoursMSMs: (t, ~hours: float, ~minutes: float, ~seconds: float, ~milliseconds: float, unit) => float;
-```
-Sets the given `Date`’s hours, minutes, seconds, and milliseconds to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCHours) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCHoursMSMs(date1, ~hours=22.0, ~minutes=46.0, 
-  ~seconds=37.0, ~milliseconds=494.0, ());
-date1 == Js.Date.fromString("1973-11-29T22:46:37.494Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setUTCMilliseconds
-
-```re sig
-let setUTCMilliseconds: (t, float) => float;
-```
-Sets the given `Date`’s milliseconds to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMilliseconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMilliseconds(date1, 494.0);
-date1 == Js.Date.fromString("1973-11-29T21:30:54.494Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setUTCMinutes
-
-```re sig
-let setUTCMinutes: (t, float) => float;
-```
-Sets the given `Date`’s minutes to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMinutes(date1, 34.0);
-date1 == Js.Date.fromString("1973-11-29T21:34:54.494Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setUTCMinutesS
-
-```re sig
-let setUTCMinutesS: (t, ~minutes: float, ~seconds: float, unit) => float;
-```
-Sets the given `Date`’s minutes and seconds to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMinutesS(date1, ~minutes=34.0, ~seconds=56.0, ());
-date1 == Js.Date.fromString("1973-11-29T21:34:56.494Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setUTCMinutesSMs
-
-```re sig
-let setUTCMinutesSMs: (t, ~minutes: float, ~seconds: float, ~milliseconds: float, unit) => float;
-```
-Sets the given `Date`’s minutes, seconds, and milliseconds to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMinutesSMs(date1, ~minutes=34.0, ~seconds=56.0,
-  ~milliseconds=789.0, ());
-date1 == Js.Date.fromString("1973-11-29T21:34:56.789Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setUTCMonth
-
-```re sig
-let setUTCMonth: (t, float) => float;
-```
-Sets the given `Date`’s month to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMonth(date1, 11.0);
-date1 == Js.Date.fromString("1973-12-29T21:34:56.789Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setUTCMonthD
-
-```re sig
-let setUTCMonthD: (t, ~month: float, ~date: float, unit) => float;
-```
-Sets the given `Date`’s month and day of month to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMonthD(date1, ~month=11.0, ~date=8.0, ());
-date1 == Js.Date.fromString("1973-12-08T21:34:56.789Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setUTCSeconds
-
-```re sig
-let setUTCSeconds: (t, float) => float;
-```
-Sets the given `Date`’s seconds to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCSeconds(date1, 56.0);
-date1 == Js.Date.fromString("1973-12-29T21:30:56.321Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setUTCSecondsMs
-
-```re sig
-let setUTCSecondsMs: (t, ~seconds: float, ~milliseconds: float, unit) => float;
-```
-Sets the given `Date`’s seconds and milliseconds to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds) on MDN.
-
-```re example
-let date1 = Js.Date.fromFloat(123456654321.0); // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCSecondsMs(date1, ~seconds=56.0,
-  ~milliseconds=789.0, ());
-date1 == Js.Date.fromString("1973-12-29T21:30:56.789Z00:00");
-futureTime == Js.Date.getTime(date1);
-```
-
-## setUTCTime
-
-```re sig
-let setUTCTime: (t, float) => float;
-```
-Same as [`setTime()`](#settime).
-
-## setYear
-
-```re sig
-let setYear: (t, float) => float;
-```
-Deprecated. Use [`setFullYear()`](#setfullyear) instead.
-
-## toDateString
-
-```re sig
-let toDateString: t => string;
-```
-Returns the date (day of week, year, month, and day of month) portion of a `Date` in English. See [`Date.toDateString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toDateString) on MDN.
-
-```re example
-Js.Date.toDateString(exampleDate) == "Thu Nov 29 1973";
-```
-
-## toGMTString
-
-```re sig
-let toGMTString: t => string;
-```
-Deprecated. Use [`toUTCString()`](#toutcstring) instead.
-
-## toISOString
-
-```re sig
-let toISOString: t => string;
-```
-Returns a simplified version of the ISO 8601 format for the date. See [`Date.toISOString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) on MDN.
-
-```re example
-Js.Date.toISOString(exampleDate) == "1973-11-29T21:30:54.321Z";
-```
-
-## toJSON
-
-```re sig
-let toJSON: t => string;
-```
-Deprecated. This method is unsafe. It will be changed to return `option` in a future release. Please use `toJSONUnsafe()` instead.
-
-## toJSONUnsafe
-
-```re sig
-let toJSONUnsafe: t => string;
-```
-Returns a string representation of the given date. See [`Date.toJSON`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toJSON) on MDN.
-
-```re example
-Js.Date.toJSONUnsafe(exampleDate) == "1973-11-29T21:30:54.321Z";
-```
-
-## toLocaleDateString
-
-```re sig
-let toLocaleDateString: t => string;
-```
-
-Returns the year, month, and day for the given `Date` in the current locale format. See [`Date.toLocaleDateString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString) on MDN.
-
-```re example
-Js.Date.toLocaleDateString(exampleDate) == "11/29/1973"; // for en_US.utf8
-Js.Date.toLocaleDateString(exampleDate) == "29.11.73"; // for de_DE.utf8
-```
-
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-Returns the time and date for the given `Date` in the current locale format. See [`Date.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString) on MDN.
-
-```re example
-Js.Date.toLocaleString(exampleDate) == "11/29/1973, 10:30:54 PM"; // for en_US.utf8
-Js.Date.toLocaleString(exampleDate) == "29.11.1973, 22:30:54"; // for de_DE.utf8
-```
-
-## toLocaleTimeString
-
-```re sig
-let toLocaleTimeString: t => string;
-```
-Returns the time of day for the given `Date` in the current locale format. See [`Date.toLocaleTimeString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString) on MDN.
-
-```re example
-Js.Date.toLocaleTimeString(exampleDate) == "10:30:54 PM"; // for en_US.utf8
-Js.Date.toLocaleTimeString(exampleDate) == "22:30:54"; // for de_DE.utf8
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-Returns a string representing the date and time of day for the given `Date` in the current locale and time zone. See [`Date.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toString) on MDN.
-
-```re example
-Js.Date.toString(exampleDate) == "Thu Nov 29 1973 22:30:54 GMT+0100 (Central European Standard Time)";
-```
-
-## toTimeString
-
-```re sig
-let toTimeString: t => string;
-```
-
-Returns a string representing the time of day for the given `Date` in the current locale and time zone.  See [`Date.toTimeString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toTimeString) on MDN.
-
-```re example
-Js.Date.toTimeString(exampleDate) == "22:30:54 GMT+0100 (Central European Standard Time)";
-```
-
-## toUTCString
-
-```re sig
-let toUTCString: t => string;
-```
-
-Returns a string representing the date and time of day for the given `Date` in the current locale and UTC (GMT time zone). See [`Date.toUTCString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toUTCString) on MDN.
-
-```re example
-Js.Date.toUTCString(exampleDate) == "Thu, 29 Nov 1973 21:30:54 GMT";
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/dict.mdx b/pages/docs/manual/v8.0.0/api/js/dict.mdx
deleted file mode 100644
index 5bc29f5f1..000000000
--- a/pages/docs/manual/v8.0.0/api/js/dict.mdx
+++ /dev/null
@@ -1,168 +0,0 @@
-# Dict
-
-<Intro>
-
-Provide utilities for JS dictionary object.
-
-**Note:** This module's examples will assume this predeclared dictionary:
-
-```re prelude
-let ages = Js.Dict.fromList(
-  [("Maria", 30), ("Vinh", 22), ("Fred", 49)]
-);
-```
-
-</Intro>
-
-## t
-
-```re sig
-type t('a);
-```
-
-Dictionary type (ie an '{ }' JS object). However it is restricted to hold a single type; therefore values must have the same type.
-This Dictionary type is mostly used with the Js_json.t type.
-
-## key
-
-```re sig
-type key = string;
-```
-
-The type for dictionary keys. This means that dictionaries *must* use `string`s as their keys.
-
-## get
-
-```re sig
-let get: (t('a), key) => option('a);
-```
-
-`Js.Dict.get(key)` returns `None` if the key is not found in the dictionary, `Some(value)` otherwise.
-
-```re example
-Js.Dict.get(ages, "Vinh") == Some(22);
-Js.Dict.get(ages, "Paul") == None;
-```
-
-## unsafeGet
-
-```re sig
-let unsafeGet: (t('a), key) => 'a;
-```
-`Js.Dict.unsafeGet(key)` returns the value if the key exists, otherwise an `undefined` value is returned. Use this only when you are sure the key exists (i.e. when having used the `keys()` function to check that the key is valid).
-
-```re example
-Js.Dict.unsafeGet(ages, "Fred") == 49;
-Js.Dict.unsafeGet(ages, "Paul"); // returns undefined
-```
-
-## set
-
-```re sig
-let set: (t('a), key, 'a) => unit;
-```
-
-`Js.Dict.set(dict, key, value)` sets the key/value in the dictionary `dict`. If the key does not exist, and entry will be created for it. *This function modifies the original dictionary.*
-
-```re example
-Js.Dict.set(ages, "Maria", 31)
-Js.log(ages ==
-  Js.Dict.fromList([("Maria", 31), ("Vinh", 22), ("Fred", 49)]));
-
-Js.Dict.set(ages, "David", 66)
-Js.log(ages ==
-  Js.Dict.fromList([("Maria", 31), ("Vinh", 22), ("Fred", 49), ("David", 66)]));
-```
-
-## keys
-
-```re sig
-let keys: t('a) => array(string);
-```
-
-Returns all the keys in the dictionary `dict`.
-
-```re example
-Js.Dict.keys(ages) == [|"Maria", "Vinh", "Fred"|];
-```
-
-## empty
-
-```re sig
-let empty: unit => t('a);
-```
-
-Returns an empty dictionary.
-
-## unsafeDeleteKey
-
-```re sig
-let unsafeDeleteKey: (. t(string), string) => unit;
-```
-
-Experimental internal function
-
-## entries
-
-```re sig
-let entries: t('a) => array((key, 'a));
-```
-
-Returns an array of key/value pairs in the given dictionary (ES2017).
-
-```re example
-Js.Dict.entries(ages) == [|("Maria", 30), ("Vinh", 22), ("Fred", 49)|]
-```
-
-## values
-
-```re sig
-let values: t('a) => array('a);
-```
-
-Returns the values in the given dictionary (ES2017).
-
-```re example
-Js.Dict.values(ages) == [|30, 22, 49|]
-```
-
-## fromList
-
-```re sig
-let fromList: list((key, 'a)) => t('a);
-```
-
-Creates a new dictionary containing each (key, value) pair in its list argument.
-
-```re example
-let capitals = Js.Dict.fromList([("Japan", "Tokyo"), ("France", "Paris"), ("Egypt", "Cairo")]);
-```
-
-## fromArray
-
-```re sig
-let fromArray: array((key, 'a)) => t('a);
-```
-
-Creates a new dictionary containing each (key, value) pair in its array argument.
-
-```re example
-let capitals2 = Js.Dict.fromArray([|("Germany", "Berlin"), ("Burkina Faso", "Ouagadougou")|]);
-```
-
-## map
-
-```re sig
-let map: ((. 'a) => 'b, t('a)) => t('b);
-```
-
-`map(f, dict)` maps `dict` to a new dictionary with the same keys, using the function `f` to map each value.
-
-```re example
-let prices = Js.Dict.fromList([("pen", 1.00), ("book", 5.00), ("stapler", 7.00)]);
-
-let discount = (. price) => {price *. 0.90};
-let salePrices = Js.Dict.map(discount, prices);
-
-salePrices == Js.Dict.fromList([("pen", 0.90), ("book", 4.50), ("stapler", 6.30)]);
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/exn.mdx b/pages/docs/manual/v8.0.0/api/js/exn.mdx
deleted file mode 100644
index dbfe8be2d..000000000
--- a/pages/docs/manual/v8.0.0/api/js/exn.mdx
+++ /dev/null
@@ -1,103 +0,0 @@
-# Exn
-
-<Intro>
-
-Provide utilities for dealing with JS exceptions.
-
-</Intro>
-
-## t
-
-```re sig
-  type t;
-```
-
-## exn
-
-```re sig
-  type exn +=
-    pri
-    | Error(t);
-```
-
-## asJsExn
-
-```re sig
-let asJsExn: exn => option(t);
-```
-
-## stack
-
-```re sig
-let stack: t => option(string);
-```
-
-## message
-
-```re sig
-let message: t => option(string);
-```
-
-## name
-
-```re sig
-let name: t => option(string);
-```
-
-## fileName
-
-```re sig
-let fileName: t => option(string);
-```
-
-## isCamlExceptionOrOpenVariant
-
-```re sig
-let isCamlExceptionOrOpenVariant: 'a => bool;
-```
-
-Internal use only.
-
-## raiseError
-
-```re sig
-let raiseError: string => 'a;
-```
-
-Raise Js exception Error object with stacktrace.
-
-## raiseEvalError
-
-```re sig
-let raiseEvalError: string => 'a;
-```
-
-## raiseRangeError
-
-```re sig
-let raiseRangeError: string => 'a;
-```
-
-## raiseReferenceError
-
-```re sig
-let raiseReferenceError: string => 'a;
-```
-
-## raiseSyntaxError
-
-```re sig
-let raiseSyntaxError: string => 'a;
-```
-
-## raiseTypeError
-
-```re sig
-let raiseTypeError: string => 'a;
-```
-
-## raiseUriError
-
-```re sig
-let raiseUriError: string => 'a;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/float.mdx b/pages/docs/manual/v8.0.0/api/js/float.mdx
deleted file mode 100644
index abc3c583d..000000000
--- a/pages/docs/manual/v8.0.0/api/js/float.mdx
+++ /dev/null
@@ -1,281 +0,0 @@
-# Float
-
-<Intro>
-
-Provide utilities for JS float.
-
-</Intro>
-
-## _NaN
-
-```re sig
-let _NaN: float;
-```
-The special value "Not a Number".
-
-## isNaN
-
-```re sig
-let isNaN: float => bool;
-```
-
-Tests if the given value is _NaN.
-Note that both `_NaN == _NaN` and `_NaN === _NaN` will return false. `isNaN` is therefore necessary to test for `_NaN`.
-
-Returns true if the given value is `_NaN`, false otherwise.
-
-## isFinite
-
-```re sig
-let isFinite: float => bool;
-```
-
-Tests if the given value is finite.
-Returns true if the given value is a finite number, false otherwise.
-
-```re example
-/* returns [false] */
-Js.Float.isFinite(infinity);
-```
-
-```re example
-/* returns [false] */
-Js.Float.isFinite(neg_infinity);
-```
-
-```re example
-/* returns [false] */
-Js.Float.isFinite(Js.Float._NaN);
-```
-
-```re example
-/* returns [true] */
-Js.Float.isFinite(1234.);
-```
-
-## toExponential
-
-```re sig
-let toExponential: float => string;
-```
-
-Formats a float using exponential (scientific) notation.
-Returns a string representing the given value in exponential notation.
-Raises `RangeError` if `digits` is not in the range \[0, 20\] (inclusive).
-
-```re example
-/* prints "7.71234e+1" */
-Js.log @@ Js.Float.toExponential(77.1234);
-```
-
-```re example
-/* prints "7.7e+1" */
-Js.log @@ Js.Float.toExponential(77.);
-```
-
-## toExponentialWithPrecision
-
-```re sig
-let toExponentialWithPrecision: (float, ~digits: int) => string;
-```
-
-Formats a `float` using exponential (scientific) notation.
-`digits` specifies how many digits should appear after the decimal point. The value must be in the range \[0, 20\] (inclusive).
-
-Returns a `string` representing the given value in exponential notation.
-
-The output will be rounded or padded with zeroes if necessary.
-Raises `RangeError` if `digits` is not in the range \[0, 20\] (inclusive).
-
-```re example
-/* prints "7.71e+1" */
-Js.log @@ Js.Float.toExponentialWithPrecision(77.1234, ~digits=2);
-```
-
-## toFixed
-
-```re sig
-let toFixed: float => string;
-```
-
-Formats a `float` using fixed point notation.
-Returns a `string` representing the given value in fixed-point notation (usually).
-Raises `RangeError` if `digits` is not in the range \[0, 20\] (inclusive).
-
-```re example
-/* prints "12346" (note the rounding) */
-Js.log @@ Js.Float.toFixed(12345.6789);
-```
-
-```re example
-/* print "1.2e+21" */
-Js.log @@ Js.Float.toFixed(1.2e21);
-```
-
-## toFixedWithPrecision
-
-```re sig
-let toFixedWithPrecision: (float, ~digits: int) => string;
-```
-
-Formats a `float` using fixed point notation.
-`digits` specifies how many digits should appear after the decimal point. The value must be in the range \[0, 20\] (inclusive). Defaults to 0.
-
-Returns a `string` representing the given value in fixed-point notation (usually).
-
-The output will be rounded or padded with zeroes if necessary.
-Raises `RangeError` if `digits` is not in the range \[0, 20\] (inclusive).
-
-```re example
-/* prints "12345.7" (note the rounding) */
-Js.log @@ Js.Float.toFixedWithPrecision(12345.6789, ~digits=1);
-```
-
-```re example
-/* prints "0.00" (note the added zeroes) */
-Js.log @@ Js.Float.toFixedWithPrecision(0., ~digits=2);
-```
-
-## toPrecision
-
-```re sig
-let toPrecision: float => string;
-```
-
-Formats a `float` using some fairly arbitrary rules.
-Returns a `string` representing the given value in fixed-point (usually).
-
-`toPrecision` differs from `toFixed` in that the former will format the number with full precision, while the latter will not output any digits after the decimal point.
-Raises `RangeError` if `digits` is not in the range accepted by this function.
-
-```re example
-/* prints "12345.6789" */
-Js.log @@ Js.Float.toPrecision(12345.6789);
-```
-
-```re example
-/* print "1.2e+21" */
-Js.log @@ Js.Float.toPrecision(1.2e21);
-```
-
-## toPrecisionWithPrecision
-
-```re sig
-let toPrecisionWithPrecision: (float, ~digits: int) => string;
-```
-
-Formats a `float` using some fairly arbitrary rules.
-`digits` specifies how many digits should appear in total. The value must be between 0 and some arbitrary number that's hopefully at least larger than 20 (for Node it's 21. Why? Who knows).
-
-Returns a `string` representing the given value in fixed-point or scientific notation.
-
-The output will be rounded or padded with zeroes if necessary.
-
-`toPrecisionWithPrecision` differs from `toFixedWithPrecision` in that the former will count all digits against the precision, while the latter will count only the digits after the decimal point. 
-`toPrecisionWithPrecision` will also use scientific notation if the specified precision is less than the number for digits before the decimal point.
-Raises `RangeError` if `digits` is not in the range accepted by this function.
-
-```re example
-/* prints "1e+4" */
-Js.log @@ Js.Float.toPrecisionWithPrecision(12345.6789, ~digits=1);
-```
-
-```re example
-/* prints "0.0" */
-Js.log @@ Js.Float.toPrecisionWithPrecision(0., ~digits=2);
-```
-
-## toString
-
-```re sig
-let toString: float => string;
-```
-
-Formats a `float` as a `string`.
-Returns a `string` representing the given value in fixed-point (usually).
-
-```re example
-/* prints "12345.6789" */
-Js.log @@ Js.Float.toString(12345.6789);
-```
-
-## toStringWithRadix
-
-```re sig
-let toStringWithRadix: (float, ~radix: int) => string;
-```
-
-Formats a `float` as a `string`.
-`radix` specifies the radix base to use for the formatted number. The value must be in the range \[2, 36\] (inclusive).
-
-Returns a `string` representing the given value in fixed-point (usually).
-Raises `RangeError` if `radix` is not in the range \[2, 36\] (inclusive).
-
-```re example
-/* prints "110" */
-Js.log @@ Js.Float.toStringWithRadix(6., ~radix=2);
-```
-
-```re example
-/* prints "11.001000111101011100001010001111010111000010100011111" */
-Js.log @@ Js.Float.toStringWithRadix(3.14, ~radix=2);
-```
-
-```re example
-/* prints "deadbeef" */
-Js.log @@ Js.Float.toStringWithRadix(3735928559., ~radix=16);
-```
-
-```re example
-/* prints "3f.gez4w97ry0a18ymf6qadcxr" */
-Js.log @@ Js.Float.toStringWithRadix(123.456, ~radix=36);
-```
-
-## fromString
-
-```re sig
-let fromString: string => float;
-```
-
-Parses the given `string` into a `float` using JavaScript semantics.
-Returns the number as a `float` if successfully parsed, `_NaN` otherwise.
-
-```re example
-/* returns 123 */
-Js.Float.fromString("123");
-```
-
-```re example
-/* returns 12.3 */
-Js.Float.fromString("12.3");
-```
-
-```re example
-/* returns 0 */
-Js.Float.fromString("");
-```
-
-```re example
-/* returns 17 */
-Js.Float.fromString("0x11");
-```
-
-```re example
-/* returns 3 */
-Js.Float.fromString("0b11");
-```
-
-```re example
-/* returns 9 */
-Js.Float.fromString("0o11");
-```
-
-```re example
-/* returns [_NaN] */
-Js.Float.fromString("foo");
-```
-
-```re example
-/* returns [_NaN] */
-Js.Float.fromString("100a");
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/global.mdx b/pages/docs/manual/v8.0.0/api/js/global.mdx
deleted file mode 100644
index 8725970fa..000000000
--- a/pages/docs/manual/v8.0.0/api/js/global.mdx
+++ /dev/null
@@ -1,182 +0,0 @@
-# Global
-
-<Intro>
-
-Provide bindings to JS global functions in global namespace.
-
-</Intro>
-
-```re sig
-type intervalId;
-```
-
-Identify an interval started by `Js.Global.setInterval`.
-
-```re sig
-type timeoutId;
-```
-
-Identify timeout started by `Js.Global.setTimeout`.
-
-## clearInterval
-
-```re sig
-let clearInterval: intervalId => unit;
-```
-
-Clear an interval started by `Js.Global.setInterval`
-
-```re example
-/* API for a somewhat aggressive snoozing alarm clock */
-
-let punchSleepyGuy = () => Js.log("Punch");
-
-let interval = ref(Js.Nullable.null);
-
-let remind = () => {
-  Js.log("Wake Up!");
-  punchSleepyGuy();
-};
-
-let snooze = mins =>
-  interval :=
-    Js.Nullable.return(Js.Global.setInterval(remind, mins * 60 * 1000));
-
-let cancel = () =>
-  Js.Nullable.iter(interval^, (. intervalId) =>
-    Js.Global.clearInterval(intervalId)
-  );
-```
-
-## clearTimeout
-
-```re sig
-let clearTimeout: timeoutId => unit;
-```
-
-Clear a timeout started by `Js.Global.setTimeout`.
-
-```re example
-/* A simple model of a code monkey's brain */
-
-let closeHackerNewsTab = () => Js.log("close");
-
-let timer = ref(Js.Nullable.null);
-
-let work = () => closeHackerNewsTab();
-
-let procrastinate = mins => {
-  Js.Nullable.iter(timer^, (. timer) => Js.Global.clearTimeout(timer));
-  timer := Js.Nullable.return(Js.Global.setTimeout(work, mins * 60 * 1000));
-};
-```
-
-## setInterval
-
-```re sig
-let setInterval: (unit => unit, int) => intervalId;
-```
-
-Repeatedly executes a callback with a specified interval (in milliseconds) between calls.
-Returns a `Js.Global.intervalId` that can be passed to `Js.Global.clearInterval` to cancel the timeout.
-
-```re example
-/* Will count up and print the count to the console every second */
-
-let count = ref(0);
-
-let tick = () => {
-  count := count^ + 1;
-  Js.log(Belt.Int.toString(count^));
-};
-
-Js.Global.setInterval(tick, 1000);
-```
-
-## setIntervalFloat
-
-```re sig
-let setIntervalFloat: (unit => unit, float) => intervalId;
-```
-
-Repeatedly executes a callback with a specified interval (in milliseconds) between calls.
-Returns a `Js.Global.intervalId` that can be passed to `Js.Global.clearInterval` to cancel the timeout.
-
-```re example
-/* Will count up and print the count to the console every second */
-
-let count = ref(0);
-
-let tick = () => {
-  count := count^ + 1;
-  Js.log(Belt.Int.toString(count^));
-};
-
-Js.Global.setIntervalFloat(tick, 1000.0);
-```
-
-## setTimeout
-
-```re sig
-let setTimeout: (unit => unit, int) => timeoutId;
-```
-
-Execute a callback after a specified delay (in milliseconds).
-Returns a `Js.Global.timeoutId` that can be passed to `Js.Global.clearTimeout` to cancel the timeout.
-
-```re example
-/* Prints "Timed out!" in the console after one second */
-
-let message = "Timed out!";
-
-Js.Global.setTimeout(() => Js.log(message), 1000);
-```
-
-## setTimeoutFloat
-
-```re sig
-let setTimeoutFloat: (unit => unit, float) => timeoutId;
-```
-
-Execute a callback after a specified delay (in milliseconds).
-Returns a `Js.Global.timeoutId` that can be passed to `Js.Global.clearTimeout` to cancel the timeout.
-
-```re example
-/* Prints "Timed out!" in the console after one second */
-
-let message = "Timed out!";
-
-Js.Global.setTimeoutFloat(() => Js.log(message), 1000.0);
-```
-
-## encodeURI
-
-```re sig
-let encodeURI: string => string;
-```
-
-URL-encodes a string.
-
-## decodeURI
-
-```re sig
-let decodeURI: string => string;
-```
-
-Decodes a URL-enmcoded string produced by encodeURI.
-
-## encodeURIComponent
-
-```re sig
-let encodeURIComponent: string => string;
-```
-
-URL-encodes a string, including characters with special meaning in a URI.
-
-## decodeURIComponent
-
-```re sig
-let decodeURIComponent: string => string;
-```
-
-Decodes a URL-enmcoded string produced by encodeURIComponent
diff --git a/pages/docs/manual/v8.0.0/api/js/int.mdx b/pages/docs/manual/v8.0.0/api/js/int.mdx
deleted file mode 100644
index f2c7e7465..000000000
--- a/pages/docs/manual/v8.0.0/api/js/int.mdx
+++ /dev/null
@@ -1,146 +0,0 @@
-# Int
-
-<Intro>
-
-Provide utilities for handling `int`.
-
-</Intro>
-
-## toExponential
-
-```re sig
-let toExponential: int => string;
-```
-
-Formats an `int` using exponential (scientific) notation.
-Returns a `string` representing the given value in exponential notation.
-Raises `RangeError` if digits is not in the range \[0, 20\] (inclusive).
-
-```re example
-/* prints "7.7e+1" */
-Js.log(Js.Int.toExponential(77));
-```
-
-## toExponentialWithPrecision
-
-```re sig
-let toExponentialWithPrecision: (int, ~digits: int) => string;
-```
-
-Formats an `int` using exponential (scientific) notation.
-`digits` specifies how many digits should appear after the decimal point. The value must be in the range \[0, 20\] (inclusive).
-
-Returns a `string` representing the given value in exponential notation.
-
-The output will be rounded or padded with zeroes if necessary.
-Raises `RangeError` if `digits` is not in the range \[0, 20\] (inclusive).
-
-```re example
-/* prints "7.70e+1" */
-Js.log(Js.Int.toExponentialWithPrecision(77, ~digits=2));
-
-/* prints "5.68e+3" */
-Js.log(Js.Int.toExponentialWithPrecision(5678, ~digits=2));
-```
-
-## toPrecision
-
-```re sig
-let toPrecision: int => string;
-```
-
-Formats an `int` using some fairly arbitrary rules.
-Returns a `string` representing the given value in fixed-point (usually).
-
-`toPrecision` differs from `toFixed` in that the former will format the number with full precision, while the latter will not output any digits after the decimal point.
-Raises `RangeError` if `digits` is not in the range accepted by this function.
-
-```re example
-/* prints "123456789" */
-Js.log(Js.Int.toPrecision(123456789));
-```
-
-## toPrecisionWithPrecision
-
-```re sig
-let toPrecisionWithPrecision: (int, ~digits: int) => string;
-```
-
-Formats an `int` using some fairly arbitrary rules.
-`digits` specifies how many digits should appear in total. The value must between 0 and some arbitrary number that's hopefully at least larger than 20 (for Node it's 21. Why? Who knows).
-
-Returns a `string` representing the given value in fixed-point or scientific notation.
-
-The output will be rounded or padded with zeroes if necessary.
-
-`toPrecisionWithPrecision` differs from `toFixedWithPrecision` in that the former will count all digits against the precision, while the latter will count only the digits after the decimal point.
-`toPrecisionWithPrecision` will also use scientific notation if the specified precision is less than the number of digits before the decimal point.
-Raises `RangeError` if `digits` is not in the range accepted by this function.
-
-```re example
-/* prints "1.2e+8" */
-Js.log(Js.Int.toPrecisionWithPrecision(123456789, ~digits=2));
-
-/* prints "0.0" */
-Js.log(Js.Int.toPrecisionWithPrecision(0, ~digits=2));
-```
-
-## toString
-
-```re sig
-let toString: int => string;
-```
-
-Formats an `int` as a `string`.
-Returns a `string` representing the given value in fixed-point (usually).
-
-```re example
-/* prints "123456789" */
-Js.log(Js.Int.toString(123456789));
-```
-
-## toStringWithRadix
-
-```re sig
-let toStringWithRadix: (int, ~radix: int) => string;
-```
-
-Formats an `int` as a `string`.
-`radix` specifies the radix base to use for the formatted number. The value must be in the range \[2, 36\] (inclusive).
-Returns a `string` representing the given value in fixed-point (usually).
-Raises `RangeError` if `radix` is not in the range \[2, 36\] (inclusive).
-
-```re example
-/* prints "110" */
-Js.log(Js.Int.toStringWithRadix(6, ~radix=2));
-
-/* prints "deadbeef" */
-Js.log(Js.Int.toStringWithRadix(3735928559, ~radix=16));
-
-/* prints "2n9c" */
-Js.log(Js.Int.toStringWithRadix(123456, ~radix=36));
-```
-
-## toFloat
-
-```re sig
-let toFloat: int => float;
-```
-
-## equal
-
-```re sig
-let equal: (int, int) => bool;
-```
-
-## max
-
-```re sig
-let max: int;
-```
-
-## min
-
-```re sig
-let min: int;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/json.mdx b/pages/docs/manual/v8.0.0/api/js/json.mdx
deleted file mode 100644
index 3403d9129..000000000
--- a/pages/docs/manual/v8.0.0/api/js/json.mdx
+++ /dev/null
@@ -1,318 +0,0 @@
-# Json
-
-<Intro>
-
-Provide utilities for JSON.
-
-</Intro>
-
-## t
-
-```re sig
-type t;
-```
-
-The JSON data structure.
-
-## kind
-
-```re sig
-type kind('a) =
-  | String: kind(Js_string.t)
-  | Number: kind(float)
-  | Object: kind(Js_dict.t(t))
-  | Array: kind(array(t))
-  | Boolean: kind(bool)
-  | Null: kind(Js_types.null_val);
-```
-
-Underlying type of a JSON value.
-
-## tagged_t
-
-```re sig
-type tagged_t =
-  | JSONFalse
-  | JSONTrue
-  | JSONNull
-  | JSONString(string)
-  | JSONNumber(float)
-  | JSONObject(Js_dict.t(t))
-  | JSONArray(array(t));
-```
-
-
-## classify
-
-```re sig
-let classify: t => tagged_t;
-```
-
-## test
-
-```re sig
-let test: ('a, kind('b)) => bool;
-```
-
-`test(v, kind)` returns `true` if `v` is of `kind`.
-
-## decodeString
-
-```re sig
-let decodeString: t => option(Js_string.t);
-```
-
-`decodeString(json)` returns `Some(s)` if `json` is a `string`, `None` otherwise.
-
-## decodeNumber
-
-```re sig
-let decodeNumber: t => option(float);
-```
-
-`decodeNumber(json)` returns `Some(n)` if `json` is a `number`, `None` otherwise.
-
-## decodeObject
-
-```re sig
-let decodeObject: t => option(Js_dict.t(t));
-```
-
-`decodeObject(json)` returns `Some(o)` if `json` is an `object`, `None` otherwise.
-
-## decodeArray
-
-```re sig
-let decodeArray: t => option(array(t));
-```
-
-`decodeArray(json)` returns `Some(a)` if `json` is an `array`, `None` otherwise.
-
-## decodeBoolean
-
-```re sig
-let decodeBoolean: t => option(bool);
-```
-
-`decodeBoolean(json)` returns `Some(b)` if `json` is a `boolean`, `None` otherwise.
-
-## decodeNull
-
-```re sig
-let decodeNull: t => option(Js_null.t('a));
-```
-
-`decodeNull(json)` returns `Some(null)` if `json` is a `null`, `None` otherwise.
-
-## null
-
-```re sig
-let null: t;
-```
-
-`null` is the singleton null JSON value.
-
-## string
-
-```re sig
-let string: string => t;
-```
-
-`string(s)` makes a JSON string of the `string` `s`.
-
-## number
-
-```re sig
-let number: float => t;
-```
-
-`number(n)` makes a JSON number of the `float` `n`.
-
-## boolean
-
-```re sig
-let boolean: bool => t;
-```
-
-`boolean(b)` makes a JSON boolean of the `bool` `b`.
-
-## object_
-
-```re sig
-let object_: Js_dict.t(t) => t;
-```
-
-`object_(dict)` makes a JSON object of the `Js.Dict.t` `dict`.
-
-## array
-
-```re sig
-let array: array(t) => t;
-```
-
-`array_(a)` makes a JSON array of the `Js.Json.t` array `a`.
-
-## stringArray
-
-```re sig
-let stringArray: array(string) => t;
-```
-
-`stringArray(a)` makes a JSON array of the `string` array `a`.
-
-## numberArray
-
-```re sig
-let numberArray: array(float) => t;
-```
-
-`numberArray(a)` makes a JSON array of the `float` array `a`.
-
-## booleanArray
-
-```re sig
-let booleanArray: array(bool) => t;
-```
-
-`booleanArray(a)` makes a JSON array of the `bool` array `a`.
-
-## objectArray
-
-```re sig
-let objectArray: array(Js_dict.t(t)) => t;
-```
-
-`objectArray(a) makes a JSON array of the `JsDict.t` array `a`.
-
-## parseExn
-
-```re sig
-let parseExn: string => t;
-```
-
-`parseExn(s)` parses the `string` `s` into a JSON data structure.
-Returns a JSON data structure.
-Raises `SyntaxError` if the given string is not a valid JSON. Note: `SyntaxError` is a JavaScript exception.
-
-```re example
-/* parse a simple JSON string */
-
-let json =
-  try (Js.Json.parseExn({| "foo" |})) {
-  | _ => failwith("Error parsing JSON string")
-  };
-
-switch (Js.Json.classify(json)) {
-| Js.Json.JSONString(value) => Js.log(value)
-| _ => failwith("Expected a string")
-};
-```
-
-```re example
-/* parse a complex JSON string */
-
-let getIds = s => {
-  let json =
-    try (Js.Json.parseExn(s)) {
-    | _ => failwith("Error parsing JSON string")
-    };
-
-  switch (Js.Json.classify(json)) {
-  | Js.Json.JSONObject(value) =>
-    /* In this branch, compiler infer value : Js.Json.t Js.Dict.t */
-    switch (Js.Dict.get(value, "ids")) {
-    | Some(ids) =>
-      switch (Js.Json.classify(ids)) {
-      | Js.Json.JSONArray(ids) =>
-        /* In this branch compiler infer ids : Js.Json.t array */
-        ids
-      | _ => failwith("Expected an array")
-      }
-    | None => failwith("Expected an `ids` property")
-    }
-  | _ => failwith("Expected an object")
-  };
-};
-
-/* prints `1, 2, 3` */
-Js.log(getIds({| { "ids" : [1, 2, 3 ] } |}));
-```
-
-## stringify
-
-```re sig
-let stringify: t => string;
-```
-
-`stringify(json)` formats the JSON data structure as a `string`.
-Returns the string representation of a given JSON data structure.
-
-```re example
-/* Creates and stringifies a simple JS object */
-
-{
-  let dict = Js.Dict.empty();
-  Js.Dict.set(dict, "name", Js.Json.string("John Doe"));
-  Js.Dict.set(dict, "age", Js.Json.number(30.0));
-  Js.Dict.set(
-    dict,
-    "likes",
-    Js.Json.stringArray([|"bucklescript", "ocaml", "js"|]),
-  );
-
-  Js.log(Js.Json.stringify(Js.Json.object_(dict)));
-};
-```
-
-## stringifyWithSpace
-
-```re sig
-let stringifyWithSpace: (t, int) => string;
-```
-
-`stringify(json)` formats the JSON data structure as a `string`.
-Returns the string representation of a given JSON data structure with spacing.
-
-```re example
-/* Creates and stringifies a simple JS object with spacing */
-
-{
-  let dict = Js.Dict.empty();
-  Js.Dict.set(dict, "name", Js.Json.string("John Doe"));
-  Js.Dict.set(dict, "age", Js.Json.number(30.0));
-  Js.Dict.set(
-    dict,
-    "likes",
-    Js.Json.stringArray([|"bucklescript", "ocaml", "js"|]),
-  );
-
-  Js.log(Js.Json.stringifyWithSpace(Js.Json.object_(dict), 2));
-};
-```
-
-## stringifyAny
-
-```re sig
-let stringifyAny: 'a => option(string);
-```
-
-`stringifyAny(value)` formats any value into a JSON string.
-
-```re example
-/* prints `["foo", "bar"]` */
-Js.log(Js.Json.stringifyAny([|"foo", "bar"|]));
-```
-
-
-
-
-
-
-
-
-
-
-  
-
-  
- 
diff --git a/pages/docs/manual/v8.0.0/api/js/list.mdx b/pages/docs/manual/v8.0.0/api/js/list.mdx
deleted file mode 100644
index 44ad1fd9a..000000000
--- a/pages/docs/manual/v8.0.0/api/js/list.mdx
+++ /dev/null
@@ -1,143 +0,0 @@
-# List
-
-<Intro>
-
-Provide utilities for list.
-
-</Intro>
-
-## t
-
-```re sig
-type t('a) = list('a);
-```
-
-## length
-
-```re sig
-let length: t('a) => int;
-```
-
-## cons
-
-```re sig
-let cons: ('a, t('a)) => t('a);
-```
-
-## isEmpty
-
-```re sig
-let isEmpty: t('a) => bool;
-```
-
-## hd
-
-```re sig
-let hd: t('a) => option('a);
-```
-
-## tl
-
-```re sig
-let tl: t('a) => option(t('a));
-```
-
-## nth
-
-```re sig
-let nth: (t('a), int) => option('a);
-```
-
-## revAppend
-
-```re sig
-let revAppend: (t('a), t('a)) => t('a);
-```
-
-## rev
-
-```re sig
-let rev: t('a) => t('a);
-```
-
-## mapRev
-
-```re sig
-let mapRev: ((. 'a) => 'b, t('a)) => t('b);
-```
-
-## map
-
-```re sig
-let map: ((. 'a) => 'b, t('a)) => t('b);
-```
-
-## iter
-
-```re sig
-let iter: ((. 'a) => unit, t('a)) => unit;
-```
-
-## iteri
-
-```re sig
-let iteri: ((. int, 'a) => unit, t('a)) => unit;
-```
-
-## foldLeft
-
-```re sig
-let foldLeft: ((. 'a, 'b) => 'a, 'a, list('b)) => 'a;
-```
-
-Application order is left to right, tail-recurisve.
-
-## foldRight
-
-```re sig
-let foldRight: ((. 'a, 'b) => 'b, list('a), 'b) => 'b;
-```
-
-Application order is right to left, tail-recursive.
-
-## flatten
-
-```re sig
-let flatten: t(t('a)) => t('a);
-```
-
-## filter
-
-```re sig
-let filter: ((. 'a) => bool, t('a)) => t('a);
-```
-
-## filterMap
-
-```re sig
-let filterMap: ((. 'a) => option('b), t('a)) => t('b);
-```
-
-## countBy
-
-```re sig
-let countBy: ((. 'a) => bool, list('a)) => int;
-```
-
-## init
-
-```re sig
-let init: (int, (. int) => 'a) => t('a);
-```
-
-## toVector
-
-```re sig
-let toVector: t('a) => Js_vector.t('a);
-```
-
-## equal
-
-```re sig
-let equal: ((. 'a, 'a) => bool, list('a), list('a)) => bool;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/math.mdx b/pages/docs/manual/v8.0.0/api/js/math.mdx
deleted file mode 100644
index 19d05c8e5..000000000
--- a/pages/docs/manual/v8.0.0/api/js/math.mdx
+++ /dev/null
@@ -1,628 +0,0 @@
-# Math
-
-<Intro>
-
-Provide utilities for JS Math. Note: The constants `_E`, `_LN10`, `_LN2`, `_LOG10E`, `_LOG2E`, `_PI`, `_SQRT1_2`, and `_SQRT2` begin with an underscore because ReasonML variable names cannot begin with a capital letter. (Module names begin with upper case.)
-
-</Intro>
-
-## _E
-
-```re sig
-let _E: float;
-```
-
-Euler's number; ≈ 2.718281828459045. See [`Math.E`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/E) on MDN.
-
-## _LN2
-
-```re sig
-let _LN2: float;
-```
-
-Natural logarithm of 2; ≈ 0.6931471805599453. See [`Math.LN2`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/LN2) on MDN.
-
-## _LN10
-
-```re sig
-let _LN10: float;
-```
-
-Natural logarithm of 10; ≈ 2.302585092994046. See [`Math.LN10`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/LN10) on MDN.
-
-## _LOG2E
-
-```re sig
-let _LOG2E: float;
-```
-
-Base 2 logarithm of E; ≈ 1.4426950408889634. See [`Math.LOG2E`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/LOG2E) on MDN.
-
-## _LOG10E
-
-```re sig
-let _LOG10E: float;
-```
-
-Base 10 logarithm of E; ≈ 0.4342944819032518. See [`Math.LOG10E`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/LOG10E) on MDN.
-
-## _PI
-
-```re sig
-let _PI: float;
-```
-
-Pi - ratio of the circumference to the diameter of a circle; ≈ 3.141592653589793. See [`Math.PI`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/PI) on MDN.
-
-## _SQRT1_2
-
-```re sig
-let _SQRT1_2: float;
-```
-
-Square root of 1/2; ≈ 0.7071067811865476. See [`Math.SQRT1_2`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2) on MDN.
-
-## _SQRT2
-
-```re sig
-let _SQRT2: float;
-```
-
-Square root of 2; ≈ 1.4142135623730951. See [`Math.SQRT2`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/SQRT2) on MDN.
-
-## abs_int
-
-```re sig
-let abs_int: int => int;
-```
-
-Absolute value for integer argument. See [`Math.abs`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/abs) on MDN.
-
-## abs_float
-
-```re sig
-let abs_float: float => float;
-```
-
-Absolute value for float argument. See [`Math.abs`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/abs) on MDN.
-
-## acos
-
-```re sig
-let acos: float => float;
-```
-
-Arccosine (in radians) of argument; returns `NaN` if the argument is outside the range [-1.0, 1.0]. See [`Math.acos`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acos) on MDN.
-
-## acosh
-
-```re sig
-let acosh: float => float;
-```
-
-Hyperbolic arccosine (in radians) of argument; returns `NaN` if the argument is less than 1.0. See [`Math.acosh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acosh) on MDN.
-
-## asin
-
-```re sig
-let asin: float => float;
-```
-
-Arcsine (in radians) of argument; returns `NaN` if the argument is outside the range [-1.0, 1.0]. See [`Math.asin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asin) on MDN.
-
-## asinh
-
-```re sig
-let asinh: float => float;
-```
-
-Hyperbolic arcsine (in radians) of argument. See [`Math.asinh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asinh) on MDN.
-
-## atan
-
-```re sig
-let atan: float => float;
-```
-
-Arctangent (in radians) of argument. See [`Math.atan`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan) on MDN.
-
-## atanh
-
-```re sig
-let atanh: float => float;
-```
-
-Hyperbolic arctangent (in radians) of argument; returns `NaN` if the argument is is outside the range [-1.0, 1.0]. Returns `-Infinity` and `Infinity` for arguments -1.0 and 1.0. See [`Math.atanh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atanh) on MDN.
-
-## atan2
-
-```re sig
-let atan2: (~y: float, ~x: float, unit) => float;
-```
-
-Returns the angle (in radians) of the quotient `y /. x`. It is also the angle between the *x*-axis and point (*x*, *y*). See [`Math.atan2`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2) on MDN.
-
-```re example
-Js.Math.atan2(~y=0.0, ~x=10.0, ()) == 0.0 ;
-Js.Math.atan2(~x=5.0, ~y=5.0, ()) == Js.Math._PI /. 4.0;
-Js.Math.atan2(~x=-5.0, ~y=5.0, ());
-Js.Math.atan2(~x=-5.0, ~y=5.0, ()) == 3.0 *. Js.Math._PI /. 4.0;
-Js.Math.atan2(~x=-0.0, ~y=-5.0, ()) == -. Js.Math._PI /. 2.0;
-```
-
-## cbrt
-
-```re sig
-let cbrt: float => float;
-```
-
-Cube root. See [`Math.cbrt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cbrt) on MDN
-
-## unsafe_ceil_int
-
-```re sig
-let unsafe_ceil_int: float => int;
-```
-
-Returns the smallest integer greater than or equal to the argument. This function may return values not representable by `int`, whose range is -2147483648 to 2147483647. This is because, in JavaScript, there are only 64-bit floating point numbers, which can represent integers in the range ±(2<sup>53</sup>-1) exactly. See [`Math.ceil`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil) on MDN.
-
-```re example
-Js.Math.unsafe_ceil_int(3.1) == 4;
-Js.Math.unsafe_ceil_int(3.0) == 3;
-Js.Math.unsafe_ceil_int(-3.1) == -3;
-Js.Math.unsafe_ceil_int(1.0e15); // result is outside range of int datatype
-```
-
-## unsafe_ceil
-
-```re sig
-let unsafe_ceil: float => int;
-```
-Deprecated; please use [`unsafe_ceil_int`](#unsafe_ceil_int) instead.
-
-## ceil_int
-
-```re sig
-let ceil_int: float => int;
-```
-
-Returns the smallest `int` greater than or equal to the argument; the result is pinned to the range of the `int` data type: -2147483648 to 2147483647. See [`Math.ceil`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil) on MDN.
-
-```re example
-Js.Math.ceil_int(3.1) == 4;
-Js.Math.ceil_int(3.0) == 3;
-Js.Math.ceil_int(-3.1) == -3;
-Js.Math.ceil_int(-1.0e15) == -2147483648;
-Js.Math.ceil_int(1.0e15) == 2147483647;
-```
-
-## ceil
-
-```re sig
-let ceil: float => int;
-```
-
-Deprecated; please use [`ceil_int`](#ceil_int) instead.
-
-## ceil_float
-
-```re sig
-let ceil_float: float => float;
-```
-
-Returns the smallest integral value greater than or equal to the argument. The result is a `float` and is not restricted to the `int` data type range. See [`Math.ceil`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil) on MDN.
-
-```re example
-Js.Math.ceil_float(3.1) == 4.0;
-Js.Math.ceil_float(3.0) == 3.0;
-Js.Math.ceil_float(-3.1) == -3.0;
-Js.Math.ceil_float(2_150_000_000.3) == 2_150_000_001.0;
-```
-
-## clz32
-
-```re sig
-let clz32: int => int;
-```
-
-Number of leading zero bits of the argument's 32 bit int representation. See [`Math.clz32`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32) on MDN.
-
-```re example
-Js.Math.clz32(0) == 32;
-Js.Math.clz32(-1) == 0;
-Js.Math.clz32(255) == 24;
-```
-
-## cos
-
-```re sig
-let cos: float => float;
-```
-
-Cosine of argument, which must be specified in radians. See [`Math.cos`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cos) on MDN.
-
-## cosh
-
-```re sig
-let cosh: float => float;
-```
-
-Hyperbolic cosine of argument, which must be specified in radians. See [`Math.cosh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cosh) on MDN.
-
-## exp
-
-```re sig
-let exp: float => float;
-```
-
-Natural exponentional; returns *e* (the base of natural logarithms) to the power of the given argument. See [`Math.exp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/exp) on MDN.
-
-## expm1
-
-```re sig
-let expm1: float => float;
-```
-
-Returns *e* (the base of natural logarithms) to the power of the given argument minus 1. See [`Math.expm1`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/expm1) on MDN.
-
-## unsafe_floor_int
-
-```re sig
-let unsafe_floor_int: float => int;
-```
-
-Returns the largest integer less than or equal to the argument. This function may return values not representable by `int`, whose range is -2147483648 to 2147483647. This is because, in JavaScript, there are only 64-bit floating point numbers, which can represent integers in the range ±(2<sup>53</sup>-1) exactly. See [`Math.floor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor) on MDN.
-
-```re example
-Js.Math.unsafe_floor_int(3.7) == 3;
-Js.Math.unsafe_floor_int(3.0) == 3;
-Js.Math.unsafe_floor_int(-3.7) == -4;
-Js.Math.unsafe_floor_int(1.0e15); // result is outside range of int datatype
-```
-
-## unsafe_floor
-
-```re sig
-let unsafe_floor: float => int;
-```
-
-Deprecated; please use [`unsafe_floor_int`](#unsafe_floor_int) instead.
-
-## floor_int
-
-```re sig
-let floor_int: float => int;
-```
-
-Returns the largest `int` less than or equal to the argument; the result is pinned to the range of the `int` data type: -2147483648 to 2147483647. See [`Math.floor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor) on MDN.
-
-```re example
-Js.Math.floor_int(3.7) == 3;
-Js.Math.floor_int(3.0) == 3;
-Js.Math.floor_int(-3.1) == -4;
-Js.Math.floor_int(-1.0e15) == -2147483648;
-Js.Math.floor_int(1.0e15) == 2147483647;
-```
-
-## floor
-
-```re sig
-let floor: float => int;
-```
-
-Deprecated; please use [`floor_int`](#floor_int) instead.
-
-## floor_float
-
-```re sig
-let floor_float: float => float;
-```
-
-Returns the largest integral value less than or equal to the argument. The result is a `float` and is not restricted to the `int` data type range. See [`Math.floor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor) on MDN.
-
-```re example
-Js.Math.floor_float(3.7) == 3.0;
-Js.Math.floor_float(3.0) == 3.0;
-Js.Math.floor_float(-3.1) == -4.0;
-Js.Math.floor_float(2_150_000_000.3) == 2_150_000_000.0;
-```
-## fround
-
-```re sig
-let fround: float => float;
-```
-
-Round to nearest single precision float. See [`Math.fround`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround) on MDN.
-
-```re example
-Js.Math.fround(5.5) == 5.5;
-Js.Math.fround(5.05) == 5.050000190734863;
-```
-
-## hypot
-
-```re sig
-let hypot: (float, float) => float;
-```
-
-Returns the square root of the sum of squares of its two arguments (the Pythagorean formula). See [`Math.hypot`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/hypot) on MDN.
-
-## hypotMany
-
-```re sig
-let hypotMany: array(float) => float;
-```
-
-Returns the square root of the sum of squares of the numbers in the array argument (generalized Pythagorean equation). Using an array allows you to have more than two items. See [`Math.hypot`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/hypot) on MDN.
-
-```re example
-Js.Math.hypotMany([|3.0, 4.0, 12.0|]) == 13.0;
-```
-
-## imul
-
-```re sig
-let imul: (int, int) => int;
-```
-
-32-bit integer multiplication. Use this only when you need to optimize performance of multiplication of numbers stored as 32-bit integers. See [`Math.imul`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul) on MDN.
-
-## log
-
-```re sig
-let log: float => float;
-```
-
-Returns the natural logarithm of its argument; this is the number *x* such that *e*<sup>*x*</sup> equals the argument. Returns `NaN` for negative arguments. See [`Math.log`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log) on MDN.
-
-```re example
-Js.Math.log(Js.Math._E) == 1.0;
-Js.Math.log(100.0) == 4.605170185988092;
-```
-
-## log1p
-
-```re sig
-let log1p: float => float;
-```
-
-Returns the natural logarithm of one plus the argument. Returns `NaN` for arguments less than -1. See [`Math.log1p`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log1p) on MDN.
-
-```re example
-Js.Math.log1p(Js.Math._E -. 1.0) == 1.0;
-Js.Math.log1p(99.0) == 4.605170185988092;
-```
-
-## log10
-
-```re sig
-let log10: float => float;
-```
-
-Returns the base 10 logarithm of its argument. Returns `NaN` for negative arguments. See [`Math.log10`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log10) on MDN.
-
-```re example
-Js.Math.log10(1000.0) == 3.0;
-Js.Math.log10(0.01) == -2.0;
-Js.Math.log10(Js.Math.sqrt(10.0)) == 0.5;
-```
-
-## log2
-
-```re sig
-let log2: float => float;
-```
-
-Returns the base 2 logarithm of its argument. Returns `NaN` for negative arguments. See [`Math.log2`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log2) on MDN.
-
-```re example
-Js.Math.log2(512.0) == 9.0;
-Js.Math.log2(0.125) == -3.0;
-Js.Math.log2(Js.Math._SQRT2) == 0.5000000000000001; // due to precision
-```
-
-
-## max_int
-
-```re sig
-let max_int: (int, int) => int;
-```
-
-Returns the maximum of its two integer arguments.  See [`Math.max`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max) on MDN.
-
-## maxMany_int
-
-```re sig
-let maxMany_int: array(int) => int;
-```
-
-Returns the maximum of the integers in the given array.  See [`Math.max`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max) on MDN.
-
-## max_float
-
-```re sig
-let max_float: (float, float) => float;
-```
-
-Returns the maximum of its two floating point arguments. See [`Math.max`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max) on MDN.
-
-## maxMany_float
-
-```re sig
-let maxMany_float: array(float) => float;
-```
-
-Returns the maximum of the floating point values in the given array. See [`Math.max`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max) on MDN.
-
-## min_int
-
-```re sig
-let min_int: (int, int) => int;
-```
-
-Returns the minimum of its two integer arguments. See [`Math.min`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min) on MDN.
-
-
-## minMany_int
-
-```re sig
-let minMany_int: array(int) => int;
-```
-
-Returns the minimum of the integers in the given array. See [`Math.min`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min) on MDN.
-
-## min_float
-
-```re sig
-let min_float: (float, float) => float;
-```
-
-Returns the minimum of its two floating point arguments. See [`Math.min`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min) on MDN.
-
-## minMany_float
-
-```re sig
-let minMany_float: array(float) => float;
-```
-
-Returns the minimum of the floating point values in the given array. See [`Math.min`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min) on MDN.
-
-
-## pow_int
-
-```re sig
-let pow_int: (~base: int, ~exp: int) => int;
-```
-
-Raises the given base to the given exponent. (Arguments and result are integers.) See [`Math.pow`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/pow) on MDN.
-
-```re example
-Js.Math.pow_int(~base=3, ~exp=4) == 81; 
-```
-
-
-## pow_float
-
-```re sig
-let pow_float: (~base: float, ~exp: float) => float;
-```
-
-Raises the given base to the given exponent. (Arguments and result are floats.) Returns `NaN` if the result would be imaginary. See [`Math.pow`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/pow) on MDN.
-
-```re example
-Js.Math.pow_float(~base=3.0, ~exp=4.0) == 81.0;
-Js.Math.pow_float(~base=4.0, ~exp=-2.0) == 0.0625;
-Js.Math.pow_float(~base=625.0, ~exp=0.5) == 25.0;
-Js.Math.pow_float(~base=625.0, ~exp=-0.5) == 0.04;
-Js.Float.isNaN(Js.Math.pow_float(~base=-2.0, ~exp=0.5)) == true;
-```
-
-## random
-
-```re sig
-let random: unit => float;
-```
-
-Returns a random number in the half-closed interval [0,1). See [`Math.random`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random) on MDN.
-
-## random_int
-
-```re sig
-let random_int: (int, int) => int;
-```
-
-A call to `random_int(minVal, maxVal)` returns a random number in the half-closed interval [minVal, maxVal). See [`Math.random`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random) on MDN.
-
-## unsafe_round
-
-```re sig
-let unsafe_round: float => int;
-```
-
-Rounds its argument to nearest integer. For numbers with a fractional portion of exactly 0.5, the argument is rounded to the next integer in the direction of positive infinity.  This function may return values not representable by `int`, whose range is -2147483648 to 2147483647. This is because, in JavaScript, there are only 64-bit floating point numbers, which can represent integers in the range ±(2<sup>53</sup>-1) exactly. See [`Math.round`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round) on MDN.
-
-```re example
-Js.Math.unsafe_round(3.7) == 4;
-Js.Math.unsafe_round(-3.5) == -3;
-Js.Math.unsafe_round(2_150_000_000_000.3); // out of range for int
-```
-
-## round
-
-```re sig
-let round: float => float;
-```
-
-Rounds to nearest integral value (expressed as a float). See [`Math.round`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round) on MDN.
-
-
-## sign_int
-
-```re sig
-let sign_int: int => int;
-```
-
-Returns the sign of its integer argument: -1 if negative, 0 if zero, 1 if positive. See [`Math.sign`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign) on MDN.
-
-## sign_float
-
-```re sig
-let sign_float: float => float;
-```
-Returns the sign of its float argument: -1.0 if negative, 0.0 if zero, 1.0 if positive. See [`Math.sign`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign) on MDN.
-
-## sin
-
-```re sig
-let sin: float => float;
-```
-
-Sine of argument, which must be specified in radians. See [`Math.sin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sin) on MDN.
-
-## sinh
-
-```re sig
-let sinh: float => float;
-```
-
-Hyperbolic sine of argument, which must be specified in radians. See [`Math.sinh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sinh) on MDN.
-
-## sqrt
-
-```re sig
-let sqrt: float => float;
-```
-
-Square root. If the argument is negative, this function returns `NaN`. See [`Math.sqrt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sqrt) on MDN.
-
-## tan
-
-```re sig
-let tan: float => float;
-```
-
-Tangent of argument, which must be specified in radians. Returns `NaN` if the argument is positive infinity or negative infinity. See [`Math.cos`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cos) on MDN.
-
-## tanh
-
-```re sig
-let tanh: float => float;
-```
-
-Hyperbolic tangent of argument, which must be specified in radians. See [`Math.tanh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/tanh) on MDN.
-
-## unsafe_trunc
-
-```re sig
-let unsafe_trunc: float => int;
-```
-
-Truncates its argument; i.e., removes fractional digits. This function may return values not representable by `int`, whose range is -2147483648 to 2147483647. This is because, in JavaScript, there are only 64-bit floating point numbers, which can represent integers in the range ±(2<sup>53</sup>-1) exactly. See [`Math.trunc`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc) on MDN.
-
-## trunc
-
-```re sig
-let trunc: float => float;
-```
-
-Truncates its argument; i.e., removes fractional digits. See [`Math.trunc`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc) on MDN.
diff --git a/pages/docs/manual/v8.0.0/api/js/null-undefined.mdx b/pages/docs/manual/v8.0.0/api/js/null-undefined.mdx
deleted file mode 100644
index d06eede59..000000000
--- a/pages/docs/manual/v8.0.0/api/js/null-undefined.mdx
+++ /dev/null
@@ -1,114 +0,0 @@
-# Null_undefined
-
-<Intro>
-
-Provide utilities around `Js.null_undefined`.
-
-</Intro>
-
-## t
-
-```re sig
-type t('a) = Js.null_undefined('a);
-```
-
-Local alias for `Js.null_undefined('a)`.
-
-## return
-
-```re sig
-let return: 'a => t('a);
-```
-
-Constructs a value of `Js.null_undefined('a)` containing a value of `'a`.
-
-## test
-
-```re sig
-let test: t('a) => bool;
-```
-
-## isNullable
-
-```re sig
-let isNullable: t('a) => bool;
-```
-
-Returns `true` if the given value is null or undefined, `false` otherwise.
-
-## null
-
-```re sig
-let null: t('a);
-```
-
-The null value of type `Js.null_undefined('a)`.
-
-## undefined
-
-```re sig
-let undefined: t('a);
-```
-
-The undefined value of type `Js.null_undefined('a)`.
-
-## bind
-
-```re sig
-let bind: (t('a), (. 'a) => 'b) => t('b);
-```
-
-Maps the contained value using the given function.
-If `Js.null_undefined('a)` contains a value, that value is unwrapped, mapped to a `'b` using the given function `a' => 'b`, then wrapped back up and returned as `Js.null_undefined('b)`.
-
-```re example
-let maybeGreetWorld = (maybeGreeting: Js.null_undefined(string)) =>
-  Js.Null_undefined.bind(maybeGreeting, [@bs] greeting => greeting ++ " world!");
-```
-
-## iter
-
-```re sig
-let iter: (t('a), (. 'a) => unit) => unit;
-```
-
-Iterates over the contained value with the given function.
-If `Js.null_undefined('a)` contains a value, that value is unwrapped and applied to the given function.
-
-```re example
-let maybeSay = (maybeMessage: Js.null_undefined(string)) =>
-  Js.Null_undefined.iter(maybeMessage, [@bs] message => Js.log(message));
-```
-
-## fromOption
-
-```re sig
-let fromOption: option('a) => t('a);
-```
-
-Maps `option('a)` to `Js.null_undefined('a)`.
-`Some(a)` => `a`
-`None` => `undefined`
-
-## from_opt
-
-```re sig
-let from_opt: option('a) => t('a);
-```
-
-## toOption
-
-```re sig
-let toOption: t('a) => option('a);
-```
-
-Maps `Js.null_undefined('a)` to `option('a)`.
-`a` => `Some(a)`
-`undefined` => `None`
-`null` => `None`
-
-## to_opt
-
-```re sig
-let to_opt: t('a) => option('a);
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/null.mdx b/pages/docs/manual/v8.0.0/api/js/null.mdx
deleted file mode 100644
index 6ac03a635..000000000
--- a/pages/docs/manual/v8.0.0/api/js/null.mdx
+++ /dev/null
@@ -1,107 +0,0 @@
-# Null
-
-<Intro>
-
-Provide utilities around `null('a)`.
-
-</Intro>
-
-```re sig
-type t('a) = Js.null('a);
-```
-
-Local alias for `Js.null('a)`.
-
-```re sig
-let return: 'a => t('a);
-```
-
-Constructs a value of `Js.null('a)` containing a value of `'a`.
-
-## test
-
-```re sig
-let test: t('a) => bool;
-```
-
-Returns `true` if the given value is empty (`null`), `false` otherwise.
-
-## empty
-
-```re sig
-let empty: t('a);
-```
-
-The empty value, `null`.
-
-## getUnsafe
-
-```re sig
-let getUnsafe: t('a) => 'a;
-```
-
-## getExn
-
-```re sig
-let getExn: t('a) => 'a;
-```
-
-## bind
-
-```re sig
-let bind: (t('a), (. 'a) => 'b) => t('b);
-```
-
-Maps the contained value using the given function.
-If `Js.null('a)` contains a value, that value is unwrapped, mapped to a `'b` using the given function `'a => 'b`, then wrapped back up and returned as `Js.null('b)`.
-
-```re example
-let maybeGreetWorld = (maybeGreeting: Js.null(string)) =>
-  Js.Null.bind(maybeGreeting, [@bs] greeting => greeting ++ " world!");
-```
-
-## iter
-
-```re sig
-let iter: (t('a), (. 'a) => unit) => unit;
-```
-
-Iterates over the contained value with the given function.
-If `Js.null('a)` contains a value, that value is unwrapped and applied to the given function.
-
-```re example
-let maybeSay = (maybeMessage: Js.null(string)) =>
-  Js.Null.iter(maybeMessage, [@bs] message => Js.log(message));
-```
-
-## fromOption
-
-```re sig
-let fromOption: option('a) => t('a);
-```
-
-Maps `option('a)` to `Js.null('a)`.
-`Some(a)` => `a`
-`None` => `empty`
-
-## from_opt
-
-```re sig
-let from_opt: option('a) => t('a);
-```
-
-## toOption
-
-```re sig
-let toOption: t('a) => option('a);
-```
-
-Maps `Js.null('a)` to `option('a)`.
-`a` => `Some(a)`
-`empty` => `None`
-
-## to_opt
-
-```re sig
-let to_opt: t('a) => option('a);
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/nullable.mdx b/pages/docs/manual/v8.0.0/api/js/nullable.mdx
deleted file mode 100644
index b03f23134..000000000
--- a/pages/docs/manual/v8.0.0/api/js/nullable.mdx
+++ /dev/null
@@ -1,114 +0,0 @@
-# Nullable
-
-<Intro>
-
-Provide utilities around `Js.null_undefined`.
-
-</Intro>
-
-## t
-
-```re sig
-type t('a) = Js.null_undefined('a);
-```
-
-Local alias for `Js.null_undefined('a)`.
-
-## return
-
-```re sig
-let return: 'a => t('a);
-```
-
-Constructs a value of `Js.null_undefined('a)` containing a value of `'a`.
-
-## test
-
-```re sig
-let test: t('a) => bool;
-```
-
-## isNullable
-
-```re sig
-let isNullable: t('a) => bool;
-```
-
-Returns `true` if the given value is null or undefined, `false` otherwise.
-
-## null
-
-```re sig
-let null: t('a);
-```
-
-The null value of type `Js.null_undefined('a)`.
-
-## undefined
-
-```re sig
-let undefined: t('a);
-```
-
-The undefined value of type `Js.null_undefined('a)`.
-
-## bind
-
-```re sig
-let bind: (t('a), (. 'a) => 'b) => t('b);
-```
-
-Maps the contained value using the given function.
-If `Js.null_undefined('a)` contains a value, that value is unwrapped, mapped to a `'b` using the given function `a' => 'b`, then wrapped back up and returned as `Js.null_undefined('b)`.
-
-```re example
-let maybeGreetWorld = (maybeGreeting: Js.null_undefined(string)) =>
-  Js.Nullable.bind(maybeGreeting, [@bs] greeting => greeting ++ " world!");
-```
-
-## iter
-
-```re sig
-let iter: (t('a), (. 'a) => unit) => unit;
-```
-
-Iterates over the contained value with the given function.
-If `Js.null_undefined('a)` contains a value, that value is unwrapped and applied to the given function.
-
-```re example
-let maybeSay = (maybeMessage: Js.null_undefined(string)) =>
-  Js.Nullable.iter(maybeMessage, [@bs] message => Js.log(message));
-```
-
-## fromOption
-
-```re sig
-let fromOption: option('a) => t('a);
-```
-
-Maps `option('a)` to `Js.null_undefined('a)`.
-`Some(a)` => `a`
-`None` => `undefined`
-
-## from_opt
-
-```re sig
-let from_opt: option('a) => t('a);
-```
-
-## toOption
-
-```re sig
-let toOption: t('a) => option('a);
-```
-
-Maps `Js.null_undefined('a)` to `option('a)`.
-`a` => `Some(a)`
-`undefined` => `None`
-`null` => `None`
-
-## to_opt
-
-```re sig
-let to_opt: t('a) => option('a);
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/obj.mdx b/pages/docs/manual/v8.0.0/api/js/obj.mdx
deleted file mode 100644
index 00b50115b..000000000
--- a/pages/docs/manual/v8.0.0/api/js/obj.mdx
+++ /dev/null
@@ -1,57 +0,0 @@
-# Obj
-
-<Intro>
-
-Provide utilities for Js.t.
-
-</Intro>
-
-## empty
-
-```re sig
-let empty: unit => Js.t({..});
-```
-
-`empty()` returns the empty object `{}`.
-
-## assign
-
-```re sig
-let assign: (Js.t({..}), Js.t({..})) => Js.t({..});
-```
-
-`assign(target, source)` copies properties from source to target.
-Properties in `target` will be overwritten by properties in `source` if they have the same key.
-Returns `target`.
-
-```re example
-/* Copy an object */
-
-let obj = [%obj {a: 1}];
-
-let copy = Js.Obj.assign(Js.Obj.empty(), obj);
-
-/* prints "{ a: 1 }" */
-Js.log(copy);
-
-/* Merge objects with same properties */
-
-let target = [%obj {a: 1, b: 1}];
-let source = [%obj {b: 2}];
-
-let obj = Js.Obj.assign(target, source);
-
-/* prints "{ a: 1, b: 2 }" */
-Js.log(obj);
-
-/* prints "{ a: 1, b: 2 }", target is modified */
-Js.log(target);
-```
-
-## keys
-
-```re sig
-let keys: Js.t('a) => array(string);
-```
-
-`keys(obj)` returns an `array` of the keys of `obj`'s own enumerable properties.
diff --git a/pages/docs/manual/v8.0.0/api/js/option.mdx b/pages/docs/manual/v8.0.0/api/js/option.mdx
deleted file mode 100644
index f1522d0b3..000000000
--- a/pages/docs/manual/v8.0.0/api/js/option.mdx
+++ /dev/null
@@ -1,170 +0,0 @@
-# Option
-
-<Intro>
-
-Provide utilities for handling `option`.
-
-</Intro>
-
-## t
-
-```re sig
-type t('a) = option('a);
-```
-
-## some
-
-```re sig
-let some: 'a => option('a);
-```
-Wraps the given value in `Some()`
-
-```re example
-Js.Option.some(1066) == Some(1066);
-```
-
-## isSome
-
-```re sig
-let isSome: option('a) => bool;
-```
-
-Returns `true` if the argument is `Some(value)`; `false` if the argument is `None`.
-
-## isSomeValue
-
-```re sig
-let isSomeValue: ((. 'a, 'a) => bool, 'a, option('a)) => bool;
-```
-
-The first argument to `isSomeValue` is an uncurried function `eq()` that takes two arguments and returns `true` if they are considered to be equal. It is used to compare a plain value `v1`(the second argument) with an `option` value. If the `option` value is `None`, `isSomeValue()` returns `false`; if the third argument is `Some(v2)`, `isSomeValue()` returns the result of calling `eq(v1, v2)`.
-
-```re example
-let clockEqual = (. a, b) => (a mod 12 == b mod 12);
-Js.Option.isSomeValue(clockEqual, 3, Some(15)) == true;
-Js.Option.isSomeValue(clockEqual, 3, Some(4)) == false;
-Js.Option.isSomeValue(clockEqual, 3, None) == false;
-```
-
-## isNone
-
-```re sig
-let isNone: option('a) => bool;
-```
-
-Returns `true` if the argument is `None`; `false` otherwise.
-
-## getExn
-
-```re sig
-let getExn: option('a) => 'a;
-```
-
-If the argument to `getExn()` is of the form `Some(value)`, returns `value`. If given `None`, it throws a `getExn` exception.
-
-## equal
-
-```re sig
-let equal: ((. 'a, 'b) => bool, option('a), option('b)) => bool;
-```
-
-The first argument to `equal` is an uncurried function `eq()` that takes two arguments and returns `true` if they are considered to be equal. The second and third arguments are `option` values. 
-
-If the second and third arguments are of the form:
-
-* `Some(v1)` and `Some(v2)`: returns `eq(v1, v2)`
-* `Some(v1)` and `None`: returns `false`
-* `None` and `Some(v2)`: returns `false`
-* `None` and `None`: returns `true`
-
-```re example
-let clockEqual = (. a, b) => (a mod 12 == b mod 12);
-Js.Option.equal(clockEqual, Some(3), Some(15)) == true;
-Js.Option.equal(clockEqual, Some(3), Some(16)) == false;
-Js.Option.equal(clockEqual, Some(3), None) == false;
-Js.Option.equal(clockEqual, None, Some(15)) == false;
-Js.Option.equal(clockEqual, None, None) == true;
-```
-
-## andThen
-
-```re sig
-let andThen: ((. 'a) => option('b), option('a)) => option('b);
-```
-
-The first argument to `andThen()` is an uncurried function `f()` that takes a plain value and returns an `option` result. The second argument is an `option` value. If the second argument is `None`, the return value is `None`. If the second argument is `Some(v)`, the return value is `f(v)`.
-
-```re example
-let reciprocal = (. x) => (x == 0) ? None : Some(1.0 /. (float_of_int(x)));
-Js.Option.andThen(reciprocal, Some(5)) == Some(0.2);
-Js.Option.andThen(reciprocal, Some(0)) == None;
-Js.Option.andThen(reciprocal, None) == None;
-```
-
-## map
-
-```re sig
-let map: ((. 'a) => 'b, option('a)) => option('b);
-```
-
-The first argument to `map()` is an uncurried function `f()` that takes a plain value and returns a plain result. The second argument is an `option` value. If it is of the form `Some(v)`, `map()` returns `Some(f(v))`; if it is `None`, the return value is `None`, and function `f()` is not called.
-
-```re example
-let square = (. x) => (x * x);
-Js.Option.map(square, Some(3)) == Some(9);
-Js.Option.map(square, None) == None;
-```
-
-## getWithDefault
-
-```re sig
-let getWithDefault: ('a, option('a)) => 'a;
-```
-
-The first argument to `getWithDefault()` is a default value. If the second argument is of the form `Some(v)`, `getWithDefault()` returns `v`; if the second argument is `None`, the return value is the default value.
-
-```re example
-Js.Option.getWithDefault(1066, Some(15)) == 15;
-Js.Option.getWithDefault(1066, None) == 1066;
-```
-
-## default
-
-```re sig
-let default: ('a, option('a)) => 'a;
-```
-
-**See:** [getWithDefault](#getWithDefault)
-
-## filter
-
-```re sig
-let filter: ((. 'a) => bool, option('a)) => option('a);
-```
-
-The first argument to `filter()` is an uncurried function that takes a plain value and returns a boolean. The second argument is an `option` value. 
-
-If the second argument is of the form `Some(v)` and `f(v)` is `true`, 
-the return value is `Some(v)`. Otherwise, the return value is `None`.
-
-```re example
-let isEven = (. x) => {x mod 2 == 0};
-Js.Option.filter(isEven, Some(2)) == Some(2);
-Js.Option.filter(isEven, Some(3)) == None;
-Js.Option.filter(isEven, None) == None;
-```
-
-## firstSome
-
-```re sig
-let firstSome: (option('a), option('a)) => option('a);
-```
-
-The `firstSome()` function takes two `option` values; if the first is of the form `Some(v1)`, that is the return value. Otherwise, `firstSome()` returns the second value.
-
-```re example
-Js.Option.firstSome(Some("one"), Some("two")) == Some("one");
-Js.Option.firstSome(Some("one"), None) == Some("one");
-Js.Option.firstSome(None, Some("two")) == Some("two");
-Js.Option.firstSome(None, None) == None;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/promise.mdx b/pages/docs/manual/v8.0.0/api/js/promise.mdx
deleted file mode 100644
index e2a555a7e..000000000
--- a/pages/docs/manual/v8.0.0/api/js/promise.mdx
+++ /dev/null
@@ -1,91 +0,0 @@
-# Promise
-
-<Intro>
-
-Provide bindings to JS promise.
-
-</Intro>
-
-## t
-
-```re sig
-type t(+'a);
-```
-
-## error
-
-```re sig
-type error;
-```
-
-## make
-
-```re sig
-let make: ((~resolve: (. 'a) => unit, ~reject: (. exn) => unit) => unit) => t('a);
-```
-
-## resolve
-
-```re sig
-let resolve: 'a => t('a);
-```
-
-## reject
-
-```re sig
-let reject: exn => t('a);
-```
-
-## all
-
-```re sig
-let all: array(t('a)) => t(array('a));
-```
-
-## all2
-
-```re sig
-let all2: ((t('a0), t('a1))) => t(('a0, 'a1));
-```
-
-## all3
-
-```re sig
-let all3: ((t('a0), t('a1), t('a2))) => t(('a0, 'a1, 'a2));
-```
-
-## all4
-
-```re sig
-let all4: ((t('a0), t('a1), t('a2), t('a3))) => t(('a0, 'a1, 'a2, 'a3));
-```
-
-## all5
-
-```re sig
-let all5: ((t('a0), t('a1), t('a2), t('a3), t('a4))) => t(('a0, 'a1, 'a2, 'a3, 'a4));
-```
-
-## all6
-
-```re sig
-let all6: ((t('a0), t('a1), t('a2), t('a3), t('a4), t('a5))) => t(('a0, 'a1, 'a2, 'a3, 'a4, 'a5));
-```
-
-## race
-
-```re sig
-let race: array(t('a)) => t('a);
-```
-
-## then_
-
-```re sig
-let then_: ('a => t('b), t('a)) => t('b);
-```
-
-## catch
-
-```re sig
-let catch: (error => t('a), t('a)) => t('a);
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/re.mdx b/pages/docs/manual/v8.0.0/api/js/re.mdx
deleted file mode 100644
index 9e2862254..000000000
--- a/pages/docs/manual/v8.0.0/api/js/re.mdx
+++ /dev/null
@@ -1,243 +0,0 @@
-# Re
-
-<Intro>
-
-Provide bindings to JS regular expressions (RegExp).
-
-</Intro>
-
-## t
-
-```re sig
-type t
-```
-
-The RegExp object.
-
-## result
-
-```re sig
-type result
-```
-
-The result of a executing a RegExp on a string.
-
-## captures
-
-```re sig
-let captures: result => array(Js.nullable(string));
-```
-
-An `array` of the match and captures, the first is the full match and the remaining are the substring captures.
-
-## matches
-
-```re sig
-let matches: result => array(string);
-```
-
-Deprecated. Use captures instead.
-An `array` of the matches, the first is the full match and the remaining are the substring matches.
-
-## index
-
-```re sig
-let index: result => int;
-```
-
-0-based index of the match in the input string.
-
-## input
-
-```re sig
-let input: result => string;
-```
-
-The original input string.
-
-## fromString
-
-```re sig
-let fromString: string => t;
-```
-
-Constructs a RegExp object (Js.Re.t) from a `string`.
-Regex literals ([%re "/.../"]) should generally be preferred, but fromString is very useful when you need to insert a string into a regex.
-
-```re example
-/* A function that extracts the content of the first element with the given tag */
-
-let contentOf = (tag, xmlString) =>
-  Js.Re.fromString("<" ++ tag ++ ">(.*?)<\\/" ++ tag ++ ">")
-  -> Js.Re.exec_(xmlString)
-  -> (
-    fun
-    | Some(result) => Js.Nullable.toOption(Js.Re.captures(result)[1])
-    | None => None
-  );
-```
-
-## fromStringWithFlags
-
-```re sig
-let fromStringWithFlags: (string, ~flags: string) => t;
-```
-
-Constructs a RegExp object (`Js.Re.t`) from a string with the given flags.
-See `Js.Re.fromString`.
-
-Valid flags:
-
-g global
-i ignore case
-m multiline
-u unicode (es2015)
-y sticky (es2015)
-
-## flags
-
-```re sig
-let flags: t => string;
-```
-
-Returns the enabled flags as a string.
-
-## global
-
-```re sig
-let global: t => bool;
-```
-
-Returns a `bool` indicating whether the global flag is set.
-
-## ignoreCase
-
-```re sig
-let ignoreCase: t => bool;
-```
-
-Returns a `bool` indicating whether the ignoreCase flag is set.
-
-## lastIndex
-
-```re sig
-let lastIndex: t => int;
-```
-
-Returns the index where the next match will start its search.
-This property will be modified when the RegExp object is used, if the global ("g") flag is set.
-
-```re example
-let re = [%re "/ab*/g"];
-let str = "abbcdefabh";
-
-let break = ref(false);
-while (! break^) {
-  switch (Js.Re.exec_(re, str)) {
-  | Some(result) =>
-    Js.Nullable.iter(
-      Js.Re.captures(result)[0],
-      [@bs] match => {
-        let next = Belt.Int.toString(Js.Re.lastIndex(re));
-        Js.log("Found " ++ match ++ ". Next match starts at " ++ next);
-      },
-    )
-  | None => break := true
-  };
-};
-```
-
-## setLastIndex
-
-```re sig
-let setLastIndex: (t, int) => unit;
-```
-
-Sets the index at which the next match will start its search from.
-
-## multiline
-
-```re sig
-let multiline: t => bool;
-```
-
-Returns a `bool` indicating whether the multiline flag is set.
-
-## source
-
-```re sig
-let source: t => string;
-```
-
-Returns the pattern as a `string`.
-
-## sticky
-
-```re sig
-let sticky: t => bool;
-```
-
-Returns a `bool` indicating whether the sticky flag is set.
-
-## unicode
-
-```re sig
-let unicode: t => bool;
-```
-
-Returns a `bool` indicating whether the unicode flag is set.
-
-## exec\_
-
-```re sig
-let exec_: (t, string) => option(result);
-```
-
-Executes a search on a given string using the given RegExp object.
-Returns `Some(Js.Re.result)` if a match is found, `None` otherwise.
-
-```re example
-/* Match "quick brown" followed by "jumps", ignoring characters in between
- * Remember "brown" and "jumps"
- * Ignore case
- */
-
-let re = [%re "/quick\s(brown).+?(jumps)/ig"];
-let result = (Js.Re.exec_(re, "The Quick Brown Fox Jumps Over The Lazy Dog"));
-```
-
-## exec
-
-```re sig
-let exec: (string, t) => option(result);
-```
-
-Deprecated. please use `Js.Re.exec_` instead.
-
-## test\_
-
-```re sig
-let test_: (t, string) => bool;
-```
-
-Tests whether the given RegExp object will match a given `string`.
-Returns true if a match is found, false otherwise.
-
-```re example
-/* A simple implementation of Js.String.startsWith */
-
-let str = "hello world!";
-
-let startsWith = (target, substring) =>
-  Js.Re.fromString("^" ++ substring)->(Js.Re.test_(target));
-
-Js.log(str->(startsWith("hello"))); /* prints "true" */
-```
-
-## test
-
-```re sig
-let test: (string, t) => bool;
-```
-
-Deprecated. please use `Js.Re.test_` instead.
diff --git a/pages/docs/manual/v8.0.0/api/js/result.mdx b/pages/docs/manual/v8.0.0/api/js/result.mdx
deleted file mode 100644
index 0b7d1054f..000000000
--- a/pages/docs/manual/v8.0.0/api/js/result.mdx
+++ /dev/null
@@ -1,15 +0,0 @@
-# Result
-
-<Intro>
-
-Define the interface for result.
-
-</Intro>
-
-## t
-
-```re sig
-type t('good, 'bad) =
-  | Ok('good)
-  | Error('bad);
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/string-2.mdx b/pages/docs/manual/v8.0.0/api/js/string-2.mdx
deleted file mode 100644
index c5ecd9eb4..000000000
--- a/pages/docs/manual/v8.0.0/api/js/string-2.mdx
+++ /dev/null
@@ -1,774 +0,0 @@
-# String2
-
-<Intro>
-
-Provide bindings to JS string. Optimized for pipe-first.
-
-</Intro>
-
-## t
-
-```re sig
-type t = string;
-```
-
-## make
-
-```re sig
-let make: 'a => t;
-```
-
-`make(value)` converts the given value to a `string`.
-
-```re example
-Js.String2.make(3.5) == "3.5";
-Js.String2.make([|1,2,3|]) == "1,2,3";
-```
-
-## fromCharCode
-
-```re sig
-let fromCharCode: int => t;
-```
-
-`fromCharCode(n)` creates a `string` containing the character corresponding to that number; `n` ranges from 0 to 65535.
-If out of range, the lower 16 bits of the value are used. Thus, `fromCharCode(0x1F63A)` gives the same result as `fromCharCode(0xF63A)`. See [`String.fromCharCode`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode) on MDN.
-
-```re sig
-Js.String2.fromCharCode(65) == "A";
-Js.String2.fromCharCode(0x3c8) == {js|ψ|js};
-Js.String2.fromCharCode(0xd55c) == {js|한|js};
-Js.String2.fromCharCode(-64568) == {js|ψ|js};
-```
-
-## fromCharCodeMany
-
-```re sig
-let fromCharCodeMany: array(int) => t;
-```
-
-`fromCharCodeMany([|n1;n2;n3|])` creates a `string` from the characters corresponding to the given numbers, using the same rules as `fromCharCode`. See [`String.fromCharCode`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode) on MDN.
-
-## fromCodePoint
-
-```re sig
-let fromCodePoint: int => t;
-```
-
-`fromCodePoint(n)` creates a `string` containing the character corresponding to that numeric code point. 
-If the number is not a valid code point, it raises `RangeError`. 
-Thus, `fromCodePoint(0x1F63A)` will produce a correct value, unlike `fromCharCode(0x1F63A)`, and `fromCodePoint(-5)` will raise a `RangeError`. See [`String.fromCodePoint`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint) on MDN.
- 
-```re example
-Js.String2.fromCodePoint(65) == "A";
-Js.String2.fromCodePoint(0x3c8) == {js|ψ|js};
-Js.String2.fromCodePoint(0xd55c) == {js|한|js};
-Js.String2.fromCodePoint(0x1f63a) == {js|😺|js};
-```
-
-## fromCodePointMany
-
-```re sig
-let fromCodePointMany: array(int) => t;
-```
-
-`fromCodePointMany([|n1;n2;n3|])` creates a `string` from the characters corresponding to the given code point numbers, using the same rules as `fromCodePoint`. See [`String.fromCodePoint`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint) on MDN.
-
-```re example
-Js.String2.fromCodePointMany([|0xd55c, 0xae00, 0x1f63a|]) == {js|한글😺|js};
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-`length(s)` returns the length of the given `string`. See [`String.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length) on MDN.
-
-```re example
-Js.String2.length("abcd") == 4;
-```
-
-## get
-
-```re sig
-let get: (t, int) => t;
-```
-
-`get(s, n)` returns as a `string` the character at the given index number. 
-If `n` is out of range, this function returns `undefined`,so at some point this function may be modified to return `option(string)`.
-
-```re example
-Js.String2.get("Reason", 0) == "R";
-Js.String2.get("Reason", 4) == "o";
-Js.String2.get({js|Rẽasöń|js}, 5) == {js|ń|js};
-```
-
-## charAt
-
-```re sig
-let charAt: (t, int) => t;
-```
-
-`charAt(s, n)` gets the character at index `n` within string `s`. 
-If `n` is negative or greater than the length of `s`, it returns the empty string.
-If the string contains characters outside the range \u0000-\uffff, it will return the first 16-bit value at that position in the string. See [`String.charAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charAt) on MDN.
-
-```re example
-Js.String2.charAt("Reason", 0) == "R";
-Js.String2.charAt("Reason", 12) == "";
-Js.String2.charAt({js|Rẽasöń|js}, 5) == {js|ń|js};
-```
-
-## charCodeAt
-
-```re sig
-let charCodeAt: (t, int) => float;
-```
-
-`charCodeAt(s, n)` returns the character code at position `n` in string `s`; the result is in the range 0-65535, unlke `codePointAt`, so it will not work correctly for characters with code points greater than or equal to 0x10000. 
-The return type is `float` because this function returns NaN if `n` is less than zero or greater than the length of the string. See [`String.charCodeAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charCodeAt) on MDN.
-
-```re example
-Js.String2.charCodeAt({js|😺|js}, 0) == 0xd83d->float_of_int;
-Js.String2.codePointAt({js|😺|js}, 0) == Some(0x1f63a);
-```
-
-## codePointAt
-
-```re sig
-let codePointAt: (t, int) => option(int);
-```
-
-`codePointAt(s, n)` returns the code point at position `n` within string `s` as a `Some(value)`. 
-The return value handles code points greater than or equal to 0x10000.
-If there is no code point at the given position, the function returns `None`. See [`String.codePointAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/codePointAt) on MDN.
-
-```re example
-Js.String2.codePointAt({js|¿😺?|js}, 1) == Some(0x1f63a);
-Js.String2.codePointAt("abc", 5) == None;
-```
-
-## concat
-
-```re sig
-let concat: (t, t) => t;
-```
-
-`concat(original, append)` returns a new `string` with `append` added after `original`. See [`String.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat) on MDN.
-
-```re example
-Js.String2.concat("cow", "bell") == "cowbell";
-```
-
-## concatMany
-
-```re sig
-let concatMany: (t, array(t)) => t;
-```
-
-`concat(original, arr)` returns a new `string` consisting of each item of an array of strings added to the `original` string. See [`String.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat) on MDN.
-
-```re example
-Js.String2.concatMany("1st", [|"2nd", "3rd", "4th"|]) == "1st2nd3rd4th";
-```
-
-## endsWith
-
-```re sig
-let endsWith: (t, t) => bool;
-```
-
-ES2015: `endsWith(str, substr)` returns `true` if the `str` ends with `substr`, `false` otherwise. See [`String.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith) on MDN.
-
-```re example
-Js.String2.endsWith("BuckleScript", "Script") == true;
-Js.String2.endsWith("BuckleShoes", "Script") == false;
-```
-
-## endsWithFrom
-
-```re sig
-let endsWithFrom: (t, t, int) => bool;
-```
-
-`endsWithFrom(str, ending, len)` returns `true` if the first len characters of `str` end with `ending`, `false` otherwise.
-If `len` is greater than or equal to the length of `str`, then it works like `endsWith`. (Honestly, this should have been named endsWithAt, but oh well.) See [`String.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith) on MDN.
-
-```re example
-Js.String2.endsWithFrom("abcd", "cd", 4) == true;
-Js.String2.endsWithFrom("abcde", "cd", 3) == false;
-Js.String2.endsWithFrom("abcde", "cde", 99) == true;
-Js.String2.endsWithFrom("example.dat", "ple", 7) == true;
-```
-
-## includes
-
-```re sig
-let includes: (t, t) => bool;
-```
-
-ES2015: `includes(str, searchValue)` returns `true` if `searchValue` is found anywhere within `str`, false otherwise. See [`String.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes) on MDN.
-
-```re example
-Js.String2.includes("programmer", "gram") == true;
-Js.String2.includes("programmer", "er") == true;
-Js.String2.includes("programmer", "pro") == true;
-Js.String2.includes("programmer.dat", "xyz") == false;
-```
-
-## includesFrom
-
-```re sig
-let includesFrom: (t, t, int) => bool;
-```
-
-ES2015: `includes(str, searchValue start)` returns `true` if `searchValue` is found anywhere within `str` starting at character number `start` (where 0 is the first character), `false` otherwise. See [`String.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes) on MDN.
-
-```re example
-Js.String2.includesFrom("programmer", "gram", 1) == true;
-Js.String2.includesFrom("programmer", "gram", 4) == false;
-Js.String2.includesFrom({js|대한민국|js}, {js|한|js}, 1) == true;
-```
-
-## indexOf
-
-```re sig
-let indexOf: (t, t) => int;
-```
-
-ES2015: `indexOf(str, searchValue)` returns the position at which `searchValue` was first found within `str`, or -1 if `searchValue` is not in `str`. See [`String.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf) on MDN.
-
-```re example
-Js.String2.indexOf("bookseller", "ok") == 2;
-Js.String2.indexOf("bookseller", "sell") == 4;
-Js.String2.indexOf("beekeeper", "ee") == 1;
-Js.String2.indexOf("bookseller", "xyz") == -1;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (t, t, int) => int;
-```
-`indexOfFrom(str, searchValue, start)` returns the position at which `searchValue` was found within `str` starting at character position `start`, or -1 if `searchValue` is not found in that portion of `str`.
-The return value is relative to the beginning of the string, no matter where the search started from. See [`String.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf) on MDN.
-
-```re example
-Js.String2.indexOfFrom("bookseller", "ok", 1) == 2;
-Js.String2.indexOfFrom("bookseller", "sell", 2) == 4;
-Js.String2.indexOfFrom("bookseller", "sell", 5) == -1;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (t, t) => int;
-```
-
-`lastIndexOf(str, searchValue)` returns the position of the last occurrence of `searchValue` within `str`, searching backwards from the end of the string.
-Returns -1 if `searchValue` is not in `str`. The return value is always relative to the beginning of the string. See [`String.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf) on MDN.
-
-```re example
-Js.String2.lastIndexOf("bookseller", "ok") == 2;
-Js.String2.lastIndexOf("beekeeper", "ee") == 4;
-Js.String2.lastIndexOf("abcdefg", "xyz") == -1;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (t, t, int) => int;
-```
-
-`lastIndexOfFrom(str, searchValue, start)` returns the position of the last occurrence of `searchValue` within `str`, searching backwards from the given start position.
-Returns -1 if `searchValue` is not in `str`. The return value is always relative to the beginning of the string. See [`String.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf) on MDN.
-
-```re example
-Js.String2.lastIndexOfFrom("bookseller", "ok", 6) == 2;
-Js.String2.lastIndexOfFrom("beekeeper", "ee", 8) == 4;
-Js.String2.lastIndexOfFrom("beekeeper", "ee", 3) == 1;
-Js.String2.lastIndexOfFrom("abcdefg", "xyz", 4) == -1;
-```
-
-## localeCompare
-
-```re sig
-let localeCompare: (t, t) => float;
-```
-
-`localeCompare(reference, comparison)` returns
-- a negative value if reference comes before comparison in sort order
-- zero if reference and comparison have the same sort order
-- a positive value if reference comes after comparison in sort order
-
-See [`String.localeCompare`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare) on MDN.
-
-```re example
-Js.String2.localeCompare("zebra", "ant") > 0.0;
-Js.String2.localeCompare("ant", "zebra") < 0.0;
-Js.String2.localeCompare("cat", "cat") == 0.0;
-Js.String2.localeCompare("CAT", "cat") > 0.0;
-```
-
-## match
-
-```re sig
-let match: (t, Js_re.t) => option(array(t));
-```
-
-`match(str, regexp)` matches a `string` against the given `regexp`. If there is no match, it returns `None`. For regular expressions without the g modifier, if there is a match, the return value is `Some(array)` where the array contains:
-- The entire matched string
-- Any capture groups if the regexp had parentheses
-For regular expressions with the g modifier, a matched expression returns `Some(array)` with all the matched substrings and no capture groups. See [`String.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match) on MDN.
-
-```re example
-Js.String2.match("The better bats", [%re "/b[aeiou]t/"]) == Some([|"bet"|]);
-Js.String2.match("The better bats", [%re "/b[aeiou]t/g"]) == Some([|"bet", "bat"|]);
-Js.String2.match("Today is 2018-04-05.", [%re "/(\\d+)-(\\d+)-(\\d+)/"]) == Some([|"2018-04-05", "2018", "04", "05"|]);
-Js.String2.match("The large container.", [%re "/b[aeiou]g/"]) == None;
-```
-
-## normalize
-
-```re sig
-let normalize: t => t;
-```
-
-`normalize(str)` returns the normalized Unicode string using Normalization Form Canonical (NFC) Composition.
-Consider the character ã, which can be represented as the single codepoint \u00e3 or the combination of a lower case letter A \u0061 and a combining tilde \u0303.
-Normalization ensures that both can be stored in an equivalent binary representation. See [`String.normalize`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize) on MDN. See also [Unicode technical report #15](https://unicode.org/reports/tr15/) for details. 
-
-## normalizeByForm
-
-```re sig
-let normalizeByForm: (t, t) => t;
-```
-
-ES2015: `normalize(str, form)` returns the normalized Unicode string using the specified form of normalization, which may be one of:
-- "NFC" — Normalization Form Canonical Composition.
-- "NFD" — Normalization Form Canonical Decomposition.
-- "NFKC" — Normalization Form Compatibility Composition.
-- "NFKD" — Normalization Form Compatibility Decomposition.
-
-See [`String.normalize`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize) on MDN. See also [Unicode technical report #15](https://unicode.org/reports/tr15/) for details..
-
-## repeat
-
-```re sig
-let repeat: (t, int) => t;
-```
-
-`repeat(str, n)` returns a `string` that consists of `n` repetitions of `str`. Raises `RangeError` if `n` is negative. See [`String.repeat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat) on MDN.
-
-```re example
-Js.String2.repeat("ha", 3) == "hahaha";
-Js.String2.repeat("empty", 0) == "";
-```
-
-## replace
-
-```re sig
-let replace: (t, t, t) => t;
-```
-
-ES2015: `replace(str, substr, newSubstr)` returns a new `string` which is identical to `str` except with the first matching instance of `substr` replaced by `newSubstr`.
-`substr` is treated as a verbatim string to match, not a regular expression. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```re example
-Js.String2.replace("old string", "old", "new") == "new string";
-Js.String2.replace("the cat and the dog", "the", "this") == "this cat and the dog";
-```
-
-## replaceByRe
-
-```re sig
-let replaceByRe: (t, Js_re.t, t) => t;
-```
-
-`replaceByRe(str, regex, replacement)` returns a new `string` where occurrences matching regex have been replaced by `replacement`. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```re example
-Js.String2.replaceByRe("vowels be gone", [%re "/[aeiou]/g"], "x") == "vxwxls bx gxnx";
-Js.String2.replaceByRe("Juan Fulano", [%re "/(\\w+) (\\w+)/"], "$2, $1") == "Fulano, Juan";
-```
-
-## unsafeReplaceBy0
-
-```re sig
-let unsafeReplaceBy0: (t, Js_re.t, (t, int, t) => t) => t;
-```
-
-Returns a new `string` with some or all matches of a pattern with no capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```re example
-let str = "beautiful vowels";
-let re = [%re "/[aeiou]/g"];
-let matchFn = (matchPart, _offset, _wholeString) =>
-  Js.String2.toUpperCase(matchPart);
-
-Js.String2.unsafeReplaceBy0(str, re, matchFn)
-  == "bEAUtIfUl vOwEls";
-```
-
-## unsafeReplaceBy1
-
-```re sig
-let unsafeReplaceBy1: (t, Js_re.t, (t, t, int, t) => t) => t;
-```
-
-Returns a new `string` with some or all matches of a pattern with one set of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured string, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```re example
-let str = "increment 23";
-let re = [%re "/increment (\\d+)/g"];
-let matchFn = (_matchPart, p1, _offset, wholeString) =>
-  wholeString ++ " is " ++ Belt.Int.toString(int_of_string(p1) + 1);
-
-Js.String2.unsafeReplaceBy1(str, re, matchFn)
-  == "increment 23 is 24";
-```
-
-## unsafeReplaceBy2
-
-```re sig
-let unsafeReplaceBy2: (t, Js_re.t, (t, t, t, int, t) => t) => t;
-```
-
-Returns a new `string` with some or all matches of a pattern with two sets of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured strings, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```re example
-let str = "7 times 6";
-let re = [%re "/(\\d+) times (\\d+)/"];
-let matchFn = (matchPart, p1, p2, offset, wholeString) =>
-  Belt.Int.toString(int_of_string(p1) * int_of_string(p2));
-
-Js.String2.unsafeReplaceBy2(str, re, matchFn) == "42";
-```
-
-## unsafeReplaceBy3
-
-```re sig
-let unsafeReplaceBy3: (t, Js_re.t, (t, t, t, t, int, t) => t) => t;
-```
-
-Returns a new `string` with some or all matches of a pattern with three sets of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured strings, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-## search
-
-```re sig
-let search: (t, Js_re.t) => int;
-```
-
-`search(str, regexp)` returns the starting position of the first match of `regexp` in the given `str`, or -1 if there is no match. See [`String.search`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/search) on MDN.
-
-```re example
-Js.String2.search("testing 1 2 3", [%re "/\\d+/"]) == 8;
-Js.String2.search("no numbers", [%re "/\\d+/"]) == -1;
-```
-
-## slice
-
-```re sig
-let slice: (t, ~from: int, ~to_: int) => t;
-```
-
-`slice(str, from:n1, to_:n2)` returns the substring of `str` starting at character `n1` up to but not including `n2`.
-- If either `n1` or `n2` is negative, then it is evaluated as `length(str - n1)` or `length(str - n2)`.
-- If `n2` is greater than the length of `str`, then it is treated as `length(str)`.
-- If `n1` is greater than `n2`, slice returns the empty string.
-
-See [`String.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice) on MDN.
-
-```re example
-Js.String2.slice("abcdefg", ~from=2, ~to_=5) == "cde";
-Js.String2.slice("abcdefg", ~from=2, ~to_=9) == "cdefg";
-Js.String2.slice("abcdefg", ~from=(-4), ~to_=(-2)) == "de";
-Js.String2.slice("abcdefg", ~from=5, ~to_=1) == "";
-```
-
-## sliceToEnd
-
-```re sig
-let sliceToEnd: (t, ~from: int) => t;
-```
-
-`sliceToEnd(str, from:n)` returns the substring of `str` starting at character `n` to the end of the string.
-- If `n` is negative, then it is evaluated as `length(str - n)`.
-- If `n` is greater than the length of `str`, then sliceToEnd returns the empty string.
-
-See [`String.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice) on MDN.
-
-```re example
-Js.String2.sliceToEnd("abcdefg", ~from=4) == "efg";
-Js.String2.sliceToEnd("abcdefg", ~from=(-2)) == "fg";
-Js.String2.sliceToEnd("abcdefg", ~from=7) == "";
-```
-
-## split
-
-```re sig
-let split: (t, t) => array(t);
-```
-
-`split(str, delimiter)` splits the given `str` at every occurrence of `delimiter` and returns an array of the resulting substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```re example
-Js.String2.split("2018-01-02", "-") == [|"2018", "01", "02"|];
-Js.String2.split("a,b,,c", ",") == [|"a", "b", "", "c"|];
-Js.String2.split("good::bad as great::awful", "::") == [|"good", "bad as great", "awful"|];
-Js.String2.split("has-no-delimiter", ";") == [|"has-no-delimiter"|];
-```
-
-## splitAtMost
-
-```re sig
-let splitAtMost: (t, t, ~limit: int) => array(t);
-```
-
-`splitAtMost(str, delimiter, ~limit:n)` splits the given `str` at every occurrence of `delimiter` and returns an array of the first `n` resulting substrings.
-If `n` is negative or greater than the number of substrings, the array will contain all the substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```re example
-Js.String2.splitAtMost("ant/bee/cat/dog/elk", "/", ~limit=3) == [|"ant", "bee", "cat"|];
-Js.String2.splitAtMost("ant/bee/cat/dog/elk", "/", ~limit=0) == [||];
-Js.String2.splitAtMost("ant/bee/cat/dog/elk", "/", ~limit=9) == [|"ant", "bee", "cat", "dog", "elk"|];
-```
-
-## splitByRe
-
-```re sig
-let splitByRe: (t, Js_re.t) => array(option(t));
-```
-
-`splitByRe(str, regex)` splits the given `str` at every occurrence of `regex` and returns an array of the resulting substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```re example
-Js.String2.splitByRe("art; bed , cog ;dad", [%re "/\\s*[,;]\\s*/"])
-  == [|Some("art"), Some("bed"), Some("cog"), Some("dad")|];
-```
-
-## splitByReAtMost
-
-```re sig
-let splitByReAtMost: (t, Js_re.t, ~limit: int) => array(option(t));
-```
-
-`splitByReAtMost(str, regex, ~limit:n)` splits the given `str` at every occurrence of `regex` and returns an array of the first `n` resulting substrings.
-If `n` is negative or greater than the number of substrings, the array will contain all the substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```re example
-Js.String2.splitByReAtMost("one: two: three: four", [%re "/\\s*:\\s*/"], ~limit=3)
-  == [|Some("one"), Some("two"), Some("three")|];
-
-Js.String2.splitByReAtMost("one: two: three: four", [%re "/\\s*:\\s*/"], ~limit=0)
-  == [||];
-
-Js.String2.splitByReAtMost("one: two: three: four", [%re "/\\s*:\\s*/"], ~limit=8)
-  == [|Some("one"), Some("two"), Some("three"), Some("four")|];
-```
-
-## startsWith
-
-```re sig
-let startsWith: (t, t) => bool;
-```
-
-ES2015: `startsWith(str, substr)` returns `true` if the `str` starts with `substr`, `false` otherwise. See [`String.startsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith) on MDN.
-
-```re example
-Js.String2.startsWith("BuckleScript", "Buckle") == true;
-Js.String2.startsWith("BuckleScript", "") == true;
-Js.String2.startsWith("JavaScript", "Buckle") == false;
-```
-
-## startsWithFrom
-
-```re sig
-let startsWithFrom: (t, t, int) => bool;
-```
-
-ES2015: `startsWithFrom(str, substr, n)` returns `true` if the `str` starts with `substr` starting at position `n`, false otherwise.
-If `n` is negative, the search starts at the beginning of `str`. See [`String.startsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith) on MDN.
-
-```re example
-Js.String2.startsWithFrom("BuckleScript", "kle", 3) == true;
-Js.String2.startsWithFrom("BuckleScript", "", 3) == true;
-Js.String2.startsWithFrom("JavaScript", "Buckle", 2) == false;
-```
-
-## substr
-
-```re sig
-let substr: (t, ~from: int) => t;
-```
-
-`substr(str, ~from:n)` returns the substring of `str` from position `n` to the end of the string.
-- If `n` is less than zero, the starting position is the length of `str - n`.
-- If `n` is greater than or equal to the length of `str`, returns the empty string.
-
-JavaScript’s `String.substr()` is a legacy function. When possible, use `substring()` instead. See [`String.substr`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr) on MDN.
-
-```re example
-Js.String2.substr("abcdefghij", ~from=3) == "defghij";
-Js.String2.substr("abcdefghij", ~from=(-3)) == "hij";
-Js.String2.substr("abcdefghij", ~from=12) == "";
-```
-
-## substrAtMost
-
-```re sig
-let substrAtMost: (t, ~from: int, ~length: int) => t;
-```
-
-`substrAtMost(str, ~from: pos, ~length: n)` returns the substring of `str` of length `n` starting at position `pos`.
-- If `pos` is less than zero, the starting position is the length of `str - pos`.
-- If `pos` is greater than or equal to the length of `str`, returns the empty string.
-- If `n` is less than or equal to zero, returns the empty string.
-
-JavaScript’s `String.substr()` is a legacy function. When possible, use `substring()` instead. See [`String.substr`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr) on MDN.
-
-```re example
-Js.String2.substrAtMost("abcdefghij", ~from=3, ~length=4) == "defg";
-Js.String2.substrAtMost("abcdefghij", ~from=(-3), ~length=4) == "hij";
-Js.String2.substrAtMost("abcdefghij", ~from=12, ~length=2) == "";
-```
-
-## substring
-
-```re sig
-let substring: (t, ~from: int, ~to_: int) => t;
-```
-
-`substring(str, ~from: start, ~to_: finish)` returns characters `start` up to but not including finish from `str`.
-- If `start` is less than zero, it is treated as zero.
-- If `finish` is zero or negative, the empty string is returned.
-- If `start` is greater than `finish`, the `start` and `finish` points are swapped.
-
-See [`String.substring`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring) on MDN.
-
-```re example
-Js.String2.substring("playground", ~from=3, ~to_=6) == "ygr";
-Js.String2.substring("playground", ~from=6, ~to_=3) == "ygr";
-Js.String2.substring("playground", ~from=4, ~to_=12) == "ground";
-```
-
-## substringToEnd
-
-```re sig
-let substringToEnd: (t, ~from: int) => t;
-```
-
-`substringToEnd(str, ~from: start)` returns the substring of `str` from position `start` to the end.
-- If `start` is less than or equal to zero, the entire string is returned.
-- If `start` is greater than or equal to the length of `str`, the empty string is returned.
-
-See [`String.substring`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring) on MDN.
-
-```re example
-Js.String2.substringToEnd("playground", ~from=4) == "ground";
-Js.String2.substringToEnd("playground", ~from=(-3)) == "playground";
-Js.String2.substringToEnd("playground", ~from=12) == "";
-```
-
-## toLowerCase
-
-```re sig
-let toLowerCase: t => t;
-```
-
-`toLowerCase(str)` converts `str` to lower case using the locale-insensitive case mappings in the Unicode Character Database.
-Notice that the conversion can give different results depending upon context, for example with the Greek letter sigma, which has two different lower case forms; one when it is the last character in a string and another when it is not. See [`String.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase) on MDN.
-
-```re example
-Js.String2.toLowerCase("ABC") == "abc";
-Js.String2.toLowerCase({js|ΣΠ|js}) == {js|σπ|js};
-Js.String2.toLowerCase({js|ΠΣ|js}) == {js|πς|js};
-```
-
-## toLocaleLowerCase
-
-```re sig
-let toLocaleLowerCase: t => t;
-```
-
-`toLocaleLowerCase(str)` converts `str` to lower case using the current locale. See [`String.toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase) on MDN.
-
-## toUpperCase
-
-```re sig
-let toUpperCase: t => t;
-```
-
-`toUpperCase(str)` converts `str` to upper case using the locale-insensitive case mappings in the Unicode Character Database. 
-Notice that the conversion can expand the number of letters in the result; for example the German ß capitalizes to two Ses in a row. See [`String.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) on MDN.
-
-```re example
-Js.String2.toUpperCase("abc") == "ABC";
-Js.String2.toUpperCase({js|Straße|js}) == {js|STRASSE|js};
-Js.String2.toUpperCase({js|πς|js}) == {js|ΠΣ|js};
-```
-
-## toLocaleUpperCase
-
-```re sig
-let toLocaleUpperCase: t => t;
-```
-
-`toLocaleUpperCase(str)` converts `str` to upper case using the current locale. See [`String.to:LocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase) on MDN.
-
-## trim
-
-```re sig
-let trim: t => t;
-```
-
-`trim(str)` returns a string that is `str` with whitespace stripped from both ends. Internal whitespace is not removed. See [`String.trim`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trim) on MDN.
-
-```re example
-Js.String2.trim("   abc def   ") == "abc def";
-Js.String2.trim("\n\r\t abc def \n\n\t\r ") == "abc def";
-```
-
-## anchor
-
-```re sig
-let anchor: (t, t) => t;
-```
-
-`anchor(anchorText, anchorName)` creates a string with an HTML `<a>` element with name attribute of `anchorName` and `anchorText` as its content. Please do not use this method, as it has been removed from the relevant web standards. See [`String.anchor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/anchor) on MDN.
-
-```re example
-Js.String2.anchor("Page One", "page1") == "<a name=\"page1\">Page One</a>";
-```
-
-## link
-
-```re sig
-let link: (t, t) => t;
-```
-
-ES2015: `link(linkText, urlText)` creates a string with an HTML `<a>` element with href attribute of `urlText` and `linkText` as its content. Please do not use this method, as it has been removed from the relevant web standards. See [`String.link`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/link) on MDN.
-
-```re example
-Js.String2.link("Go to page two", "page2.html") == "<a href=\"page2.html\">Go to page two</a>";
-```
-
-## castToArrayLike
-
-```re sig
-let castToArrayLike: t => Js_array2.array_like(t);
-```
-
-Casts its argument to an `array_like` entity that can be processed by functions such as `Js.Array2.fromMap()`
-
-```re example
-let s = "abcde";
-let arr = Js.Array2.fromMap(Js.String2.castToArrayLike(s), (x)=>{x});
-arr == [|"a", "b", "c", "d", "e"|];
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/string.mdx b/pages/docs/manual/v8.0.0/api/js/string.mdx
deleted file mode 100644
index 43296c34e..000000000
--- a/pages/docs/manual/v8.0.0/api/js/string.mdx
+++ /dev/null
@@ -1,790 +0,0 @@
-# String
-
-<Intro>
-
-Provide bindings to JS string. Optimized for pipe-last.
-
-</Intro>
-
-## t
-
-```re sig
-type t = string;
-```
-
-## make
-
-```re sig
-let make: 'a => t;
-```
-
-`make(value)` converts the given value to a `string`.
-
-```re example
-Js.String2.make(3.5) == "3.5";
-Js.String2.make([|1,2,3|]) == "1,2,3";
-```
-
-## fromCharCode
-
-```re sig
-let fromCharCode: int => t;
-```
-
-`fromCharCode(n)` creates a `string` containing the character corresponding to that number; `n` ranges from 0 to 65535.
-If out of range, the lower 16 bits of the value are used. Thus, `fromCharCode(0x1F63A)` gives the same result as `fromCharCode(0xF63A)`. See [`String.fromCharCode`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode) on MDN.
-
-```re sig
-Js.String2.fromCharCode(65) == "A";
-Js.String2.fromCharCode(0x3c8) == {js|ψ|js};
-Js.String2.fromCharCode(0xd55c) == {js|한|js};
-Js.String2.fromCharCode(-64568) == {js|ψ|js};
-```
-
-## fromCharCodeMany
-
-```re sig
-let fromCharCodeMany: array(int) => t;
-```
-
-`fromCharCodeMany([|n1;n2;n3|])` creates a `string` from the characters corresponding to the given numbers, using the same rules as `fromCharCode`. See [`String.fromCharCode`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode) on MDN.
-
-## fromCodePoint
-
-```re sig
-let fromCodePoint: int => t;
-```
-
-`fromCodePoint(n)` creates a `string` containing the character corresponding to that numeric code point. 
-If the number is not a valid code point, it raises `RangeError`. 
-Thus, `fromCodePoint(0x1F63A)` will produce a correct value, unlike `fromCharCode(0x1F63A)`, and `fromCodePoint(-5)` will raise a `RangeError`. See [`String.fromCodePoint`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint) on MDN.
- 
-```re example
-Js.String2.fromCodePoint(65) == "A";
-Js.String2.fromCodePoint(0x3c8) == {js|ψ|js};
-Js.String2.fromCodePoint(0xd55c) == {js|한|js};
-Js.String2.fromCodePoint(0x1f63a) == {js|😺|js};
-```
-
-## fromCodePointMany
-
-```re sig
-let fromCodePointMany: array(int) => t;
-```
-
-`fromCodePointMany([|n1;n2;n3|])` creates a `string` from the characters corresponding to the given code point numbers, using the same rules as `fromCodePoint`. See [`String.fromCodePoint`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint) on MDN.
-
-```re example
-Js.String2.fromCodePointMany([|0xd55c, 0xae00, 0x1f63a|]) == {js|한글😺|js};
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-`length(s)` returns the length of the given `string`. See [`String.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length) on MDN.
-
-```re example
-Js.String2.length("abcd") == 4;
-```
-
-## get
-
-```re sig
-let get: (t, int) => t;
-```
-
-`get(s, n)` returns as a `string` the character at the given index number. 
-If `n` is out of range, this function returns `undefined`, so at some point this function may be modified to return `option(string)`.
-
-```re example
-Js.String2.get("Reason", 0) == "R";
-Js.String2.get("Reason", 4) == "o";
-Js.String2.get({js|Rẽasöń|js}, 5) == {js|ń|js};
-```
-
-## charAt
-
-```re sig
-let charAt: (int, t) => t;
-```
-
-`charAt(n, s)` gets the character at index `n` within string `s`. 
-If `n` is negative or greater than the length of `s`, it returns the empty string.
-If the string contains characters outside the range \u0000-\uffff, it will return the first 16-bit value at that position in the string. See [`String.charAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charAt) on MDN.
-
-```re example
-Js.String.charAt(0, "Reason") == "R";
-Js.String.charAt(12, "Reason") == "";
-Js.String.charAt(5, {js|Rẽasöń|js}) == {js|ń|js};
-```
-
-## charCodeAt
-
-```re sig
-let charCodeAt: (int, t) => float;
-```
-
-`charCodeAt(n, s)` returns the character code at position `n` in string `s`; the result is in the range 0-65535, unlke `codePointAt`, so it will not work correctly for characters with code points greater than or equal to 0x10000. 
-The return type is `float` because this function returns NaN if `n` is less than zero or greater than the length of the string. See [`String.charCodeAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charCodeAt) on MDN.
-
-```re example
-Js.String.charCodeAt(0, {js|😺|js}) == 0xd83d->float_of_int;
-Js.String.codePointAt(0, {js|😺|js}) == Some(0x1f63a);
-```
-
-## codePointAt
-
-```re sig
-let codePointAt: (int, t) => option(int);
-```
-
-`codePointAt(n, s)` returns the code point at position `n` within string `s` as a `Some(value)`. 
-The return value handles code points greater than or equal to 0x10000.
-If there is no code point at the given position, the function returns `None`. See [`String.codePointAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/codePointAt) on MDN.
-
-```re example
-Js.String.codePointAt(1, {js|¿😺?|js}) == Some(0x1f63a);
-Js.String.codePointAt(5, "abc") == None;
-```
-
-## concat
-
-```re sig
-let concat: (t, t) => t;
-```
-
-`concat(append, original)` returns a new `string` with `append` added after `original`. See [`String.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat) on MDN.
-
-```re example
-Js.String.concat("bell", "cow") == "cowbell";
-```
-
-## concatMany
-
-```re sig
-let concatMany: (array(t), t) => t;
-```
-
-`concat(arr, original)` returns a new `string` consisting of each item of an array of strings added to the `original` string. See [`String.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat) on MDN.
-
-```re example
-Js.String.concatMany([|"2nd", "3rd", "4th"|], "1st") == "1st2nd3rd4th";
-```
-
-## endsWith
-
-```re sig
-let endsWith: (t, t) => bool;
-```
-
-ES2015: `endsWith(substr, str)` returns `true` if the `str` ends with `substr`, `false` otherwise. See [`String.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith) on MDN.
-
-```re example
-Js.String.endsWith("Script", "BuckleScript") == true;
-Js.String.endsWith("Script", "BuckleShoes") == false;
-```
-
-## endsWithFrom
-
-```re sig
-let endsWithFrom: (t, int, t) => bool;
-```
-
-`endsWithFrom(ending, len, str)` returns `true` if the first len characters of `str` end with `ending`, `false` otherwise.
-If `len` is greater than or equal to the length of `str`, then it works like `endsWith`. (Honestly, this should have been named endsWithAt, but oh well.) See [`String.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith) on MDN.
-
-```re example
-Js.String.endsWithFrom("cd", 4, "abcd") == true;
-Js.String.endsWithFrom("cd", 3, "abcde") == false;
-Js.String.endsWithFrom("cde", 99, "abcde",) == true;
-Js.String.endsWithFrom("ple", 7, "example.dat") == true;
-```
-
-## includes
-
-```re sig
-let includes: (t, t) => bool;
-```
-
-ES2015: `includes(searchValue, str)` returns `true` if `searchValue` is found anywhere within `str`, false otherwise. See [`String.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes) on MDN.
-
-```re example
-Js.String.includes("gram", "programmer") == true;
-Js.String.includes("er", "programmer") == true;
-Js.String.includes("pro", "programmer") == true;
-Js.String.includes("xyz", "programmer.dat") == false;
-```
-
-## includesFrom
-
-```re sig
-let includesFrom: (t, int, t) => bool;
-```
-
-ES2015: `includes(searchValue start, str)` returns `true` if `searchValue` is found anywhere within `str` starting at character number `start` (where 0 is the first character), `false` otherwise. See [`String.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes) on MDN.
-
-```re example
-Js.String.includesFrom("gram", 1, "programmer") == true;
-Js.String.includesFrom("gram", 4, "programmer") == false;
-Js.String.includesFrom({js|한|js}, 1, {js|대한민국|js}) == true;
-```
-
-## indexOf
-
-```re sig
-let indexOf: (t, t) => int;
-```
-
-ES2015: `indexOf(searchValue, str)` returns the position at which `searchValue` was first found within `str`, or -1 if `searchValue` is not in `str`. See [`String.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf) on MDN.
-
-```re example
-Js.String.indexOf("ok", "bookseller") == 2;
-Js.String.indexOf("sell", "bookseller") == 4;
-Js.String.indexOf( "ee", "beekeeper") == 1;
-Js.String.indexOf("xyz", "bookseller") == -1;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (t, t, int) => int;
-```
-`indexOfFrom(searchValue, start, str)` returns the position at which `searchValue` was found within `str` starting at character position `start`, or -1 if `searchValue` is not found in that portion of `str`.
-The return value is relative to the beginning of the string, no matter where the search started from. See [`String.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf) on MDN.
-
-```re example
-Js.String.indexOfFrom("ok", 1, "bookseller") == 2;
-Js.String.indexOfFrom("sell", 2, "bookseller") == 4;
-Js.String.indexOfFrom("sell", 5, "bookseller") == -1;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (t, t) => int;
-```
-
-`lastIndexOf(searchValue, str)` returns the position of the last occurrence of `searchValue` within `str`, searching backwards from the end of the string.
-Returns -1 if `searchValue` is not in `str`. The return value is always relative to the beginning of the string. See [`String.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf) on MDN.
-
-```re example
-Js.String.lastIndexOf("ok", "bookseller") == 2;
-Js.String.lastIndexOf("ee", "beekeeper") == 4;
-Js.String.lastIndexOf("xyz", "abcdefg") == -1;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (t, int, t) => int;
-```
-
-`lastIndexOfFrom(searchValue, start, str)` returns the position of the last occurrence of `searchValue` within `str`, searching backwards from the given start position.
-Returns -1 if `searchValue` is not in `str`. The return value is always relative to the beginning of the string. See [`String.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf) on MDN.
-
-```re example
-Js.String.lastIndexOfFrom("ok", 6, "bookseller") == 2;
-Js.String.lastIndexOfFrom("ee", 8, "beekeeper") == 4;
-Js.String.lastIndexOfFrom("ee", 3, "beekeeper") == 1;
-Js.String.lastIndexOfFrom("xyz", 4, "abcdefg") == -1;
-```
-
-## localeCompare
-
-```re sig
-let localeCompare: (t, t) => float;
-```
-
-`localeCompare(comparison, reference)` returns
-- a negative value if reference comes before comparison in sort order
-- zero if reference and comparison have the same sort order
-- a positive value if reference comes after comparison in sort order
-
-See [`String.localeCompare`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare) on MDN.
-
-```re example
-Js.String.localeCompare("ant", "zebra") > 0.0;
-Js.String.localeCompare("zebra", "ant") < 0.0;
-Js.String.localeCompare("cat", "cat") == 0.0;
-Js.String.localeCompare("cat", "CAT") > 0.0;
-```
-
-## match
-
-```re sig
-let match: (Js_re.t, t) => option(array(t));
-```
-
-`match(regexp, str)` matches a `string` against the given `regexp`. If there is no match, it returns `None`. For regular expressions without the g modifier, if there is a match, the return value is `Some(array)` where the array contains:
-- The entire matched string
-- Any capture groups if the regexp had parentheses
-For regular expressions with the g modifier, a matched expression returns `Some(array)` with all the matched substrings and no capture groups. See [`String.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match) on MDN.
-
-```re example
-Js.String.match([%re "/b[aeiou]t/"], "The better bats") == Some([|"bet"|]);
-Js.String.match([%re "/b[aeiou]t/g"], "The better bats") == Some([|"bet", "bat"|]);
-Js.String.match([%re "/(\\d+)-(\\d+)-(\\d+)/"], "Today is 2018-04-05.") == Some([|"2018-04-05", "2018", "04", "05"|]);
-Js.String.match([%re "/b[aeiou]g/"], "The large container.") == None;
-```
-
-## normalize
-
-```re sig
-let normalize: t => t;
-```
-
-`normalize(str)` returns the normalized Unicode string using Normalization Form Canonical (NFC) Composition.
-Consider the character ã, which can be represented as the single codepoint \u00e3 or the combination of a lower case letter A \u0061 and a combining tilde \u0303.
-Normalization ensures that both can be stored in an equivalent binary representation. See [`String.normalize`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize) on MDN. See also [Unicode technical report #15](https://unicode.org/reports/tr15/) for details. 
-
-## normalizeByForm
-
-```re sig
-let normalizeByForm: (t, t) => t;
-```
-
-ES2015: `normalize(form, str)` returns the normalized Unicode string using the specified form of normalization, which may be one of:
-- "NFC" — Normalization Form Canonical Composition.
-- "NFD" — Normalization Form Canonical Decomposition.
-- "NFKC" — Normalization Form Compatibility Composition.
-- "NFKD" — Normalization Form Compatibility Decomposition.
-
-See [`String.normalize`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize) on MDN. See also [Unicode technical report #15](https://unicode.org/reports/tr15/) for details.
-
-## repeat
-
-```re sig
-let repeat: (t, int) => t;
-```
-
-`repeat(n, str)` returns a `string` that consists of `n` repetitions of `str`. Raises `RangeError` if `n` is negative. See [`String.repeat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat) on MDN.
-
-```re example
-Js.String.repeat(3, "ha") == "hahaha";
-Js.String.repeat(0, "empty") == "";
-```
-
-## replace
-
-```re sig
-let replace: (t, t, t) => t;
-```
-
-ES2015: `replace(substr, newSubstr, str)` returns a new `string` which is identical to `str` except with the first matching instance of `substr` replaced by `newSubstr`.
-`substr` is treated as a verbatim string to match, not a regular expression. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```re example
-Js.String.replace("old", "new", "old string") == "new string";
-Js.String.replace("the", "this", "the cat and the dog") == "this cat and the dog";
-```
-
-## replaceByRe
-
-```re sig
-let replaceByRe: (Js_re.t, t, t) => t;
-```
-
-`replaceByRe(regex, replacement, str)` returns a new `string` where occurrences matching regex have been replaced by `replacement`. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```re example
-Js.String.replaceByRe([%re "/[aeiou]/g"], "x", "vowels be gone") == "vxwxls bx gxnx";
-Js.String.replaceByRe([%re "/(\\w+) (\\w+)/"], "$2, $1", "Juan Fulano") == "Fulano, Juan";
-```
-
-## unsafeReplaceBy0
-
-```re sig
-let unsafeReplaceBy0: (Js_re.t, (t, int, t) => t, t) => t;
-```
-
-Returns a new `string` with some or all matches of a pattern with no capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```re example
-let str = "beautiful vowels";
-let re = [%re "/[aeiou]/g"];
-let matchFn = (matchPart, _offset, _wholeString) =>
-  Js.String.toUpperCase(matchPart);
-
-Js.String.unsafeReplaceBy0(re, matchFn, str)
-  == "bEAUtIfUl vOwEls";
-```
-
-## unsafeReplaceBy1
-
-```re sig
-let unsafeReplaceBy1: (Js_re.t, (t, t, int, t) => t, t) => t;
-```
-
-Returns a new `string` with some or all matches of a pattern with one set of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured string, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```re example
-let str = "increment 23";
-let re = [%re "/increment (\\d+)/g"];
-let matchFn = (_matchPart, p1, _offset, wholeString) =>
-  wholeString ++ " is " ++ Belt.Int.toString(int_of_string(p1) + 1);
-
-Js.String.unsafeReplaceBy1(re, matchFn, str)
-  == "increment 23 is 24";
-```
-
-## unsafeReplaceBy2
-
-```re sig
-let unsafeReplaceBy2: (Js_re.t, (t, t, t, int, t) => t, t) => t;
-```
-
-Returns a new `string` with some or all matches of a pattern with two sets of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured strings, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```re example
-let str = "7 times 6";
-let re = [%re "/(\\d+) times (\\d+)/"];
-let matchFn = (_matchPart, p1, p2, _offset, _wholeString) =>
-  Belt.Int.toString(int_of_string(p1) * int_of_string(p2));
-
-Js.String.unsafeReplaceBy2(re, matchFn, str) == "42";
-```
-
-## unsafeReplaceBy3
-
-```re sig
-let unsafeReplaceBy3: (Js_re.t, (t, t, t, t, int, t) => t, t) => t;
-```
-
-Returns a new `string` with some or all matches of a pattern with three sets of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured strings, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-## search
-
-```re sig
-let search: (Js_re.t, t) => int;
-```
-
-`search(regexp, str)` returns the starting position of the first match of `regexp` in the given `str`, or -1 if there is no match. See [`String.search`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/search) on MDN.
-
-```re example
-Js.String.search([%re "/\\d+/"], "testing 1 2 3") == 8;
-Js.String.search([%re "/\\d+/"], "no numbers") == -1;
-```
-
-## slice
-
-```re sig
-let slice: (~from: int, ~to_: int, t) => t;
-```
-
-`slice(from:n1, to_:n2, str)` returns the substring of `str` starting at character `n1` up to but not including `n2`.
-- If either `n1` or `n2` is negative, then it is evaluated as `length(str - n1)` or `length(str - n2)`.
-- If `n2` is greater than the length of `str`, then it is treated as `length(str)`.
-- If `n1` is greater than `n2`, slice returns the empty string.
-
-See [`String.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice) on MDN.
-
-```re example
-Js.String.slice(~from=2, ~to_=5, "abcdefg") == "cde";
-Js.String.slice(~from=2, ~to_=9, "abcdefg") == "cdefg";
-Js.String.slice(~from=(-4), ~to_=(-2), "abcdefg") == "de";
-Js.String.slice(~from=5, ~to_=1, "abcdefg") == "";
-```
-
-## sliceToEnd
-
-```re sig
-let sliceToEnd: (~from: int, t) => t;
-```
-
-`sliceToEnd(str, from:n)` returns the substring of `str` starting at character `n` to the end of the string.
-- If `n` is negative, then it is evaluated as `length(str - n)`.
-- If `n` is greater than the length of `str`, then sliceToEnd returns the empty string.
-
-See [`String.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice) on MDN.
-
-```re example
-Js.String.sliceToEnd(~from=4, "abcdefg") == "efg";
-Js.String.sliceToEnd(~from=(-2), "abcdefg") == "fg";
-Js.String.sliceToEnd(~from=7, "abcdefg") == "";
-```
-
-## split
-
-```re sig
-let split: (t, t) => array(t);
-```
-
-`split(delimiter, str)` splits the given `str` at every occurrence of `delimiter` and returns an array of the resulting substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```re example
-Js.String.split("-", "2018-01-02") == [|"2018", "01", "02"|];
-Js.String.split(",", "a,b,,c") == [|"a", "b", "", "c"|];
-Js.String.split("::", "good::bad as great::awful") == [|"good", "bad as great", "awful"|];
-Js.String.split(";", "has-no-delimiter") == [|"has-no-delimiter"|];
-```
-
-## splitAtMost
-
-```re sig
-let splitAtMost: (t, ~limit: int, t) => array(t);
-```
-
-`splitAtMost(delimiter, ~limit:n, str)` splits the given `str` at every occurrence of `delimiter` and returns an array of the first `n` resulting substrings.
-If `n` is negative or greater than the number of substrings, the array will contain all the substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```re example
-Js.String.splitAtMost("/", ~limit=3, "ant/bee/cat/dog/elk") == [|"ant", "bee", "cat"|];
-Js.String.splitAtMost("/", ~limit=0, "ant/bee/cat/dog/elk") == [||];
-Js.String.splitAtMost("/", ~limit=9, "ant/bee/cat/dog/elk") == [|"ant", "bee", "cat", "dog", "elk"|];
-```
-
-## splitLimited
-
-```re sig
-let splitLimited: (t, int, t) => array(t);
-```
-
-Deprecated - Please use splitAtMost.
-
-## splitByRe
-
-```re sig
-let splitByRe: (Js_re.t, t) => array(option(t));
-```
-
-`splitByRe(regex, str)` splits the given `str` at every occurrence of `regex` and returns an array of the resulting substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```re example
-Js.String.splitByRe([%re "/\\s*[,;]\\s*/"], "art; bed , cog ;dad")
-  == [|Some("art"), Some("bed"), Some("cog"), Some("dad")|];
-```
-
-## splitByReAtMost
-
-```re sig
-let splitByReAtMost: (Js_re.t, ~limit: int, t) => array(option(t));
-```
-
-`splitByReAtMost(regex, ~limit:n, str)` splits the given `str` at every occurrence of `regex` and returns an array of the first `n` resulting substrings.
-If `n` is negative or greater than the number of substrings, the array will contain all the substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```re example
-Js.String.splitByReAtMost([%re "/\\s*:\\s*/"], ~limit=3, "one: two: three: four")
-  == [|Some("one"), Some("two"), Some("three")|];
-
-Js.String.splitByReAtMost([%re "/\\s*:\\s*/"], ~limit=0, "one: two: three: four")
-  == [||];
-
-Js.String.splitByReAtMost([%re "/\\s*:\\s*/"], ~limit=8, "one: two: three: four")
-  == [|Some("one"), Some("two"), Some("three"), Some("four")|];
-```
-
-## splitRegexpLimited
-
-```re sig
-let splitRegexpLimited: (Js_re.t, int, t) => array(t);
-```
-
-Deprecated - Please use splitByReAtMost.
-
-## startsWith
-
-```re sig
-let startsWith: (t, t) => bool;
-```
-
-ES2015: `startsWith(substr, str)` returns `true` if the `str` starts with `substr`, `false` otherwise. See [`String.startsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith) on MDN.
-
-```re example
-Js.String.startsWith("Buckle", "BuckleScript") == true;
-Js.String.startsWith("", "BuckleScript") == true;
-Js.String.startsWith("Buckle", "JavaScript") == false;
-```
-
-## startsWithFrom
-
-```re sig
-let startsWithFrom: (t, int, t) => bool;
-```
-
-ES2015: `startsWithFrom(substr, n, str)` returns `true` if the `str` starts with `substr` starting at position `n`, false otherwise.
-If `n` is negative, the search starts at the beginning of `str`. See [`String.startsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith) on MDN.
-
-```re example
-Js.String.startsWithFrom("kle", 3, "BuckleScript") == true;
-Js.String.startsWithFrom("", 3, "BuckleScript") == true;
-Js.String.startsWithFrom("Buckle", 2, "JavaScript") == false;
-```
-
-## substr
-
-```re sig
-let substr: (~from: int, t) => t;
-```
-
-`substr(~from:n, str)` returns the substring of `str` from position `n` to the end of the string.
-- If `n` is less than zero, the starting position is the length of `str - n`.
-- If `n` is greater than or equal to the length of `str`, returns the empty string.
-
-JavaScript’s `String.substr()` is a legacy function. When possible, use `substring()` instead. See [`String.substr`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr) on MDN.
-
-```re example
-Js.String.substr(~from=3, "abcdefghij") == "defghij";
-Js.String.substr(~from=(-3), "abcdefghij") == "hij";
-Js.String.substr(~from=12, "abcdefghij") == "";
-```
-
-## substrAtMost
-
-```re sig
-let substrAtMost: (~from: int, ~length: int, t) => t;
-```
-
-`substrAtMost(~from: pos, ~length: n, str)` returns the substring of `str` of length `n` starting at position `pos`.
-- If `pos` is less than zero, the starting position is the length of `str - pos`.
-- If `pos` is greater than or equal to the length of `str`, returns the empty string.
-- If `n` is less than or equal to zero, returns the empty string.
-
-JavaScript’s `String.substr()` is a legacy function. When possible, use `substring()` instead. See [`String.substr`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr) on MDN.
-
-```re example
-Js.String.substrAtMost(~from=3, ~length=4, "abcdefghij") == "defg";
-Js.String.substrAtMost(~from=(-3), ~length=4, "abcdefghij") == "hij";
-Js.String.substrAtMost(~from=12, ~length=2, "abcdefghij") == "";
-```
-
-## substring
-
-```re sig
-let substring: (~from: int, ~to_: int, t) => t;
-```
-
-`substring(~from: start, ~to_: finish, str)` returns characters `start` up to but not including finish from `str`.
-- If `start` is less than zero, it is treated as zero.
-- If `finish` is zero or negative, the empty string is returned.
-- If `start` is greater than `finish`, the `start` and `finish` points are swapped.
-
-See [`String.substring`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring) on MDN.
-
-```re example
-Js.String.substring(~from=3, ~to_=6, "playground") == "ygr";
-Js.String.substring(~from=6, ~to_=3, "playground") == "ygr";
-Js.String.substring(~from=4, ~to_=12, "playground") == "ground";
-```
-
-## substringToEnd
-
-```re sig
-let substringToEnd: (~from: int, t) => t;
-```
-
-`substringToEnd(~from: start, str)` returns the substring of `str` from position `start` to the end.
-- If `start` is less than or equal to zero, the entire string is returned.
-- If `start` is greater than or equal to the length of `str`, the empty string is returned.
-
-See [`String.substring`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring) on MDN.
-
-```re example
-Js.String.substringToEnd(~from=4, "playground") == "ground";
-Js.String.substringToEnd(~from=(-3), "playground") == "playground";
-Js.String.substringToEnd(~from=12, "playground") == "";
-```
-
-## toLowerCase
-
-```re sig
-let toLowerCase: t => t;
-```
-
-`toLowerCase(str)` converts `str` to lower case using the locale-insensitive case mappings in the Unicode Character Database.
-Notice that the conversion can give different results depending upon context, for example with the Greek letter sigma, which has two different lower case forms; one when it is the last character in a string and another when it is not. See [`String.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase) on MDN.
-
-```re example
-Js.String.toLowerCase("ABC") == "abc";
-Js.String.toLowerCase({js|ΣΠ|js}) == {js|σπ|js};
-Js.String.toLowerCase({js|ΠΣ|js}) == {js|πς|js};
-```
-
-## toLocaleLowerCase
-
-```re sig
-let toLocaleLowerCase: t => t;
-```
-
-`toLocaleLowerCase(str)` converts `str` to lower case using the current locale. See [`String.toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase) on MDN.
-
-## toUpperCase
-
-```re sig
-let toUpperCase: t => t;
-```
-
-`toUpperCase(str)` converts `str` to upper case using the locale-insensitive case mappings in the Unicode Character Database. 
-Notice that the conversion can expand the number of letters in the result; for example the German ß capitalizes to two Ses in a row. See [`String.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) on MDN.
-
-```re example
-Js.String.toUpperCase("abc") == "ABC";
-Js.String.toUpperCase({js|Straße|js}) == {js|STRASSE|js};
-Js.String.toUpperCase({js|πς|js}) == {js|ΠΣ|js};
-```
-
-## toLocaleUpperCase
-
-```re sig
-let toLocaleUpperCase: t => t;
-```
-
-`toLocaleUpperCase(str)` converts `str` to upper case using the current locale. See [`String.to:LocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase) on MDN.
-
-## trim
-
-```re sig
-let trim: t => t;
-```
-
-`trim(str)` returns a string that is `str` with whitespace stripped from both ends. Internal whitespace is not removed. See [`String.trim`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trim) on MDN.
-
-```re example
-Js.String.trim("   abc def   ") == "abc def";
-Js.String.trim("\n\r\t abc def \n\n\t\r ") == "abc def";
-```
-
-## anchor
-
-```re sig
-let anchor: (t, t) => t;
-```
-
-`anchor(anchorName, anchorText)` creates a string with an HTML `<a>` element with name attribute of `anchorName` and `anchorText` as its content. Please do not use this method, as it has been removed from the relevant web standards. See [`String.anchor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/anchor) on MDN.
-
-```re example
-Js.String.anchor("page1", "Page One") == "<a name=\"page1\">Page One</a>"
-```
-
-## link
-
-```re sig
-let link: (t, t) => t;
-```
-
-ES2015: `link(urlText, linkText)` creates a string with an HTML `<a>` element with href attribute of `urlText` and `linkText` as its content. Please do not use this method, as it has been removed from the relevant web standards. See [`String.link`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/link) on MDN.
-
-```re example
-Js.String.link("page2.html", "Go to page two") == "<a href=\"page2.html\">Go to page two</a>";
-```
-
-## castToArrayLike
-
-```re sig
-let castToArrayLike: t => Js_array2.array_like(t);
-```
-
-Casts its argument to an `array_like` entity that can be processed by functions such as `Js.Array2.fromMap()`
-
-```re example
-let s = "abcde";
-let arr = Js.Array2.fromMap(Js.String.castToArrayLike(s), (x)=>{x});
-arr == [|"a", "b", "c", "d", "e"|];
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array-2.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array-2.mdx
deleted file mode 100644
index 3df37be41..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array-2.mdx
+++ /dev/null
@@ -1,31 +0,0 @@
-# TypedArray2
-
-<Intro>
-
-Provide bindings to JS typed array.
-
-</Intro>
-
-## array_buffer
-
-```re sig
-type array_buffer;
-```
-
-## array_like
-
-```re sig
-type array_like('a);
-```
-
-## module ArrayBuffer
-## module Int8Array
-## module Uint8Array
-## module Uint8ClampedArray
-## module Int16Array
-## module Uint16Array
-## module Int32Array
-## module Uint32Array
-## module Float32Array
-## module Float64Array
-## module DataView
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array-2_array-buffer.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array-2_array-buffer.mdx
deleted file mode 100644
index 0e5415ab1..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array-2_array-buffer.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# TypedArray2.ArrayBuffer
-
-<Intro>
-
-Provide bindings to JS typed array ArrayBuffer.
-
-</Intro>
-
-## t
-
-```re sig
-type t = Js_typed_array2.array_buffer;
-```
-
-## make
-
-```re sig
-let make: int => t;
-```
-
-Takes length. initializes elements to 0.
-
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## slice
-
-```re sig
-let slice: (t, ~start: int, ~end_: int) => Js_typed_array2.array_buffer;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (t, int) => Js_typed_array2.array_buffer;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array-2_data-view.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array-2_data-view.mdx
deleted file mode 100644
index a2ce87588..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array-2_data-view.mdx
+++ /dev/null
@@ -1,223 +0,0 @@
-# TypedArray2.DataView
-
-<Intro>
-
-Provide bindings to JS typed array DataView.
-
-</Intro>
-
-## t
-
-```re sig
-type t;
-```
-
-## make
-
-```re sig
-let make: Js_typed_array2.array_buffer => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array2.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t;
-```
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array2.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## getInt8
-
-```re sig
-let getInt8: (t, int) => int;
-```
-
-## getUint8
-
-```re sig
-let getUint8: (t, int) => int;
-```
-
-## getInt16
-
-```re sig
-let getInt16: (t, int) => int;
-```
-
-## getInt16LittleEndian
-
-```re sig
-let getInt16LittleEndian: (t, int) => int;
-```
-
-## getUint16
-
-```re sig
-let getUint16: (t, int) => int;
-```
-
-## getUint16LittleEndian
-
-```re sig
-let getUint16LittleEndian: (t, int) => int;
-```
-
-## getInt32
-
-```re sig
-let getInt32: (t, int) => int;
-```
-
-## getInt32LittleEndian
-
-```re sig
-let getInt32LittleEndian: (t, int) => int;
-```
-
-## getUint32
-
-```re sig
-let getUint32: (t, int) => int;
-```
-
-## getUint32LittleEndian
-
-```re sig
-let getUint32LittleEndian: (t, int) => int;
-```
-
-## getFloat32
-
-```re sig
-let getFloat32: (t, int) => float;
-```
-
-## getFloat32LittleEndian
-
-```re sig
-let getFloat32LittleEndian: (t, int) => float;
-```
-
-## getFloat64
-
-```re sig
-let getFloat64: (t, int) => float;
-```
-
-## getFloat64LittleEndian
-
-```re sig
-let getFloat64LittleEndian: (t, int) => float;
-```
-
-## setInt8
-
-```re sig
-let setInt8: (t, int, int) => unit;
-```
-
-## setUint8
-
-```re sig
-let setUint8: (t, int, int) => unit;
-```
-
-## setInt16
-
-```re sig
-let setInt16: (t, int, int) => unit;
-```
-
-## setInt16LittleEndian
-
-```re sig
-let setInt16LittleEndian: (t, int, int) => unit;
-```
-
-## setUint16
-
-```re sig
-let setUint16: (t, int, int) => unit;
-```
-
-## setUint16LittleEndian
-
-```re sig
-let setUint16LittleEndian: (t, int, int) => unit;
-```
-
-## setInt32
-
-```re sig
-let setInt32: (t, int, int) => unit;
-```
-
-## setInt32LittleEndian
-
-```re sig
-let setInt32LittleEndian: (t, int, int) => unit;
-```
-
-## setUint32
-
-```re sig
-let setUint32: (t, int, int) => unit;
-```
-
-## setUint32LittleEndian
-
-```re sig
-let setUint32LittleEndian: (t, int, int) => unit;
-```
-
-## setFloat32
-
-```re sig
-let setFloat32: (t, int, float) => unit;
-```
-
-## setFloat32LittleEndian
-
-```re sig
-let setFloat32LittleEndian: (t, int, float) => unit;
-```
-
-## setFloat64
-
-```re sig
-let setFloat64: (t, int, float) => unit;
-```
-
-## setFloat64LittleEndian
-
-```re sig
-let setFloat64LittleEndian: (t, int, float) => unit;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array-2_float-32-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array-2_float-32-array.mdx
deleted file mode 100644
index 08912039f..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array-2_float-32-array.mdx
+++ /dev/null
@@ -1,365 +0,0 @@
-# TypedArray2.Float32Array
-
-<Intro>
-
-Provide bindings to JS typed array Float32Array.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = float;
-type typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array2.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array2.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array2.array_like(elt) => t;
-```
-
-  
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array-2_float-64-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array-2_float-64-array.mdx
deleted file mode 100644
index 52a523d2a..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array-2_float-64-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Float64Array
-
-<Intro>
-
-Provide bindings to JS typed array Float64Array.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = float;
-type typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array2.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array2.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array2.array_like(elt) => t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array-2_int-16-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array-2_int-16-array.mdx
deleted file mode 100644
index 68c04f2cf..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array-2_int-16-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Int16Array
-
-<Intro>
-
-Provide bindings to JS typed array Int16Array.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = int;
-type typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array2.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array2.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array2.array_like(elt) => t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array-2_int-32-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array-2_int-32-array.mdx
deleted file mode 100644
index c6464d4df..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array-2_int-32-array.mdx
+++ /dev/null
@@ -1,375 +0,0 @@
-# TypedArray2.Int32Array
-
-<Intro>
-
-Provide bindings to JS typed array Int32Array.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = int32;
-type typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array2.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array2.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array2.array_like(elt) => t;
-```
-
-## create
-
-```re sig
-let create: array(elt) => t;
-```
-
-## of_buffer
-
-```re sig
-let of_buffer: Js_typed_array2.array_buffer => t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array-2_int-8-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array-2_int-8-array.mdx
deleted file mode 100644
index d1691dc6e..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array-2_int-8-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Int8Array
-
-<Intro>
-
-Provide bindings to JS typed array Int8Array.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = int;
-type typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array2.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array2.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array2.array_like(elt) => t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array-2_uint-16-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array-2_uint-16-array.mdx
deleted file mode 100644
index 3514b9ddd..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array-2_uint-16-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Uint16Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint16Array.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = int;
-type typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array2.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array2.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array2.array_like(elt) => t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array-2_uint-32-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array-2_uint-32-array.mdx
deleted file mode 100644
index cf2ea4280..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array-2_uint-32-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.UInt32Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint32Array.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = int;
-type typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array2.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array2.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array2.array_like(elt) => t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array-2_uint-8-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array-2_uint-8-array.mdx
deleted file mode 100644
index 68f5f6ac2..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array-2_uint-8-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Uint8Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint8Array.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = int;
-type typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array2.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array2.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array2.array_like(elt) => t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array-2_uint-8-clamped-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array-2_uint-8-clamped-array.mdx
deleted file mode 100644
index c2d4d4646..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array-2_uint-8-clamped-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Uint8ClampedArray
-
-<Intro>
-
-Provide bindings to JS typed array Uint8ClampedArray.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = int;
-type typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array2.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array2.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array2.array_like(elt) => t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array.mdx
deleted file mode 100644
index d80d022d5..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array.mdx
+++ /dev/null
@@ -1,38 +0,0 @@
-# TypedArray
-
-<Intro>
-
-Provide bindings to JS typed array.
-
-</Intro>
-
-## array_buffer
-
-```re sig
-type array_buffer;
-```
-
-## array_like
-
-```re sig
-type array_like('a);
-```
-
-## module type Type
-
-```re sig
-module type Type = {type t;};
-```
-
-## module ArrayBuffer
-## module type S
-## module Int8Array
-## module Uint8Array
-## module Uint8ClampedArray
-## module Int16Array
-## module Uint16Array
-## module Int32Array
-## module Uint32Array
-## module Float32Array
-## module Float64Array 
-## module DataView
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array_array-buffer.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array_array-buffer.mdx
deleted file mode 100644
index f3e9642b4..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array_array-buffer.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# TypedArray.ArrayBuffer
-
-<Intro>
-
-Provide bindings to JS typed array ArrayBuffer.
-
-</Intro>
-
-## t
-
-```re sig
-type t = Js_typed_array.array_buffer;
-```
-
-## make
-
-```re sig
-let make: int => t;
-```
-
-Takes length. initializes elements to 0.
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => Js_typed_array.array_buffer;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => Js_typed_array.array_buffer;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array_data-view.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array_data-view.mdx
deleted file mode 100644
index 91815dd81..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array_data-view.mdx
+++ /dev/null
@@ -1,223 +0,0 @@
-# TypedArray.DataView
-
-<Intro>
-
-Provide bindings to JS typed array DataView.
-
-</Intro>
-
-## t
-
-```re sig
-type t = Js_typed_array2.DataView.t;
-```
-
-## make
-
-```re sig
-let make: Js_typed_array.array_buffer => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t;
-```
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## getInt8
-
-```re sig
-let getInt8: (t, int) => int;
-```
-
-## getUint8
-
-```re sig
-let getUint8: (t, int) => int;
-```
-
-## getInt16
-
-```re sig
-let getInt16: (t, int) => int;
-```
-
-## getInt16LittleEndian
-
-```re sig
-let getInt16LittleEndian: (t, int) => int;
-```
-
-## getUint16
-
-```re sig
-let getUint16: (t, int) => int;
-```
-
-## getUint16LittleEndian
-
-```re sig
-let getUint16LittleEndian: (t, int) => int;
-```
-
-## getInt32
-
-```re sig
-let getInt32: (t, int) => int;
-```
-
-## getInt32LittleEndian
-
-```re sig
-let getInt32LittleEndian: (t, int) => int;
-```
-
-## getUint32
-
-```re sig
-let getUint32: (t, int) => int;
-```
-
-## getUint32LittleEndian
-
-```re sig
-let getUint32LittleEndian: (t, int) => int;
-```
-
-## getFloat32
-
-```re sig
-let getFloat32: (t, int) => float;
-```
-
-## getFloat32LittleEndian
-
-```re sig
-let getFloat32LittleEndian: (t, int) => float;
-```
-
-## getFloat64
-
-```re sig
-let getFloat64: (t, int) => float;
-```
-
-## getFloat64LittleEndian
-
-```re sig
-let getFloat64LittleEndian: (t, int) => float;
-```
-
-## setInt8
-
-```re sig
-let setInt8: (t, int, int) => unit;
-```
-
-## setUint8
-
-```re sig
-let setUint8: (t, int, int) => unit;
-```
-
-## setInt16
-
-```re sig
-let setInt16: (t, int, int) => unit;
-```
-
-## setInt16LittleEndian
-
-```re sig
-let setInt16LittleEndian: (t, int, int) => unit;
-```
-
-## setUint16
-
-```re sig
-let setUint16: (t, int, int) => unit;
-```
-
-## setUint16LittleEndian
-
-```re sig
-let setUint16LittleEndian: (t, int, int) => unit;
-```
-
-## setInt32
-
-```re sig
-let setInt32: (t, int, int) => unit;
-```
-
-## setInt32LittleEndian
-
-```re sig
-let setInt32LittleEndian: (t, int, int) => unit;
-```
-
-## setUint32
-
-```re sig
-let setUint32: (t, int, int) => unit;
-```
-
-## setUint32LittleEndian
-
-```re sig
-let setUint32LittleEndian: (t, int, int) => unit;
-```
-
-## setFloat32
-
-```re sig
-let setFloat32: (t, int, float) => unit;
-```
-
-## setFloat32LittleEndian
-
-```re sig
-let setFloat32LittleEndian: (t, int, float) => unit;
-```
-
-## setFloat64
-
-```re sig
-let setFloat64: (t, int, float) => unit;
-```
-
-## setFloat64LittleEndian
-
-```re sig
-let setFloat64LittleEndian: (t, int, float) => unit;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array_float-32-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array_float-32-array.mdx
deleted file mode 100644
index e90e15832..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array_float-32-array.mdx
+++ /dev/null
@@ -1,375 +0,0 @@
-# TypedArray.Float32Array
-
-<Intro>
-
-Provide bindings to JS typed array Float32Array.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = float;
-type typed_array('a) = Js_typed_array2.Float32Array.typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array.array_like(elt) => t;
-```
-
-## create
-
-```re sig
-let create: array(elt) => t;
-```
-
-## of_buffer
-
-```re sig
-let of_buffer: Js_typed_array.array_buffer => t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array_float-64-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array_float-64-array.mdx
deleted file mode 100644
index e122f4648..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array_float-64-array.mdx
+++ /dev/null
@@ -1,375 +0,0 @@
-# TypedArray.Float64Array
-
-<Intro>
-
-Provide bindings to JS typed array Float64Array.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = float;
-type typed_array('a) = Js_typed_array2.Float64Array.typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array.array_like(elt) => t;
-```
-
-## create
-
-```re sig
-let create: array(elt) => t;
-```
-
-## of_buffer
-
-```re sig
-let of_buffer: Js_typed_array.array_buffer => t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array_int-16-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array_int-16-array.mdx
deleted file mode 100644
index eb7fc8175..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array_int-16-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.Int16Array
-
-<Intro>
-
-Provide bindings to JS typed array Int16Array.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = int;
-type typed_array('a) = Js_typed_array2.Int16Array.typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array.array_like(elt) => t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array_int-32-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array_int-32-array.mdx
deleted file mode 100644
index c4385d7ce..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array_int-32-array.mdx
+++ /dev/null
@@ -1,375 +0,0 @@
-# TypedArray.Int32Array
-
-<Intro>
-
-Provide bindings to JS typed array Int32Array.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = int32;
-type typed_array('a) = Js_typed_array2.Int32Array.typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array.array_like(elt) => t;
-```
-
-## create
-
-```re sig
-let create: array(elt) => t;
-```
-
-## of_buffer
-
-```re sig
-let of_buffer: Js_typed_array.array_buffer => t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array_int-8-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array_int-8-array.mdx
deleted file mode 100644
index 49d19a61e..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array_int-8-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.Int8Array
-
-<Intro>
-
-Provide bindings to JS typed array Int8Array.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = int;
-type typed_array('a) = Js_typed_array2.Int8Array.typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array.array_like(elt) => t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array_type-s.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array_type-s.mdx
deleted file mode 100644
index 46b5b85da..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array_type-s.mdx
+++ /dev/null
@@ -1,310 +0,0 @@
-# TypedArray type S
-
-<Intro>
-
-TODO
-
-</Intro>
-
-## t
-
-```re sig
-type elt;
-type typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array_uint-16-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array_uint-16-array.mdx
deleted file mode 100644
index eba8edf91..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array_uint-16-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.Uint16Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint16Array.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = int;
-type typed_array('a) = Js_typed_array2.Uint16Array.typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array.array_like(elt) => t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array_uint-32-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array_uint-32-array.mdx
deleted file mode 100644
index b848c13a1..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array_uint-32-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.UInt32Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint32Array.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = int;
-type typed_array('a) = Js_typed_array2.Uint32Array.typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array.array_like(elt) => t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array_uint-8-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array_uint-8-array.mdx
deleted file mode 100644
index d785b66e9..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array_uint-8-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.Uint8Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint8Array.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = int;
-type typed_array('a) = Js_typed_array2.Uint8Array.typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array.array_like(elt) => t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/typed-array_uint-8-clamped-array.mdx b/pages/docs/manual/v8.0.0/api/js/typed-array_uint-8-clamped-array.mdx
deleted file mode 100644
index 1653dfde2..000000000
--- a/pages/docs/manual/v8.0.0/api/js/typed-array_uint-8-clamped-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.Uint8ClampedArray
-
-<Intro>
-
-Provide bindings to JS typed array Uint8ClampedArray.
-
-</Intro>
-
-## t
-
-```re sig
-type elt = int;
-type typed_array('a) = Js_typed_array2.Uint8ClampedArray.typed_array('a);
-type t = typed_array(elt);
-```
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t, int) => elt;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t, int, elt) => unit;
-```
-
-## buffer
-
-```re sig
-let buffer: t => Js_typed_array.array_buffer;
-```
-
-## byteLength
-
-```re sig
-let byteLength: t => int;
-```
-
-## byteOffset
-
-```re sig
-let byteOffset: t => int;
-```
-
-## setArray
-
-```re sig
-let setArray: (array(elt), t) => unit;
-```
-
-## setArrayOffset
-
-```re sig
-let setArrayOffset: (array(elt), int, t) => unit;
-```
-
-## length
-
-```re sig
-let length: t => int;
-```
-
-## copyWithin
-
-```re sig
-let copyWithin: (~to_: int, t) => t;
-```
-
-## copyWithinFrom
-
-```re sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t;
-```
-
-## copyWithinFromRange
-
-```re sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t;
-```
-
-## fillInPlace
-
-```re sig
-let fillInPlace: (elt, t) => t;
-```
-
-## fillFromInPlace
-
-```re sig
-let fillFromInPlace: (elt, ~from: int, t) => t;
-```
-
-## fillRangeInPlace
-
-```re sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t;
-```
-
-## reverseInPlace
-
-```re sig
-let reverseInPlace: t => t;
-```
-
-## sortInPlace
-
-```re sig
-let sortInPlace: t => t;
-```
-
-## sortInPlaceWith
-
-```re sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t;
-```
-
-## includes
-
-```re sig
-let includes: (elt, t) => bool;
-```
-
-ES2016
-
-## indexOf
-
-```re sig
-let indexOf: (elt, t) => int;
-```
-
-## indexOfFrom
-
-```re sig
-let indexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## join
-
-```re sig
-let join: t => string;
-```
-
-## joinWith
-
-```re sig
-let joinWith: (string, t) => string;
-```
-
-## lastIndexOf
-
-```re sig
-let lastIndexOf: (elt, t) => int;
-```
-
-## lastIndexOfFrom
-
-```re sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int;
-```
-
-## slice
-
-```re sig
-let slice: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```re sig
-let copy: t => t;
-```
-
-## sliceFrom
-
-```re sig
-let sliceFrom: (int, t) => t;
-```
-
-## subarray
-
-```re sig
-let subarray: (~start: int, ~end_: int, t) => t;
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```re sig
-let subarrayFrom: (int, t) => t;
-```
-
-## toString
-
-```re sig
-let toString: t => string;
-```
-
-## toLocaleString
-
-```re sig
-let toLocaleString: t => string;
-```
-
-## every
-
-```re sig
-let every: ((. elt) => bool, t) => bool;
-```
-
-## everyi
-
-```re sig
-let everyi: ((. elt, int) => bool, t) => bool;
-```
-
-## filter
-
-```re sig
-let filter: ((. elt) => bool, t) => t;
-```
-
-## filteri
-
-```re sig
-let filteri: ((. elt, int) => bool, t) => t;
-```
-
-## find
-
-```re sig
-let find: ((. elt) => bool, t) => Js.undefined(elt);
-```
-
-## findi
-
-```re sig
-let findi: ((. elt, int) => bool, t) => Js.undefined(elt);
-```
-
-## findIndex
-
-```re sig
-let findIndex: ((. elt) => bool, t) => int;
-```
-
-## findIndexi
-
-```re sig
-let findIndexi: ((. elt, int) => bool, t) => int;
-```
-
-## forEach
-
-```re sig
-let forEach: ((. elt) => unit, t) => unit;
-```
-
-## forEachi
-
-```re sig
-let forEachi: ((. elt, int) => unit, t) => unit;
-```
-
-## map
-
-```re sig
-let map: ((. elt) => 'b, t) => typed_array('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. elt, int) => 'b, t) => typed_array('b);
-```
-
-## reduce
-
-```re sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reducei
-
-```re sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## reduceRight
-
-```re sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b;
-```
-
-## reduceRighti
-
-```re sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b;
-```
-
-## some
-
-```re sig
-let some: ((. elt) => bool, t) => bool;
-```
-
-## somei
-
-```re sig
-let somei: ((. elt, int) => bool, t) => bool;
-```
-
-## _BYTES_PER_ELEMENT
-
-```re sig
-let _BYTES_PER_ELEMENT: int;
-```
-
-## make
-
-```re sig
-let make: array(elt) => t;
-```
-
-## fromBuffer
-
-```re sig
-let fromBuffer: Js_typed_array.array_buffer => t;
-```
-
-## fromBufferOffset
-
-```re sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t;
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```re sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```re sig
-let fromLength: int => t;
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```re sig
-let from: Js_typed_array.array_like(elt) => t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/types.mdx b/pages/docs/manual/v8.0.0/api/js/types.mdx
deleted file mode 100644
index 4ccce8b2b..000000000
--- a/pages/docs/manual/v8.0.0/api/js/types.mdx
+++ /dev/null
@@ -1,77 +0,0 @@
-# Types
-
-<Intro>
-
-Provide utilities for manipulating JS types.
-
-</Intro>
-
-## symbol
-
-```re sig
-type symbol;
-```
-
-## obj_val
-
-```re sig
-type obj_val;
-```
-
-## undefined_val
-
-```re sig
-type undefined_val;
-```
-
-## null_val
-
-```re sig
-type null_val;
-```
-
-## function_val
-
-```re sig
-type function_val;
-```
-
-## t
-```re sig
-type t('a) =
-  | Undefined: t(undefined_val)
-  | Null: t(null_val)
-  | Boolean: t(bool)
-  | Number: t(float)
-  | String: t(string)
-  | Function: t(function_val)
-  | Object: t(obj_val)
-  | Symbol: t(symbol);
-```
-
-## test
-
-```re sig
-let test: ('a, t('b)) => bool;
-```
-
-## tagged_t
-
-```re sig
-type tagged_t =
-  | JSFalse
-  | JSTrue
-  | JSNull
-  | JSUndefined
-  | JSNumber(float)
-  | JSString(string)
-  | JSFunction(function_val)
-  | JSObject(obj_val)
-  | JSSymbol(symbol);
-```
-
-## classify
-
-```re sig
-let classify: 'a => tagged_t;
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/undefined.mdx b/pages/docs/manual/v8.0.0/api/js/undefined.mdx
deleted file mode 100644
index 2bc30704f..000000000
--- a/pages/docs/manual/v8.0.0/api/js/undefined.mdx
+++ /dev/null
@@ -1,119 +0,0 @@
-# Undefined
-
-<Intro>
-
-Provide utilities around `Js.undefined`.
-
-</Intro>
-
-## t
-
-```re sig
-type t('a) = Js.undefined('a);
-```
-
-Local alias for 'a Js.undefined.
-
-## return
-
-```re sig
-let return: 'a => t('a);
-```
-
-Constructs a value of `Js.undefined('a)` containing a value of `'a`.
-
-## test
-
-```re sig
-let test: t('a) => bool;
-```
-
-Returns `true` if the given value is empty (undefined), `false` otherwise.
-
-## testAny
-
-```re sig
-let testAny: 'a => bool;
-```
-
-Since 1.6.1 Returns `true` if the given value is empty (undefined).
-
-## empty
-
-```re sig
-let empty: t('a);
-```
-
-The empty value, `undefined`.
-
-## getUnsafe
-
-```re sig
-let getUnsafe: t('a) => 'a;
-```
-
-## getExn
-
-```re sig
-let getExn: t('a) => 'a;
-```
-
-## bind
-
-```re sig
-let bind: (t('a), (. 'a) => 'b) => t('b);
-```
-
-Maps the contained value using the given function.
-If `Js.undefined('a)` contains a value, that value is unwrapped, mapped to a `'b` using the given function `a' => 'b`, then wrapped back up and returned as `Js.undefined('b)`.
-
-```re example
-let maybeGreetWorld = (maybeGreeting: Js.undefined(string)) =>
-  Js.Undefined.bind(maybeGreeting, [@bs] greeting => greeting ++ " world!");
-```
-
-## iter
-
-```re sig
-let iter: (t('a), (. 'a) => unit) => unit;
-```
-
-Iterates over the contained value with the given function.
-If `Js.undefined('a)` contains a value, that value is unwrapped and applied to the given function.
-
-```re example
-let maybeSay = (maybeMessage: Js.undefined(string)) =>
-  Js.Undefined.iter(maybeMessage, [@bs] message => Js.log(message));
-```
-
-## fromOption
-
-```re sig
-let fromOption: option('a) => t('a);
-```
-
-Maps `option('a)` to `Js.undefined('a)`.
-`Some(a)` => `a`
-`None` => `empty`
-
-## from_opt
-
-```re sig
-let from_opt: option('a) => t('a);
-```
-
-## toOption
-
-```re sig
-let toOption: t('a) => option('a);
-```
-
-Maps `Js.undefined('a)` to `option('a)`
-`a` => `Some(a)`
-`empty` => `None`
-
-## to_opt
-
-```re sig
-let to_opt: t('a) => option('a);
-```
diff --git a/pages/docs/manual/v8.0.0/api/js/vector.mdx b/pages/docs/manual/v8.0.0/api/js/vector.mdx
deleted file mode 100644
index 1ceef1474..000000000
--- a/pages/docs/manual/v8.0.0/api/js/vector.mdx
+++ /dev/null
@@ -1,157 +0,0 @@
-# Vector
-
-<Intro>
-
-Provide vector utilities.
-
-</Intro>
-
-## t
-
-```re sig
-type t('a) = array('a);
-```
-
-## filterInPlace
-
-```re sig
-let filterInPlace: ((. 'a) => bool, t('a)) => unit;
-```
-
-p : predicate
-a : array
-
-## empty
-
-```re sig
-let empty: t('a) => unit;
-```
-
-## pushBack
-
-```re sig
-let pushBack: ('a, t('a)) => unit;
-```
-
-## copy
-
-```re sig
-let copy: t('a) => t('a);
-```
-
-Create a shallow copy of a vector.
-
-## memByRef
-
-```re sig
-let memByRef: ('a, t('a)) => bool;
-```
-
-Find by JS (===) equality.
-
-## iter
-
-```re sig
-let iter: ((. 'a) => unit, t('a)) => unit;
-```
-
-## iteri
-
-```re sig
-let iteri: ((. int, 'a) => unit, t('a)) => unit;
-```
-
-## toList
-
-```re sig
-let toList: t('a) => list('a);
-```
-
-## map
-
-```re sig
-let map: ((. 'a) => 'b, t('a)) => t('b);
-```
-
-## mapi
-
-```re sig
-let mapi: ((. int, 'a) => 'b, t('a)) => t('b);
-```
-
-## foldLeft
-
-```re sig
-let foldLeft: ((. 'a, 'b) => 'a, 'a, t('b)) => 'a;
-```
-
-## foldRight
-
-```re sig
-let foldRight: ((. 'b, 'a) => 'a, t('b), 'a) => 'a;
-```
-
-## length
-
-```re sig
-let length: t('a) => int;
-```
-
-Return the length (number of elements) of the given array.
-
-## get
-
-```re sig
-let get: (t('a), int) => 'a;
-```
-
-`Vector.get(a, n)` returns the element number `n` of vector `a`. The first element has number 0. The last element has number `Vector.length(a) - 1`. You can also write `a[n]` instead of `Vector.get(a, n)`.
-Raise `Invalid_argument "index out of bounds"` if `n` is outside the range 0 to (`Array.length(a) - 1`).
-
-## set
-
-```re sig
-let set: (t('a), int, 'a) => unit;
-```
-
-`Vector.set(a, n, x)` modifies vector `a` in place, replacing element number `n` with `x`.
-Raise `Invalid_argument "index out of bounds"` if `n` is outside the range 0 to `Array.length(a) - 1`.
-
-## make
-
-```re sig
-let make: (int, 'a) => t('a);
-```
-
-`Vector.make(n, x)` returns a fresh vector of length `n`, initialized with `x`. All the elements of this new vector are initially physically equal to `x` (in the sense of the `==` predicate).
-Consequently, if `x` is mutable, it is shared among all elements of the array, and modifying `x` through one of the array entries will modify all other entries at the same time.
-Raise `Invalid_argument` if `n < 0` or `n > Sys.max_array_length`. If the value of `x` is a floating-point number, then the maximum size is only `Sys.max_array_length / 2`.
-
-## init
-
-```re sig
-let init: (int, (. int) => 'a) => t('a);
-```
-
-Raises `RangeError` when n is negative.
-n : size
-
-## append
-
-```re sig
-let append: ('a, t('a)) => t('a);
-```
-
-`append(x, a)` returns a fresh vector with `x` appended to `a`.
-
-## unsafe_get
-
-```re sig
-let unsafe_get: (t('a), int) => 'a;
-```
-
-## unsafe_set
-
-```re sig
-let unsafe_set: (t('a), int, 'a) => unit;
-```
diff --git a/pages/docs/manual/v8.0.0/array-and-list.mdx b/pages/docs/manual/v8.0.0/array-and-list.mdx
deleted file mode 100644
index 229c4a078..000000000
--- a/pages/docs/manual/v8.0.0/array-and-list.mdx
+++ /dev/null
@@ -1,172 +0,0 @@
----
-title: "Array & List"
-description: "Arrays and List data structures"
-canonical: "/docs/manual/latest/array-and-list"
----
-
-# Array and List
-
-## Array
-
-Arrays are our main ordered data structure. They work the same way as JavaScript arrays: they can be randomly accessed, dynamically resized, updated, etc.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let myArray = [|"hello", "world", "how are you"|];
-```
-```ml
-let myArray = [|"hello"; "world"; "how are you"|]
-```
-```js
-var myArray = ["hello", "world", "how are you"];
-```
-
-</CodeTab>
-
-ReScript arrays' items must have the same type, i.e. homogeneous.
-
-### Usage
-
-See the [Js.Array](api/js/array) API.
-
-Access & update an array item like so:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let myArray = [|"hello", "world", "how are you"|];
-
-let firstItem = myArray[0]; // "hello"
-
-myArray[0] = "hey"; // now [|"hey", "world", "how are you"|]
-
-let pushedValue = Js.Array2.push(myArray, "bye");
-```
-```ml
-let myArray = [|"hello"; "world"; "how are you"|]
-
-let firstItem = myArray(0)  (* "hello" *)
-
-let () = myArray.(0) <- "hey" (* now [|"hey"; "world"; "how are you"|] *)
-```
-```js
-var myArray = ["hello", "world", "how are you"];
-
-var firstItem = myArray[0];
-
-myArray[0] = "hey";
-
-var pushedValue = myArray.push("bye");
-```
-
-</CodeTab>
-
-## List
-
-ReScript provides a singly linked list too. Lists are:
-
-- immutable
-- fast at prepending items
-- fast at getting the tail
-- slow at everything else
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let myList = [1, 2, 3];
-```
-```ml
-let myList = [1; 2; 3]
-```
-```js
-var myList = {
-  hd: 1,
-  tl: {
-    hd: 2,
-    tl: {
-      hd: 3,
-      tl: 0
-    }
-  }
-};
-```
-
-</CodeTab>
-
-Like arrays, lists' items need to be of the same type.
-
-### Usage
-
-You'd use list for its resizability, its fast prepend (adding at the head), and its fast split, all of which are immutable and relatively efficient.
-
-Do **not** use list if you need to randomly access an item or insert at non-head position. Your code would end up obtuse and/or slow.
-
-The standard lib provides a [List module](api/belt/list).
-
-#### Immutable Prepend
-
-Use the spread syntax:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let myList = [1, 2, 3];
-let anotherList = [0, ...myList];
-```
-```ml
-let myList = [1; 2; 3]
-let anotherList = 0 :: myList
-```
-```js
-var myList = {
-  hd: 1,
-  tl: {
-    hd: 2,
-    tl: {
-      hd: 3,
-      tl: 0
-    }
-  }
-};
-
-var anotherList = {
-  hd: 0,
-  tl: myList
-};
-```
-
-</CodeTab>
-
-`myList` didn't mutate. `anotherList` is now `[0, 1, 2, 3]`. This is efficient (constant time, not linear). `anotherList`'s last 3 elements are shared with `myList`!
-
-**Note that `[a, ...b, ...c]` is a syntax error**. We don't support multiple spread for a list. That'd be an accidental linear operation (`O(b)`), since each item of b would be one-by-one added to the head of `c`. You can use `List.concat` for this, but we highly discourage it.
-
-Updating an arbitrary item in the middle of a list is also discouraged, since its performance and allocation overhead would be linear (`O(n)`).
-
-#### Access
-
-`switch` (described in the [pattern matching section](pattern-matching-destructuring.md)) is usually used to access list items:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let message =
-  switch myList {
-  | [] => "This list is empty"
-  | [a, ...rest] => "The head of the list is the string " ++ Js.Int.toString(a)
-  };
-```
-```ml
-let message =
-  match myList with
-  | [] -> "This list is empty"
-  | a::rest -> "The head of the list is the string " ^ (Js.Int.toString a)
-```
-```js
-var message = myList
-  ? "The head of the list is the string " + (1).toString()
-  : "This list is empty";
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v8.0.0/bind-to-global-js-values.mdx b/pages/docs/manual/v8.0.0/bind-to-global-js-values.mdx
deleted file mode 100644
index 44272b926..000000000
--- a/pages/docs/manual/v8.0.0/bind-to-global-js-values.mdx
+++ /dev/null
@@ -1,175 +0,0 @@
----
-title: "Bind to Global JS Values"
-description: "JS interop with global JS values in ReScript"
-canonical: "/docs/manual/latest/bind-to-global-js-values"
----
-
-# Bind to Global JS Values
-
-**First**, make sure the value you'd like to model doesn't already exist in our [provided API](api/js).
-
-Some JS values, like `setTimeout`, live in the global scope. You can bind to them like so:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.val] external setTimeout: (unit => unit, int) => float = "setTimeout";
-[@bs.val] external clearTimeout: float => unit = "clearTimeout";
-```
-```ml
-external setTimeout: (unit -> unit) -> int -> float = "setTimeout" [@@bs.val]
-external clearTimeout: float -> unit = "clearTimeout" [@@bs.val]
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-(We already provide `setTimeout`, `clearTimeout` and others in the [Js.Global](api/js/global) module).
-
-This binds to the JavaScript [`setTimeout`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrworkerGlobalScope/setTimeout) methods and the corresponding `clearTimeout`. The `external`'s type annotation specifies that `setTimeout`:
-
-- Takes a function that accepts `unit` and returns `unit` (which on the JS side turns into a function that accepts nothing and returns nothing aka `undefined`),
-- and an integer that specifies the duration before calling said function,
-- returns a number that is the timeout's ID. This number might be big, so we're modeling it as a float rather than the 32-bit int.
-
-### Tips & Tricks
-
-**The above isn't ideal**. See how `setTimeout` returns a `float` and `clearTimeout` accepts one. There's no guarantee that you're passing the float created by `setTimeout` into `clearTimeout`! For all we know, someone might pass it `Math.random()` into the latter.
-
-We're in a language with a great type system now! Let's leverage a popular feature to solve this problem: abstract types.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type timerId;
-[@bs.val] external setTimeout: (unit => unit, int) => timerId = "setTimeout";
-[@bs.val] external clearTimeout: timerId => unit = "clearTimeout";
-
-let id = setTimeout(() => Js.log("hello"), 100);
-clearTimeout(id);
-```
-```ml
-type timerId
-external setTimeout: (unit -> unit) -> int -> timerId = "setTimeout" [@@bs.val]
-external clearTimeout: timerId -> unit = "clearTimeout" [@@bs.val]
-
-let id = setTimeout (fun () -> Js.log "hello") 100
-let () = clearTimeout id
-```
-```js
-var id = setTimeout(function (param) {
-  console.log("hello");
-}, 100);
-
-clearTimeout(id);
-```
-
-</CodeTab>
-
-Clearly, `timerId` is a type that can only be created by `setTimeout`! Now we've guaranteed that `clearTimeout` _will_ be passed a valid ID. Whether it's a number under the hood is now a mere implementation detail.
-
-Since `external`s are inlined, we end up with JS output as readable as hand-written JS.
-
-## Global Modules
-
-If you want to bind to a value inside a global module, e.g. `Math.random`, attach a `bs.scope` to your `bs.val` external:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.scope "Math"] [@bs.val] external random: unit => float = "random";
-let someNumber = random();
-```
-```ml
-external random : unit -> float = "random" [@@bs.scope "Math"][@@bs.val]
-let someNumber = random ()
-```
-```js
-var someNumber = Math.random();
-```
-
-</CodeTab>
-
-you can bind to an arbitrarily deep object by passing a tuple to `bs.scope`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.val] [@bs.scope ("window", "location", "ancestorOrigins")]
-external length: int = "length";
-```
-```ml
-external length: int = "length"
-[@@bs.val][@@bs.scope ("window", "location", "ancestorOrigins")]
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-This binds to `window.location.ancestorOrigins.length`.
-
-## Special Global Values
-
-Global values like `__filename` and `__DEV__` don't always exist; you can't even model them as an `option`, since the mere act of referring to them in ReScript (then compiled into JS) would trigger the usual `Uncaught ReferenceError: __filename is not defined` error in e.g. the browser environment.
-
-For these troublesome global values, ReScript provides a special approach: `%external(a_single_identifier)`.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-switch ([%external __DEV__]) {
-| Some(_) => Js.log("dev mode")
-| None => Js.log("production mode")
-};
-```
-```ml
-let () = match [%external __DEV__] with
-| Some _ -> Js.log "dev mode"
-| None -> Js.log "production mode"
-```
-```js
-var match = typeof __DEV__ === "undefined" ? undefined : __DEV__;
-
-if (match !== undefined) {
-  console.log("dev mode");
-} else {
-  console.log("production mode");
-}
-```
-
-</CodeTab>
-
-That first line's `typeof` check won't trigger a JS ReferenceError.
-
-Another example:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-switch ([%external __filename]) {
-| Some(f) => Js.log(f)
-| None => Js.log("non-node environment")
-};
-```
-```ml
-let () = match [%external __filename] with
-| Some f -> Js.log f
-| None -> Js.log "non-node environment"
-```
-```js
-var match = typeof (__filename) === "undefined" ? undefined : (__filename);
-
-if (match !== undefined) {
-  console.log(match);
-} else {
-  console.log("non-node environment");
-}
-```
-
-</CodeTab>
-
-<!-- TODO: revamp this page. Not good. Tell to use globalThis["foo"], and look in our stdlib -->
diff --git a/pages/docs/manual/v8.0.0/bind-to-js-function.mdx b/pages/docs/manual/v8.0.0/bind-to-js-function.mdx
deleted file mode 100644
index 3aed460ca..000000000
--- a/pages/docs/manual/v8.0.0/bind-to-js-function.mdx
+++ /dev/null
@@ -1,600 +0,0 @@
----
-title: "Bind to JS Function"
-description: "JS interop with functions in ReScript"
-canonical: "/docs/manual/latest/bind-to-js-function"
----
-
-# Function
-
-Binding a JS function is like binding any other value:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-// Import nodejs' path.dirname
-[@bs.module "path"] external dirname: string => string = "dirname";
-let root = dirname("/User/github"); // returns "User"
-```
-```ml
-(* Import nodejs' path.dirname *)
-external dirname: string -> string = "dirname" [@@bs.module "path"]
-let root = dirname "/User/github" (* returns "User" *)
-```
-```js
-var Path = require("path");
-var root = Path.dirname("/User/github");
-```
-
-</CodeTab>
-
-We also expose a few special features, described below.
-
-## Labeled Arguments
-
-ReScript has [labeled arguments](function.md#labeled-arguments) (that can also be optional). These work on an `external` too! You'd use them to _fix_ a JS function's unclear usage. Assuming we're modeling this:
-
-```js
-// MyGame.js
-
-function draw(x, y, border) {
-   // suppose `border` is optional and defaults to false
-}
-draw(10, 20)
-draw(20, 20, true)
-```
-
-It'd be nice if on ReScript's side, we can bind & call `draw` while labeling things a bit:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.module "MyGame"]
-external draw: (~x: int, ~y: int, ~border: bool=?, unit) => unit = "draw";
-
-draw(~x=10, ~y=20, ~border=true, ());
-draw(~x=10, ~y=20, ());
-```
-```ml
-external draw: x:int -> y:int -> ?border:bool -> unit -> unit = "draw"
-[@@bs.module "MyGame"]
-
-let () = draw ~x:10 ~y:20 ~border:true ()
-let () = draw ~x:10 ~y:20 ()
-```
-```js
-var MyGame = require("MyGame");
-
-MyGame.draw(10, 20, true);
-MyGame.draw(10, 20, undefined);
-```
-
-</CodeTab>
-
-We've compiled to the same function, but now the usage is much clearer on the ReScript side thanks to labels!
-
-**Note**: in this particular case, you need a unit, `()` after `border`, since `border` is an [optional argument at the last position](function.md#optional-labeled-arguments). Not having a unit to indicate you've finished applying the function would generate a warning.
-
-Note that you can change the order of labeled arguments on the ReScript side and BuckleScript will ensure that they appear the right way in the JavaScript output:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.module "MyGame"]
-external draw: (~x: int, ~y: int, ~border: bool=?, unit) => unit = "draw";
-
-draw(~x=10, ~y=20, ());
-draw(~y=20, ~x=10, ());
-```
-```ml
-external draw: x:int -> y:int -> ?border:bool -> unit -> unit = "draw"
-[@@bs.module "MyGame"]
-
-let () = draw ~x:10 ~y:20 ()
-let () = draw ~y:20 ~x:10 ()
-```
-```js
-var MyGame = require("MyGame");
-
-MyGame.draw(10, 20, undefined);
-MyGame.draw(10, 20, undefined);
-```
-
-</CodeTab>
-
-## Object Method
-
-Functions attached to JS objects (other than JS modules) require a special way of binding to them, using `bs.send`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type document; // abstract type for a document object
-[@bs.send] external getElementById: (document, string) => Dom.element = "getElementById";
-[@bs.val] external doc: document = "document";
-
-let el = getElementById(doc, "myId");
-```
-```ml
-type document (* abstract type for a document object *)
-external getElementById: document -> string -> Dom.element = "getElementById" [@@bs.send]
-external doc: document = "document" [@@bs.val ]
-
-let el = getElementById doc "myId"
-```
-```js
-var el = document.getElementById("myId");
-```
-
-</CodeTab>
-
-In a `bs.send`, the object is always the first argument. Actual arguments of the method follow (this is a bit what modern OOP objects are really).
-
-### Chaining
-
-Ever used `foo().bar().baz()` chaining ("fluent api") in JS OOP? We can model that in BuckleScript too, through the [pipe operator](pipe.md).
-
-## Variadic Function Arguments
-
-You might have JS functions that take an arbitrary amount of arguments. BuckleScript supports modeling those, under the condition that the arbitrary arguments part is homogenous (aka of the same type). If so, add `bs.variadic` to your `external`.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.module "path"] [@bs.variadic]
-external join: array(string) => string = "join";
-
-let v = join([|"a", "b"|]);
-```
-```ml
-external join : string array -> string = "join"
-[@@bs.module "path"][@@bs.variadic]
-
-let v = join [|"a"; "b"|]
-```
-```js
-var Path = require("path");
-var v = Path.join("a", "b");
-```
-
-</CodeTab>
-
-`bs.module` will be explained in [Import from/Export to JS](import-from-export-to-js.md).
-
-## Modeling Polymorphic Function
-
-Apart from the above special-case, JS function in general are often arbitrary overloaded in terms of argument types and number. How would you bind to those?
-
-### Trick 1: Multiple `external`s
-
-If you can exhaustively enumerate the many forms an overloaded JS function can take, simply bind to each differently:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.module "MyGame"] external drawCat: unit => unit = "draw";
-[@bs.module "MyGame"] external drawDog: (~giveName: string) => unit = "draw";
-[@bs.module "MyGame"] external draw: (string, ~useRandomAnimal: bool) => unit = "draw";
-```
-```ml
-external drawCat: unit -> unit = "draw" [@@bs.module "MyGame"]
-external drawDog: giveName:string -> unit = "draw" [@@bs.module "MyGame"]
-external draw: string -> useRandomAnimal:bool -> unit = "draw" [@@bs.module "MyGame"]
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Note how all three externals bind to the same JS function, `draw`.
-
-### Trick 2: Polymorphic Variant + `bs.unwrap`
-
-If you have the irresistible urge of saying "if only this JS function argument was a variant instead of informally being either `string` or `int`", then good news: we do provide such `external` features through annotating a parameter as a polymorphic variant! Assuming you have the following JS function you'd like to bind to:
-
-```js
-function padLeft(value, padding) {
-  if (typeof padding === "number") {
-    return Array(padding + 1).join(" ") + value;
-  }
-  if (typeof padding === "string") {
-    return padding + value;
-  }
-  throw new Error(`Expected string or number, got '${padding}'.`);
-}
-```
-
-Here, `padding` is really conceptually a variant. Let's model it as such.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.val]
-external padLeft: (
-  string,
-  [@bs.unwrap] [
-    | `Str(string)
-    | `Int(int)
-  ])
-  => string = "padLeft";
-
-padLeft("Hello World", `Int(4));
-padLeft("Hello World", `Str("Message from ReScript: "));
-```
-```ml
-external padLeft:
-  string ->
-  (([
-    | `Str of string
-    | `Int of int
-  ]) [@bs.unwrap]) ->
-  string = "padLeft" [@@bs.val]
-
-let _ = padLeft "Hello World" (`Int 4)
-let _ = padLeft "Hello World" (`Str "Message from ReScript: ")
-```
-```js
-padLeft("Hello World", 4);
-padLeft("Hello World", "Message from ReScript: ");
-```
-
-</CodeTab>
-
-Obviously, the JS side couldn't have an argument that's a polymorphic variant! But here, we're just piggy backing on poly variants' type checking and syntax. The secret is the `@bs.unwrap` annotation on the type. It strips the variant constructors and compile to just the payload's value. See the output.
-
-## Constrain Arguments Better
-
-Consider the Node `fs.readFileSync`'s second argument. It can take a string, but really only a defined set: `"ascii"`, `"utf8"`, etc. You can still bind it as a string, but we can use poly variants + `bs.string` to ensure that our usage's more correct:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.module "fs"]
-external readFileSync: (
-  ~name: string,
-  [@bs.string] [
-    | `utf8
-    | [@bs.as "ascii"] `useAscii
-  ],
-) => string = "fs";
-
-readFileSync(~name="xx.txt", `useAscii);
-```
-```ml
-external readFileSync:
-  name:string ->
-  (([
-    | `utf8
-    | `useAscii [@bs.as "ascii"]
-  ]) [@bs.string]) ->
-  string = "fs"
-[@@bs.module "fs"]
-
-let _ = readFileSync ~name:"xx.txt" `useAscii
-```
-```js
-var Fs = require("fs");
-Fs.readFileSync("xx.txt", "ascii");
-```
-
-</CodeTab>
-
-- Attaching `[@bs.string]` to the whole poly variant type makes its constructor compile to a string of the same name.
-- Attaching a `[@bs.as "bla"]` to a constructor lets you customize the final string.
-
-And now, passing something like `"myOwnUnicode"` or other variant constructor names to `readFileSync` would correctly error.
-
-Aside from string, you can also compile an argument to an int, using `bs.int` instead of `bs.string` in a similar way:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.val]
-external testIntType: (
-  [@bs.int] [
-    | `onClosed
-    | [@bs.as 20] `onOpen
-    | `inBinary
-  ])
-  => int = "testIntType";
-testIntType(`inBinary);
-```
-```ml
-external testIntType: (([
-  | `onClosed
-  | `onOpen [@bs.as 20]
-  | `inBinary
-  ]) [@bs.int]) ->
-  int = "testIntType" [@@bs.val]
-
-let _ = testIntType `inBinary
-```
-```js
-testIntType(21);
-```
-
-</CodeTab>
-
-`onClosed` compiles to `0`, `onOpen` to `20` and `inBinary` to **`21`**.
-
-## Special-case: Event Listeners
-
-One last trick with polymorphic variants:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type readline;
-
-[@bs.send]
-external on: (
-    readline,
-    [@bs.string] [
-      | `close(unit => unit)
-      | `line(string => unit)
-    ]
-  )
-  => readline = "on";
-
-let register = rl =>
-  rl
-  ->on(`close(event => ()))
-  ->on(`line(line => Js.log(line)));
-```
-```ml
-type readline
-
-external on:
-  readline ->
-  (([
-    | `close of unit -> unit
-    | `line of string -> unit
-  ]) [@bs.string]) ->
-  readline = "on" [@@bs.send]
-
-let register rl =
-  rl
-  |. on (`close (fun event -> ()))
-  |. on (`line (fun line -> Js.log line))
-```
-```js
-function register(rl) {
-  return rl
-    .on("close", function($$event) {})
-    .on("line", function(line) {
-      console.log(line);
-    });
-}
-```
-
-</CodeTab>
-
-<!-- TODO: GADT phantom type -->
-
-## Fixed Arguments
-
-Sometimes it's convenient to bind to a function using an `external`, while passing predetermined argument values to the JS function:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.val]
-external processOnExit: (
-  [@bs.as "exit"] _,
-  int => unit
-) => unit = "process.on";
-
-processOnExit(exitCode =>
-  Js.log("error code: " ++ Js.Int.toString(exitCode))
-);
-```
-```ml
-external processOnExit:
-  (_ [@bs.as "exit"]) ->
-  (int -> unit) ->
-  unit = "process.on"
-[@@bs.val]
-
-let () = processOnExit (fun exitCode  ->
- Js.log ("error code: " ^ (Js.Int.toString exitCode))
-)
-```
-```js
-process.on("exit", function (exitCode) {
-  console.log("error code: " + exitCode.toString());
-});
-```
-
-</CodeTab>
-
-The `[@bs.as "exit"]` and the placeholder `_` argument together indicates that you want the first argument to compile to the string `"exit"`. You can also use any JSON literal with `bs.as`: `` [@bs.as {json|true|json}] ``, `` [@bs.as {json|{"name": "John"}|json}] ``, etc.
-
-## Curry & Uncurry
-
-Curry is a delicious Indian dish. More importantly, in the context of ReScript (and functional programming in general), currying means that function taking multiple arguments can be applied a few arguments at time, until all the arguments are applied.
-
-See the `addFive` intermediate function? `add` takes in 3 arguments but received only 1. It's interpreted as "currying" the argument `5` and waiting for the next 2 arguments to be applied later on. Type signatures:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```rei
-let add: (int, int, int) => int;
-let addFive: (int, int) => int;
-let twelve: int;
-```
-```mli
-val add: (int * int * int) => int
-val addFive: (int * int) => int
-val twelve: int
-```
-
-</CodeTab>
-
-(In a dynamic language such as JS, currying would be dangerous, since accidentally forgetting to pass an argument doesn't error at compile time).
-
-### Drawback
-
-Unfortunately, due to JS not having currying because of the aforementioned reason, it's hard for ReScript multi-argument functions to map cleanly to JS functions 100% of the time:
-
-1. When all the arguments of a function are supplied (aka no currying), ReScript does its best to to compile e.g. a 3-arguments call into a plain JS call with 3 arguments.
-
-2. If it's too hard to detect whether a function application is complete\*, ReScript will use a runtime mechanism (the `Curry` module) to curry as many args as we can and check whether the result is fully applied.
-
-3. Some JS APIs like `throttle`, `debounce` and `promise` might mess with context, aka use the function `bind` mechanism, carry around `this`, etc. Such implementation clashes with the previous currying logic.
-
-\* If the call site is typed as having 3 arguments, we sometimes don't know whether it's a function that's being curried, or if the original one indeed has only 3 arguments.
-
-ReScript tries to do #1 as much as it can. Even when it bails and uses #2's currying mechanism, it's usually harmless.
-
-**However**, if you encounter #3, heuristics are not good enough: you need a guaranteed way of fully applying a function, without intermediate currying steps. We provide such guarantee through the use of the `@bs` "uncurrying" annotation on a function declaration & call site.
-
-### Solution: Use Guaranteed Uncurrying
-
-[Uncurried function](function.md#uncurried-function) annotation also works on `external`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type timerId;
-[@bs.val] external setTimeout: ((. unit) => unit, int) => timerId = "setTimeout";
-
-let id = setTimeout((.) => Js.log("hello"), 1000);
-```
-```ml
-type timerId
-external setTimeout: ((unit -> unit) [@bs]) -> int -> timerId = "setTimeout" [@@bs.val]
-
-let id = setTimeout ((fun () -> Js.log "hello") [@bs]) 1000
-```
-```js
-var id = setTimeout(function () {
-  console.log("hello");
-}, 1000);
-```
-
-</CodeTab>
-
-#### Extra Solution
-
-The above solution is safe, guaranteed, and performant, but sometimes visually a little burdensome. We provide an alternative solution if:
-
-- you're using `external`
-- the `external` function takes in an argument that's another function
-- you want the user **not** to need to annotate the call sites with the dot
-
-<!-- TODO: is this up-to-date info? -->
-
-Then try `@bs.uncurry`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.send] external map: (array('a), [@bs.uncurry] ('a => 'b)) => array('b) = "map";
-map([|1, 2, 3|], x => x + 1);
-```
-```ml
-external map: 'a array -> (('a -> 'b) [@bs.uncurry]) -> 'b array = "map" [@@bs.send]
-let _ = map [|1; 2; 3|] (fun x -> x + 1)
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-In general, `bs.uncurry` is recommended; the compiler will do lots of optimizations to resolve the currying to uncurrying at compile time. However, there are some cases the compiler can't optimize it. In these cases, it will be converted to a runtime check.
-
-## Modeling `this`-based Callbacks
-
-Many JS libraries have callbacks which rely on this (the source), for example:
-
-```js
-x.onload = function(v) {
-  console.log(this.response + v)
-}
-```
-
-Here, `this` would point to `x` (actually, it depends on how `onload` is called, but we digress). It's not correct to declare `x.onload` of type `(. unit) -> unit`. Instead, we introduced a special attribute, `bs.this`, which allows us to type `x` as so:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type x;
-[@bs.val] external x: x = "x";
-[@bs.set] external setOnload: (x, [@bs.this] ((x, int) => unit)) => unit = "onload";
-[@bs.get] external resp: x => int = "response";
-setOnload(x, [@bs.this] ((o, v) => Js.log(resp(o) + v)));
-```
-```ml
-type x
-external x: x = "x" [@@bs.val]
-external setOnload: x -> ((x -> int -> unit) [@bs.this]) -> unit = "onload" [@@bs.set]
-external resp: x -> int = "response" [@@bs.get]
-let _ = setOnload x ((fun o v -> Js.log ((resp o) + v)) [@bs.this])
-```
-```js
-x.onload = function (v) {
-  var o = this;
-  console.log((o.response + v) | 0);
-};
-```
-
-</CodeTab>
-
-`bs.this` has its first parameter is reserved for `this` and for arity of 0, there is no need for a redundant `unit` type.
-
-## Function Nullable Return Value Wrapping
-
-For JS functions that return a value that can also be `undefined` or `null`, we provide `[@bs.return ...]`. To automatically convert that value to an `option` type (recall that ReScript `option` type's `None` value only compiles to `undefined` and not `null`).
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type element;
-type dom;
-
-[@bs.send] [@bs.return nullable]
-external getElementById: (dom, string) => option(element) = "getElementById";
-
-let test = dom => {
-  let elem = dom->(getElementById("haha"))
-  switch (elem) {
-  | None => 1
-  | Some(_ui) => 2
-  }
-};
-```
-```ml
-type element
-type dom
-external getElementById : dom -> string -> element option = "getElementById"
-[@@bs.send][@@bs.return nullable]
-
-let test dom =
-  let elem = dom |. (getElementById "haha") in
-  match elem with
-  | None -> 1
-  | Some _ui -> 2
-```
-```js
-function test(dom) {
-  var elem = dom.getElementById("haha");
-  if (elem == null) {
-    return 1;
-  } else {
-    console.log(elem);
-    return 2;
-  }
-}
-
-```
-
-</CodeTab>
-
-`bs.return(nullable)` attribute will automatically convert `null` and `undefined` to `option` type.
-
-Currently 4 directives are supported: `null_to_opt`, `undefined_to_opt`, `nullable` and `identity`.
-
-<!-- When the return type is unit: the compiler will append its return value with an OCaml unit literal to make sure it does return unit. Its main purpose is to make the user consume FFI in idiomatic OCaml code, the cost is very very small and the compiler will do smart optimizations to remove it when the returned value is not used (mostly likely). -->
-
-`identity` will make sure that compiler will do nothing about the returned value. It is rarely used, but introduced here for debugging purpose.
diff --git a/pages/docs/manual/v8.0.0/bind-to-js-object.mdx b/pages/docs/manual/v8.0.0/bind-to-js-object.mdx
deleted file mode 100644
index ea72db842..000000000
--- a/pages/docs/manual/v8.0.0/bind-to-js-object.mdx
+++ /dev/null
@@ -1,202 +0,0 @@
----
-title: "Bind to JS Object"
-description: "Interop with JS objects in ReScript"
-canonical: "/docs/manual/latest/bind-to-js-object"
----
-
-# Bind to JS Object
-
-JavaScript objects are a combination of several use-cases:
-
-- As a "record" or "struct" in other languages (like ReScript and C).
-- As a hash map.
-- As a class.
-- As a module to import/export.
-
-ReScript cleanly separates the binding methods for JS object based on these 4 use-cases. This page documents the first three. Binding to JS module objects is described in the [Import from/Export to JS](import-from-export-to-js.md) section.
-
-<!-- TODO: mention bs.scope here too? -->
-
-## Bind to Record-like JS Objects
-
-### Bind Using ReScript Record
-
-If your JavaScript object has fixed fields, then it's conceptually like a ReScript record. Since a ReScript record compiles to a clean JavaScript object, you can definitely type a JS object as a ReScript record!
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type person = {
-  name: string,
-  friends: array(string),
-  age: int,
-};
-
-[@bs.module "MySchool"] external john: person = "john";
-
-let johnName = john.name;
-```
-```ml
-type person = {
-  name: string;
-  friends: string array;
-  age: int;
-}
-
-external john: person = "john" [@@bs.module "MySchool"]
-
-let johnName = john.name
-```
-```js
-var MySchool = require("MySchool");
-
-var johnName = MySchool.john.name;
-```
-
-</CodeTab>
-
-External is documented [here](external.md). `@bs.module` is documented [here](import-from-export-to-js.md).
-
-### Bind Using ReScript Object
-
-Alternatively, you can use [ReScript object](object.md) to model a JS object too:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type person = {
-  .
-  "name": string,
-  "friends": array(string),
-  "age": int,
-};
-
-[@bs.module "MySchool"] external john: person = "john";
-
-let johnName = john##name;
-```
-```ml
-type person = <
-  name: string;
-  friends: string array;
-  age: int
-> Js.t
-
-external john: person = "john" [@@bs.module "MySchool"]
-
-let johnName = ## john name
-```
-```js
-var MySchool = require("MySchool");
-
-var johnName = MySchool.john.name;
-```
-
-</CodeTab>
-
-### Bind Using Special `@bs` Getters & Setters
-
-Alternatively, you can use `bs.get` and `bs.set` to bind to individual fields of a JS object:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type textarea;
-[@bs.set] external setName: (textarea, string) => unit = "name";
-[@bs.get] external getName: textarea => string = "name";
-```
-```ml
-type textarea;
-external setName: textarea -> string -> unit = "name" [@@bs.set]
-external getName: textarea -> string = "name" [@@bs.get]
-```
-```js
-```
-
-</CodeTab>
-
-You can also use `bs.get_index` and `bs.set_index` to access a dynamic property or an index:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type t;
-[@bs.new] external create: int => t = "Int32Array";
-[@bs.get_index] external get: (t, int) => int = "";
-[@bs.set_index] external set: (t, int, int) => unit = "";
-
-let i32arr = create(3);
-i32arr->set(0, 42);
-Js.log(i32arr->get(0));
-```
-```ml
-type t
-external create: int -> t = "Int32Array" [@@bs.new]
-external get: t -> int -> int = "" [@@bs.get_index]
-external set: t -> int -> int -> unit = "" [@@bs.set_index]
-
-let i32arr = create 3
-let () = i32arr |. (set 0 42)
-let () = Js.log (i32arr |. (get 0))
-```
-```js
-var i32arr = new Int32Array(3);
-i32arr[0] = 42;
-console.log(i32arr[0]);
-```
-
-</CodeTab>
-
-## Bind to Hash Map-like JS Object
-
-If your JavaScript object:
-
-- might or might not add/remove keys
-- contains only values that are of the same type
-
-Then it's not really an object, it's a hash map. Use [Js.Dict](api/js/dict), which contains operations like `get`, `set`, etc. and cleanly compiles to a JavaScript object still.
-
-## Bind to a JS Object That's a Class
-
-Use `bs.new` to emulate e.g. `new Date()`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type t;
-[@bs.new] external createDate: unit => t = "Date";
-
-let date = createDate();
-```
-```ml
-type t
-external createDate: unit -> t = "Date" [@@bs.new]
-
-let date = createDate ()
-```
-```js
-var date = new Date();
-```
-
-</CodeTab>
-
-You can chain `bs.new` and `bs.module` if the JS module you're importing is itself a class:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type t;
-[@bs.new] [@bs.module] external book: unit => t = "Book";
-let myBook = book();
-```
-```ml
-type t
-external book: unit -> t = "Book" [@@bs.new][@@bs.module]
-let myBook = book ()
-```
-```js
-var Book = require("Book");
-var myBook = new Book();
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v8.0.0/browser-support-polyfills.mdx b/pages/docs/manual/v8.0.0/browser-support-polyfills.mdx
deleted file mode 100644
index c1de7a491..000000000
--- a/pages/docs/manual/v8.0.0/browser-support-polyfills.mdx
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: "Browser Support & Polyfills"
-description: "Note on browser support in ReScript"
-canonical: "/docs/manual/latest/browser-support-polyfills"
----
-
-# Browser Support & Polyfills
-
-ReScript compiles to JavaScript **ES5**, with the exception of optionally allowing to compile to ES6's module import & export.
-
-For [old browsers](https://caniuse.com/#search=typed%20array), you also need to polyfill TypedArray. The following standard library functions require it:
-
-- `Int64.float_of_bits`
-- `Int64.bits_of_float`
-- `Int32.float_of_bits`
-- `Int32.bits_of_float`
-
-If you don't use these functions, you're fine. Otherwise, it'll be a runtime failure.
diff --git a/pages/docs/manual/v8.0.0/build-configuration.mdx b/pages/docs/manual/v8.0.0/build-configuration.mdx
deleted file mode 100644
index 4d7938592..000000000
--- a/pages/docs/manual/v8.0.0/build-configuration.mdx
+++ /dev/null
@@ -1,179 +0,0 @@
----
-title: "Build System Configuration"
-description: "Details about the configuration of the ReScript build system (bsconfig.json)"
-canonical: "/docs/manual/latest/build-configuration"
----
-
-# Configuration
-
-`bsconfig.json` is the single, mandatory build meta file needed for bsb.
-
-**The complete configuration schema is [here](https://bucklescript.github.io/bucklescript/docson/#build-schema.json)**. We'll _non-exhaustively_ highlight the important parts in prose here.
-
-## name, namespace
-
-`name` is the name of the library, used as its "namespace". You can activate namespacing through `"namespace": true` in your `bsconfig.json`. Namespacing is almost **mandatory**; we haven't turned it on by default yet to preserve backward-compatibility.
-
-**Explanation**: by default, your files, once used as a third-party dependency, are available globally to the consumer. E.g. if you have an `Util.re` and the consumer also has a file of the same name, they will clash. Turning on `namespace` avoids this by wrapping all your own project's files into an extra module layer; instead of a global `Util` module, the consumer will see you as `MyProject.Util`. **The namespacing affects your consumers, not yourself**.
-
-Aka, in Bsb, "namespace" is just a fancy term for an auto-generated module that wraps all your project's files (efficiently and correctly, of course!) for third-party consumption.
-
-We don't do folder-level namespacing for your own project; all your own file names must be unique. This is a constraint that enables several features such as fast search and easier project reorganization.
-
-**Note**: the `bsconfig.json` `name` should be the same as the `package.json` `name`, to avoid confusing corner-cases. However, this means that you can't use a camelCased names such as `MyProject`, since `package.json` and npm forbid you to do so (some file systems are case-insensitive). To have the namespace/module as `MyProject`, write `"name": "my-project"`. Bsb will turn that into the camelCased name correctly.
-
-**Note on custom namespacing**: if for some reason, you need a namespace that is different from what your `name` will produce, you can directly send a string to the `namespace` option. For example, if your package is a binding named `bs-some-thing`, you can use `"namespace": "some-thing"` to get `SomeThing` namespace instead of `BsSomeThing`.
-
-## sources
-
-Your source files need to be specified explicitly (we don't want to accidentally drill down into some unrelated directories). Examples:
-
-```json
-{
-  "sources": ["src", "examples"]
-}
-```
-
-```json
-{
-  "sources": {
-    "dir": "src",
-    "subdirs": ["page"]
-  }
-}
-```
-
-```json
-{
-  "sources": [
-    "examples",
-    {
-      "dir": "src",
-      "subdirs": true // recursively builds every subdirectory
-    }
-  ]
-}
-```
-
-You can mark your directories as dev-only (for e.g. tests). These won't be built and exposed to third-parties, or even to other "dev" directories in the same project:
-
-```json
-{
-  "sources": {
-    "dir": "test",
-    "type": "dev"
-  }
-}
-```
-
-## bs-dependencies, bs-dev-dependencies
-
-List of ReScript dependencies. Just like `package.json`'s dependencies, they'll be searched in `node_modules`.
-
-Note that only sources marked with `"type":"dev"` will be able to resolve modules from `bs-dev-dependencies`.
-
-## reason, refmt (old)
-
-`reason` config is enabled by default. To turn on JSX for [ReasonReact](https://reasonml.github.io/reason-react/en/), specify:
-
-```json
-{
-  "reason": { "react-jsx": 3 },
-  "refmt": 3
-}
-```
-
-The `refmt` config **should be explicitly specified** as `3`.
-
-## js-post-build
-
-Hook that's invoked every time a file is recompiled. Good for JS build system interop, but please use it **sparingly**. Calling your custom command for every recompiled file slows down your build and worsens the building experience for even third-party users of your lib.
-
-Example:
-
-```json
-{
-  "js-post-build": {
-    "cmd": "/path/to/node ../../postProcessTheFile.js"
-  }
-}
-```
-
-Note that the command's path resolution is done through the following:
-
-- `/myCommand` is resolved into `/myCommand`
-- `myCommand/` is resolved into `node_modules/myCommand`
-- `./myCommand` is resolved into `myProjectRoot/myCommand`
-- `myCommand` is just called as `myCommand`. But note that Bsb doesn't read into your environment, so if you put `node`, it won't find it unless you specify an absolute path. Alternatively, point to a script that has the header `#!/usr/local/bin/node`.
-
-The command itself is called from inside `lib/bs`.
-
-## package-specs
-
-Output to either CommonJS (the default) or ES6 modules. Example:
-
-```json
-{
-  "package-specs": {
-    "module": "commonjs",
-    "in-source": true
-  }
-}
-```
-
-- `"module": "es6-global"` resolves `node_modules` using relative paths. Good for development-time usage of ES6 in conjunction with browsers like Safari and Firefox that support ES6 modules today. **No more dev-time bundling**!
-- `"in-source": true` generates output alongside source files. If you omit it, it'll generate the artifacts into `lib/js`. The output directory is not configurable otherwise.
-
-This configuration only applies to you, when you develop the project. When the project is used as a third-party library, the consumer's own `bsconfig.json` `package-specs` overrides the configuration here, logically.
-
-## suffix
-
-Either `".js"` or `".bs.js"`. Strongly prefer the latter.
-
-### Design Decisions
-
-Generating JS files with the `.bs.js` suffix means that, on the JS side, you can do `const myReScriptFile = require('./theFile.bs')`. The benefits:
-
-- It's immediately clear that we're dealing with a generated JS file here.
-- It avoids clashes with a potential `theFile.js` file in the same folder.
-- It avoids the need of using a build system loader for ReScript files. This + in-source build means integrating a ReScript project into your pure JS codebase **basically doesn't touch anything in your build pipeline at all**.
-- The `.bs.js` suffix [lets bsb track JS artifacts much better](build-overview.md#tips-tricks).
-
-## warnings
-
-Selectively turn on/off certain warnings and/or turn them into hard errors. Example:
-
-```json
-{
-  "warnings": {
-    "number": "-44-102",
-    "error": "+5"
-  }
-}
-```
-
-Turn off warning `44` and `102` (polymorphic comparison). Turn warning `5` (partial application whose result has function type and is ignored) into a hard error.
-
-The warning number are shown in the build output when they're triggered. The complete list is [here](https://caml.inria.fr/pub/docs/manual-ocaml/comp.html#sec281), a little bit below. `100` and up are ReScript-specific.
-
-## bsc-flags
-
-Extra flags to pass to the underlying `bsc` call. Notably: `["-bs-super-errors"]` for turning on cleaner error output. No need to pass this flag for a new ReScript project; it's enabled by default.
-
-## Environment Variables
-
-We heavily disrecommend the usage of environment variables, but for certain cases, they're justified.
-
-### Error Output Coloring: `NINJA_ANSI_FORCED`
-
-This is mostly for other programmatic usage of `bsb` where outputting colors is not desired.
-
-When `NINJA_ANSI_FORCED` is set to `1`: `bsb` produces color.
-When `NINJA_ANSI_FORCED` is set to `0`: `bsb` doesn't produce color.
-When `NINJA_ANSI_FORCED` is not set: `bsb` might or might not produce color, depending on a smart detection of where it's outputted.
-
-> Note that bsc, the barebone compiler, will always be passed `-color always`. See more details in [this issue](https://github.com/rescript-lang/rescript/issues/2984#issuecomment-410669163).
-
-### BS_VSCODE error output adapted for VSCODE
-
-If you run bsb under VSCODE task runner like [this](https://github.com/rescript-lang/rescript/blob/master/jscomp/bsb/templates/basic-reason/.vscode/tasks.json#L6), it is recommended to have BS_VSCODE set
diff --git a/pages/docs/manual/v8.0.0/build-overview.mdx b/pages/docs/manual/v8.0.0/build-overview.mdx
deleted file mode 100644
index 0d8fc9c61..000000000
--- a/pages/docs/manual/v8.0.0/build-overview.mdx
+++ /dev/null
@@ -1,64 +0,0 @@
----
-title: "Build System Overview"
-description: "Documentation about the ReScript build system and its toolchain"
-canonical: "/docs/manual/latest/build-overview"
----
-
-# Build System Overview
-
-ReScript comes with a build system, bsb, that's meant to be fast, lean and used as the authoritative build system of the community.
-
-Bsb provides a few templates to quickly start a new project:
-
-```sh
-bsb -init my-directory-name
-```
-
-Feel free to inspect the various files in the newly generated directory. To see all the templates available, do:
-
-```sh
-bsb -themes
-```
-
-The build description file is called `bsconfig.json`. Every ReScript project needs one.
-
-**To build a project**, run:
-
-```sh
-bsb -make-world
-```
-
-Add `-w` to keep the built-in watcher running. Any new file change will be picked up and the build will re-run.
-
-**Note**: third-party libraries (in `node_modules`) aren't watched, as doing so may exceed the node.js watcher count limit. If you're doing quick and dirty modifications inside `node_modules`, you have to do `bsb -clean-world -make-world` to rebuild them.
-
-**Note 3**: If you are developing across multiple devices, you may find the `-ws` configuration useful in order to have live-reloading across the network. Possible configurations are:
-- `bsb -make-world -w -ws _` (default)
-- `bsb -make-world -w -ws 0.0.0.0:9999`
-- `bsb -make-world -w -ws 5000`
-
-**To build only yourself**, use `bsb -make`.
-
-`bsb -help` to see all the available options.
-
-## Artifacts Cleaning
-
-If you ever get into a stable build for edge-case reasons, use:
-
-```sh
-bsb -clean-world
-```
-
-Or `bsb -clean` to clean only your own artifacts.
-
-## Editor Support
-
-Bsb generates a `.merlin` file, used by various [editor plugins](editor-plugins.md) under the hood to power e.g. autocomplete, type hint, diagnosis, etc.
-
-### Tips & Tricks
-
-A typical problem with traditional build systems is that they're not resilient against the user moving/deleting source files. Most don't clean up the old artifacts correctly after such user action\*. Bsb is unfortunately no different, **unless** you turn on `"suffix": ".bs.js"` in `bsconfig.json`, in which case we can track which JS artifact belongs to which source file correctly, even against source file moving/deletion.
-
-## Design Decisions
-
-\* One such build system that tracks these correctly & efficiently is [Tup](http://gittup.org/tup/). See the (rather accessible!) paper [here](http://gittup.org/tup/build_system_rules_and_algorithms.pdf). Unfortunately, Tup's implementation uses FUSE and other systems, which we can't safely use on every platform.
diff --git a/pages/docs/manual/v8.0.0/build-performance.mdx b/pages/docs/manual/v8.0.0/build-performance.mdx
deleted file mode 100644
index 595213534..000000000
--- a/pages/docs/manual/v8.0.0/build-performance.mdx
+++ /dev/null
@@ -1,88 +0,0 @@
----
-title: "Build Performance"
-description: "ReScript build performance and measuring tools"
-canonical: "/docs/manual/latest/build-performance"
----
-
-# Build Performance
-
-ReScript considers performance at install time, build time and run time as a serious feature. Here are some more info, and tips on keeping the build fast. **Feel free to skip this section** if you're just starting out.
-
-## Profile Your Build
-
-Sometime your build can be slow due to some confused infra setups. We provide an interactive visualization of your build's performance via `bstracing`:
-
-```sh
-./node_modules/.bin/bstracing
-```
-
-Run the above command at your ReScript project's root; it'll spit out a JSON file you can drag and drop into `chrome://tracing`.
-
-import Image from "src/components/Image";
-
-<Image withShadow={true} src="/static/img/bstracing.png" caption="Screenshot of bstracing result"/>
-
-## Under the Hood
-
-Bsb itself uses a build system under the hood, called [Ninja](https://ninja-build.org). Ninja is like Make, but cross-platform, minimal, focuses in perf and destined to be more of a low-level building block than a full-blown build system. In this regard, Ninja's a great implementation detail for bsb.
-
-Bsb reads into `bsconfig.json` and generates the Ninja build file in `lib/bs`. The file contains the low-level `bsc`-related commands, namespacing rules, intermediate artifacts generation & others. It then runs `ninja` for the actual build.
-
-## The JS Wrapper
-
-`bsb` itself is a Node.js wrapper which takes care of some miscellaneous tasks, plus the watcher. The lower-level, watcher-less, true `bsb` is called `bsb.exe`. It can be located in the same directory as where `bsb` is found:
-
-```sh
-> bsb -where
-/usr/local/lib/node_modules/bs-platform/lib
-```
-
-The path varies across systems.
-
-If you don't need the watcher, you can run said `bsb.exe`: `/usr/local/lib/node_modules/bs-platform/lib/bsb.exe`. This side-steps the node.js startup time, which can be big (in the order of `100ms`).
-
-## Numbers
-
-Raw `bsb.exe` build on a small project should be around `70ms`. This doubles when you use the more common `bsb` wrapper which comes with a watcher, which is practically faster since you don't manually run the build at every change (though you should opt for the raw `bsb.exe` for programmatic usage, e.g. inserting bsb into your existing JS build pipeline).
-
-No-op build (when no file's changed) should be around `15ms`. Incremental rebuild (described soon) of a single file in a project is around `70ms` too.
-
-Cleaning the artifacts should be instantaneous.
-
-### Extreme Test
-
-We've stress-tested bsb on a big project of 10,000 files (2 directories, 5000 files each, first 5000 no dependencies, last 5000 10 dependencies on files from the former directory) using https://github.com/ocaml-omake/omake/blob/perf-test/performance/generate.ml, on Retina Macbook Pro Early 2015 (3.1 GHz Intel Core i7).
-
-<!-- TODO: better repro -->
-
-- No-op build of 10k files: `800ms` (the minimum amount of time required to check the mtimes of 10k files).
-- Clean build: \<3 minutes.
-- Incremental build: depends on the number of the dependents of the file. No dependent means `1s`.
-
-Note that bsb is a file-based build system. We don't do in-memory build, even if that speeds up the build a lot. In-memory builds risk memory leaks, out-of-memory errors and others. The bsb watcher, on the other hand, can stay open for days.
-
-## Incrementality
-
-Bsb doesn't take whole seconds to run every time. The bulk of the build performance comes from incremental build, aka re-building a previously built project when a few files changed.
-
-In short, thanks to our bsc compiler and bsb build system's architecture, we're able to **only build what's needed**. E.g. if `MyFile.res` isn't changed, then it's not recompiled. You can roughly emulate such incrementality in languages like JavaScript, but the degree of correctness is unfortunately low. For example, if you rename or move a JS file, then the watcher might get confused and not pick up the "new" file or fail to clean things up correctly, resulting in you needing to clean your build and restart anew, which defeats the purpose.
-
-## Speed Up Incremental Build
-
-ReScript uses the concept of interface files (`.rei`) (or, equivalently, [module signatures](module.md#signatures)). Exposing only what you need naturally speeds up incremental builds. E.g. if you change a `.re` file whose corresponding `.rei` file doesn't expose the changed part, then you've reduced the amount of dependent files you have to rebuild.
-
-<!-- TODO: validate this -->
-
-## Programmatic Usage
-
-Unfortunately, JS build systems are usually the bottleneck for building a JS project nowadays. Having parts of the build blazingly fast doesn't matter much if the rest of the build takes seconds or literally minutes. Here are a few suggestions:
-
-- Convert more files into ReScript =). Fewer files going through fewer parts of the JS pipeline helps a ton.
-- Careful with bringing in more dependencies: libraries, syntax transforms, build step loaders, etc. The bulk of these dragging down the editing & building experience might out-weight the API benefits they provide.
-- Wait for us to create our own super fast linker (aka bundler).
-
-## Hot Reloading
-
-Hot reloading refers to maintaining a dev server and listening to file changes in a way that allows the server to pipe some delta changes right into the currently running browser page. This provides a relatively fast iteration workflow while working in specific frameworks.
-
-However, hot reloading is fragile by nature, and counts on the occasional inconsistencies (bad state, bad eval, etc.) and the heavy devserver setup/config being less of a hassle than the benefits it provides. We err on the side of caution and stability in general, and decided not to provide a built-in hot reloading _yet_. **Note**: you can still use the hot reloading facility provided by your JS build pipeline.
diff --git a/pages/docs/manual/v8.0.0/control-flow.mdx b/pages/docs/manual/v8.0.0/control-flow.mdx
deleted file mode 100644
index 40f557bca..000000000
--- a/pages/docs/manual/v8.0.0/control-flow.mdx
+++ /dev/null
@@ -1,267 +0,0 @@
----
-title: "If-Else & Loops"
-description: "If, else, ternary, for, and while"
-canonical: "/docs/manual/latest/control-flow"
----
-
-# If-Else & Loops
-
-ReScript supports `if`, `else`, ternary expression (`a ? b : c`), `for` and `while`.
-
-ReScript also supports our famous pattern matching, which will be covered in [its own section](pattern-matching-destructuring.md)
-
-## If-Else & Ternary
-
-Unlike its JavaScript counterpart, ReScript's `if` is an expression; they evaluate to their body's content:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let message = if (isMorning) {
-  "Good morning!"
-} else {
-  "Hello!"
-};
-```
-```ml
-let message =
-  if isMorning then
-    "Good morning!"
-  else
-    "Hello!"
-```
-```js
-var message = isMorning ? "Good morning!" : "Hello!";
-```
-
-</CodeTab>
-
-**Note:** an `if-else` expression without the final `else` branch implicitly gives `()` (aka the `unit` type). So this:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-if (showMenu) {
-  displayMenu();
-};
-```
-```ml
-if showMenu then
-  displayMenu ()
-```
-```js
-if (showMenu) {
-  displayMenu();
-}
-```
-
-</CodeTab>
-
-is basically the same as:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-if (showMenu) {
-  displayMenu();
-} else {
-  ();
-};
-```
-```ml
-if showMenu then
-  displayMenu ()
-else
-  ()
-```
-```js
-if (showMenu) {
-  displayMenu()
-}
-```
-
-</CodeTab>
-
-Here's another way to look at it. This is clearly wrong:
-
-```re
-let result = if (showMenu) {
-  1 + 2;
-};
-```
-
-It'll give a type error, saying basically that the implicit `else` branch has the type `unit` while the `if` branch has type `int`. Intuitively, this makes sense: what would `result`'s value be, if `showMenu` was `false`?
-
-We also have ternary sugar, but **we encourage you to prefer if-else when possible**.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let message = isMorning ? "Good morning!" : "Hello!"
-```
-```ml
-(* Doesn't exist in older ML syntax *)
-```
-```js
-var message = isMorning ? "Good morning!" : "Hello!";
-```
-
-</CodeTab>
-
-**`if-else` and ternary are much less used** in ReScript than in other languages; [Pattern-matching](pattern-matching-destructuring.md) kills a whole category of code that previously required conditionals.
-
-## For Loops
-
-For loops iterate from a starting value up to (and including) the ending value.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-for (i in startValueInclusive to endValueInclusive) {
-  Js.log(i);
-};
-```
-```ml
-for i = startValueInclusive to endValueInclusive do
-  Js.log i
-done
-```
-```js
-for(var i = startValueInclusive; i <= endValueInclusive; ++i){
-  console.log(i);
-}
-```
-
-</CodeTab>
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-// prints: 1 2 3, one per line
-for (x in 1 to 3) {
-  Js.log(x);
-};
-```
-```ml
-(* prints: 1 2 3, one per line *)
-for x = 1 to 3 do
-  Js.log x;
-done
-```
-```js
-for(var x = 1; x <= 3; ++x){
-  console.log(x);
-}
-```
-
-</CodeTab>
-
-You can make the `for` loop count in the opposite direction by using `downto`.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-for (i in startValueInclusive downto endValueInclusive) {
-  Js.log(i);
-};
-```
-```ml
-for i = startValueInclusive downto endValueInclusive do
-  Js.log i
-done
-```
-```js
-for(var i = startValueInclusive; i >= endValueInclusive; --i){
-  console.log(i);
-}
-```
-
-</CodeTab>
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-// prints: 3 2 1, one per line
-for (x in 3 downto 1) {
-  Js.log(x);
-};
-```
-```ml
-(* prints: 3 2 1, one per line)
-for x = 3 downto 1 do
-  Js.log x;
-done
-```
-```js
-for(var x = 3; x >= 1; --x){
-  console.log(x);
-}
-```
-
-</CodeTab>
-
-## While Loops
-
-While loops execute its body code block while its condition is true.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-while (testCondition) {
-  // body here
-};
-```
-```ml
-while testCondition do
-  (* body here *)
-done
-```
-```js
-while (testCondition) {
-  // body here
-}
-```
-
-</CodeTab>
-
-### Tips & Tricks
-
-There's no loop-breaking `break` keyword (nor early `return` from functions, for that matter) in ReScript. However, we can break out of a while loop easily through using a [mutable binding](mutation.md).
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let break = ref(false);
-
-while (!break.contents) {
-  if (Js.Math.random() > 0.3) {
-    break := true;
-  } else {
-    Js.log("Still running");
-  };
-};
-```
-```ml
-let () = break <- ref false
-let () = while not break.contents do
-  if (Js.Math.random ()) > 0.3 then
-    break := true
-  else
-    Js.log "Still running"
-done
-```
-```js
-var $$break = {
-  contents: false
-};
-
-while(!$$break.contents) {
-  if (Math.random() > 0.3) {
-    $$break.contents = true;
-  } else {
-    console.log("Still running");
-  }
-};
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v8.0.0/converting-from-js.mdx b/pages/docs/manual/v8.0.0/converting-from-js.mdx
deleted file mode 100644
index 54cf9337c..000000000
--- a/pages/docs/manual/v8.0.0/converting-from-js.mdx
+++ /dev/null
@@ -1,390 +0,0 @@
----
-title: "Converting from JS"
-description: "How to convert to ReScript with an existing JS codebase"
-canonical: "/docs/manual/latest/converting-from-js"
----
-
-# Converting from JS
-
-ReScript offers a unique project conversion methodology which:
-- Ensures minimal disruption to your teammates (very important!).
-- Remove the typical friction of verifying conversion's correctness and performance guarantees.
-- Doesn't force you to search for pre-made binding libraries made by others. **ReScript doesn't need the equivalent of TypeScript's `DefinitelyTyped`**.
-
-Enjoy!
-
-## Step 1: Install ReScript
-
-Run `npm install --save-dev bs-platform` on your project, then imitate our [New Project](installation#new-project) workflow by adding a `bsconfig.json` at the root. Then start `bsb -w`.
-
-## Step 2: Copy Paste the Entire JS File
-
-Let's work on converting a file called `src/main.js`.
-
-```js
-const school = require('school');
-
-const defaultId = 10;
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-```
-
-First, copy the entire file content over to a new file called `src/Main.res` by using our [`%%raw` JS embedding trick](embed-raw-javascript):
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[%%raw "
-const school = require('school');
-
-const defaultId = 10;
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-"]
-```
-```ml
-[%%raw "
-const school = require('school');
-
-const defaultId = 10;
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-"]
-```
-```js
-// Generated by BUCKLESCRIPT, PLEASE EDIT WITH CARE
-'use strict';
-
-const school = require('school');
-
-const defaultId = 10;
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-
-/*  Not a pure module */
-```
-
-</CodeTab>
-
-Add this file to `bsconfig.json`:
-
-```json
-  "sources": {
-    "dir" : "src",
-    "subdirs" : true
-  },
-```
-
-Open an editor tab for `src/Main.bs.js`. Do a command-line `diff -u src/main.js src/Main.bs.js`. Aside from whitespaces, you should see only minimal, trivial differences. You're already a third of the way done!
-
-**Always make sure** that at each step, you keep the ReScript output `.bs.js` file open to compare against the existing JavaScript file. Our compilation output is very close to your hand-written JavaScript; you can simply eye the difference to catch conversion bugs!
-
-## Step 3: Extract Parts into Idiomatic ReScript
-
-Let's turn the `defaultId` variable into a ReScript let-binding:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let defaultId = 10;
-
-[%%raw "
-const school = require('school');
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-"]
-```
-```ml
-let defaultId = 10
-
-[%%raw "
-const school = require('school');
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-"]
-```
-```js
-// Generated by BUCKLESCRIPT, PLEASE EDIT WITH CARE
-'use strict';
-
-const school = require('school');
-
-function queryResult(usePayload, payload) {
-  if usePayload {
-    return payload.student
-  } else {
-    return school.getStudentById(defaultId)
-  }
-}
-
-var defaultId = 10;
-
-exports.defaultId = defaultId;
-/*  Not a pure module */
-```
-
-</CodeTab>
-
-Check the output. Diff it. Code still works. Moving on! Extract the function:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[%%raw "
-const school = require('school');
-"]
-
-let defaultId = 10;
-
-let queryResult = (usePayload, payload) => {
-  if (usePayload) {
-    payload.student;
-  } else {
-    school.getStudentById(defaultId);
-  }
-};
-```
-```ml
-[%%raw "
-const school = require('school');
-"]
-
-let defaultId = 10
-
-let queryResult usePayload payload =
-  if usePayload then
-    payload.student
-  else
-    school.getStudentById(defaultId)
-```
-```js
-```
-
-</CodeTab>
-
-Format the code: `./node_modules/.bin/bsc -format src/Main.res`.
-
-We have a type error: "The record field student can't be found". That's fine! **Always ensure your code is syntactically valid first**. Fixing type errors comes later.
-
-## Step 4: Add `external`s, Fix Types
-
-The previous type error is caused by `payload`'s record declaration (which supposedly contains the field `student`) not being found. Since we're trying to convert as quickly as possible, let's use our [object](object) feature to avoid needing type declaration ceremonies:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[%%raw "
-const school = require('school');
-"]
-
-let defaultId = 10;
-
-let queryResult = (usePayload, payload) => {
-  if (usePayload) {
-    payload##student;
-  } else {
-    school##getStudentById(defaultId);
-  }
-}
-```
-```ml
-[%%raw "
-const school = require('school');
-"]
-
-let defaultId = 10
-
-let queryResult usePayload payload =
-  if usePayload then
-    payload##student
-  else
-    school##getStudentById defaultId
-```
-```js
-```
-
-</CodeTab>
-
-Now this triggers the next type error, that `school` isn't found. Let's use [`external`](external) to bind to that module:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.module] external school: 'whatever = "school";
-
-let defaultId = 10;
-
-let queryResult = (usePayload, payload) => {
-  if usePayload {
-    payload##student;
-  } else {
-    school##getStudentById(defaultId);
-  }
-}
-```
-```ml
-external school: 'whatever = "school" [@@bs.module]
-
-let defaultId = 10
-
-let queryResult usePayload payload =
-  if usePayload then
-    payload##student
-  else
-    school##getStudentById defaultId
-```
-```js
-// Generated by BUCKLESCRIPT, PLEASE EDIT WITH CARE
-'use strict';
-
-var School = require("school");
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return School.getStudentById(10);
-  }
-}
-
-var defaultId = 10;
-
-exports.defaultId = defaultId;
-exports.queryResult = queryResult;
-/* school Not a pure module */
-```
-
-</CodeTab>
-
-We hurrily typed `school` as a polymorphic `'whatever` and let its type be inferred by its usage below. The inference is technically correct, but within the context of bringing it a value from JavaScript, slightly dangerous. This is just the interop trick we've shown in the [`external`](external) page.
-
-Anyway, the file passes the type checker again. Check the `.bs.js` output, diff with the original `.js`; we've now converted a file over to ReScript!
-
-Now, you can delete the original, hand-written `main.js` file, and grep the files importing `main.js` and change them to importing `Main.bs.js`.
-
-## (Optional) Step 5: Cleanup
-
-If you prefer more advanced, rigidly typed `payload` and `school`, feel free to do so:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type school;
-type student;
-type payload = {
-  student: student
-};
-
-[@bs.module] external school: school = "school";
-[@bs.send] external getStudentById: (school, int) => student = "getStudentById";
-
-let defaultId = 10;
-
-let queryResult = (usePayload, payload) => {
-  if (usePayload) {
-    payload.student;
-  } else {
-    school->getStudentById(defaultId);
-  }
-}
-```
-```ml
-type school
-type student
-type payload = {
-  student: student
-}
-
-external school: school = "school" [@@bs.module]
-external getStudentById: school -> int -> student = "getStudentById" [@@bs.send]
-
-let defaultId = 10
-
-let queryResult usePayload payload =
-  if usePayload then
-    payload.student
-  else
-    school |. (getStudentById defaultId)
-```
-```js
-// Generated by BUCKLESCRIPT, PLEASE EDIT WITH CARE
-'use strict';
-
-var School = require("school");
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return School.getStudentById(10);
-  }
-}
-
-var defaultId = 10;
-
-exports.defaultId = defaultId;
-exports.queryResult = queryResult;
-/* school Not a pure module */
-```
-
-</CodeTab>
-
-We've:
-- introduced an opaque types for `school` and `student` to prevent misusages their values
-- typed the payload as a record with only the `student` field
-- typed `getStudentById` as the sole method of `student`
-
-Check that the `.bs.js` output didn't change. How rigidly to type your JavaScript code is up to you; we recommend not typing them too elaborately; it's sometime an endless chase, and produces diminishing returns, especially considering that the elaborate-ness might turn off your potential teammates.
-
-## Tips & Tricks
-
-In the same vein of idea, **resist the urge to write your own wrapper functions for the JS code you're converting**. Use [`external`s](external), which are guaranteed to be erased in the output. And avoid trying to take the occasion to convert JS data structures into ReScript-specific data structures like variant or list. **This isn't the time for that**.
-
-The moment you produce extra conversion code in the output, your skeptical teammate's mental model might switch from "I recognize this output" to "this conversion might be introducing more problems than it solves. Why are we testing ReScript again?". Then you've lost.
-
-## Conclusion
-
-- Paste the JS code into a new ReScript file as embedded raw JS code.
-- Compile and keep the output file open. Check and diff against original JS file. Free regression tests.
-- Always make sure your file is syntactically valid. Don't worry about fixing types before that.
-- (Ab)use [object](object.md) accesses to quickly convert things over.
-- Optionally clean up the types for robustness.
-- Don't go overboard and turn off your boss and fellow teammates.
-- Proudly display that you've conserved the semantics and performance characteristics during the conversion by showing your teammates the eerily familiar output.
-- Get promoted for introducing a new technology the safer, mature way.
diff --git a/pages/docs/manual/v8.0.0/editor-plugins.mdx b/pages/docs/manual/v8.0.0/editor-plugins.mdx
deleted file mode 100644
index e01314155..000000000
--- a/pages/docs/manual/v8.0.0/editor-plugins.mdx
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: "Editor Plugins"
-description: "List of ReScript editor plugins"
-canonical: "/docs/manual/latest/editor-plugins"
----
-
-# Editor Plugins
-
-**Note**: the editor plugins below work with the old `.re` and `.ml` syntax (plus highlighting support for the new syntax for VSCode, Atom and Sublime Text). The new `v8.2.0` introduced a new syntax and several changes that required new editor plugins, listed on the newer version of this page.
-
-- [VSCode](https://marketplace.visualstudio.com/items?itemName=jaredly.reason-vscode)
-- [Atom](https://github.com/reasonml-editor/atom-ide-reason)
-- [Vim/Neovim](https://github.com/reasonml-editor/vim-reason-plus)
-- [Sublime Text](https://github.com/reasonml-editor/sublime-reason)
-- [IDEA](https://github.com/reasonml-editor/reasonml-idea-plugin)
-- [Emacs](https://github.com/reasonml-editor/reason-mode) (currently unmaintained)
diff --git a/pages/docs/manual/v8.0.0/embed-raw-javascript.mdx b/pages/docs/manual/v8.0.0/embed-raw-javascript.mdx
deleted file mode 100644
index cd9400144..000000000
--- a/pages/docs/manual/v8.0.0/embed-raw-javascript.mdx
+++ /dev/null
@@ -1,134 +0,0 @@
----
-title: "Embed Raw JavaScript"
-description: "Utility syntax to for raw JS usage in ReScript"
-canonical: "/docs/manual/latest/embed-raw-javascript"
----
-
-# Embed Raw JavaScript
-
-## Paste Raw JS Code
-
-First thing first. If you're ever stuck learning ReScript, remember that you can always just paste raw JavaScript code into our source file:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[%%raw {|
-// look ma, regular JavaScript!
-var message = "hello";
-function greet(m) {
-  console.log(m)
-}
-|}];
-```
-```ml
-[%%raw {|
-// look ma, regular JavaScript!
-var message = "hello";
-function greet(m) {
-  console.log(m)
-}
-|}]
-```
-```js
-// look ma, regular JavaScript!
-var message = "hello";
-function greet(m) {
-  console.log(m)
-}
-```
-
-</CodeTab>
-
-The `%%raw` special ReScript call takes your code string and pastes it as-is into the output. **You've now technically written your first ReScript file!**
-
-(The back tick syntax is a multiline string, similar to JavaScript's. Except for us, no escaping is needed inside the string. More on string in a later section.)
-
-While `%%raw` lets you embed top-level raw JS code, `%raw` lets you embed expression-level JS code:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let add = [%raw {|
-  function(a, b) {
-    console.log("hello from raw JavaScript!");
-    return a + b
-  }
-|}];
-
-Js.log(add(1, 2));
-```
-```ml
-let add = [%raw {|
-  function(a, b) {
-    console.log("hello from raw JavaScript!");
-    return a + b
-  }
-|}]
-
-let () = Js.log (add 1 2)
-```
-```js
-var add = function(a, b) {
-  console.log("hello from raw JavaScript!");
-  return a + b
-};
-
-console.log(add(1, 2));
-```
-
-</CodeTab>
-
-The above code:
-- declared a ReScript variable `add`,
-- with the raw JavaScript value of a function declaration,
-- then called that function in ReScript.
-
-If your boss is ever worried that your teammates can't adopt ReScript, just let them keep writing JavaScript inside ReScript files =).
-
-## Debugger
-
-You can also drop a `%debugger` expression in a body:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let f = (x, y) => {
-  [%debugger];
-  x + y;
-};
-```
-```ml
-let f x y =
-  [%debugger ];
-  x + y
-```
-```js
-function f(x, y) {
-  debugger;
-  return x + y | 0;
-}
-```
-
-</CodeTab>
-
-Output:
-
-```js
-function f(x, y) {
-  debugger; // JavaScript developer tools will set an breakpoint and stop here
-  x + y;
-}
-```
-
-## Tips & Tricks
-
-Embedding raw JS snippets isn't the best way to experience ReScript, though it's also highly useful if you're just starting out. As a matter of fact, the first few ReScript projects were converted through:
-
-- pasting raw JS snippets inside a file
-- examining the JS output (identical to the old hand-written JS)
-- gradually extract a few values and functions and making sure the output still looks OK
-
-At the end, we get a fully safe, converted ReScript file whose JS output is clean enough that we can confidently assert that no new bug has been introduced during the conversion process.
-
-We have a small guide on this iteration [here](converting-from-js.md). Feel free to peruse it later.
diff --git a/pages/docs/manual/v8.0.0/exception.mdx b/pages/docs/manual/v8.0.0/exception.mdx
deleted file mode 100644
index 2ecf45f94..000000000
--- a/pages/docs/manual/v8.0.0/exception.mdx
+++ /dev/null
@@ -1,314 +0,0 @@
----
-title: "Exception"
-description: "Exceptions and exception handling in ReScript"
-canonical: "/docs/manual/latest/exception"
----
-
-# Exception
-
-Exceptions are just a special kind of variant, thrown in **exceptional** cases (don't abuse them!).
-
-## Usage
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let getItem = (items) =>
-  if (callSomeFunctionThatThrows()) {
-    // return the found item here
-    1;
-  } else {
-    raise(Not_found);
-  };
-
-let result =
-  try (getItem([|1, 2, 3|])) {
-  | Not_found => 0 /* Default value if getItem throws */
-  };
-```
-```ml
-let getItem items =
-  if callSomeFunctionThatThrows () then
-    (* return the found item here *)
-    1
-  else
-    raise Not_found
-
-let result =
-  try getItem [|1; 2; 3|] with
-  | Not_found -> 0 (* Default value if getItem throws *)
-```
-```js
-function getItem(items) {
-  if (callSomeFunctionThatThrows()) {
-    return 1;
-  }
-  throw {
-    RE_EXN_ID: "Not_found",
-    Error: new Error()
-  };
-}
-
-var result;
-
-try {
-  result = getItem([1, 2, 3]);
-} catch (raw_exn) {
-  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-  if (exn.RE_EXN_ID === "Not_found") {
-    result = 0;
-  } else {
-    throw exn;
-  }
-}
-```
-
-</CodeTab>
-
-Note that the above is just for demonstration purposes; in reality, you'd return an `option(int)` directly from `getItem` and avoid the `try` altogether.
-
-You can directly match on exceptions _while_ getting another return value from a function:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-switch (List.find(i => i === theItem, myItems)) {
-| item => Js.log(item)
-| exception Not_found => Js.log("No such item found!")
-};
-```
-```ml
-let () = match List.find (fun i -> i == theItem) myItems with
-| item -> Js.log item
-| exception Not_found ->
-  Js.log "No such item found!"
-```
-```js
-var exit = 0;
-
-var item;
-
-try {
-  item = List.find(function(i) {
-    return i === theItem;
-  }, myItems);
-  exit = 1;
-}
-catch (raw_exn){
-  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-  if (exn.RE_EXN_ID === "Not_found") {
-    console.log("No such item found!");
-  } else {
-    throw exn;
-  }
-}
-
-if (exit === 1) {
-  console.log(item);
-}
-```
-
-</CodeTab>
-
-You can also make your own exceptions like you'd make a variant (exceptions need to be capitalized too).
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-exception InputClosed(string);
-// later on
-raise(InputClosed("The stream has closed!"));
-```
-```ml
-exception InputClosed of string
-(* later on *)
-raise(InputClosed "The stream has closed!")
-```
-```js
-var Caml_exceptions = require("./stdlib/caml_exceptions.js");
-
-var InputClosed = Caml_exceptions.create("MyFile.InputClosed");
-
-throw {
-  RE_EXN_ID: InputClosed,
-  _1: "The stream has closed!",
-  Error: new Error()
-};
-```
-
-</CodeTab>
-
-## Catching JS Exceptions
-
-To distinguish between JavaScript exceptions and ReScript exceptions, ReScript namespaces JS exceptions under the `Js.Exn.Error(payload)` variant. To catch an exception thrown from the JS side:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-try (someJSFunctionThatThrows()) {
-| Js.Exn.Error(obj) =>
-  switch (Js.Exn.message(obj)) {
-  | Some(m) => Js.log("Caught a JS exception! Message: " ++ m)
-  | None => ()
-  }
-};
-```
-```ml
-let () = try someJSFunctionThatThrows () with
-| Js.Exn.Error obj ->
-  match Js.Exn.message obj with
-  | Some m -> Js.log ("Caught a JS exception! Message: " ^ m)
-  | None -> ()
-```
-```js
-var Js_exn = require("./stdlib/js_exn.js");
-var Caml_js_exceptions = require("./stdlib/caml_js_exceptions.js");
-
-try {
-  someJSFunctionThatThrows();
-} catch (raw_obj) {
-  var obj = Caml_js_exceptions.internalToOCamlException(raw_obj);
-  if (obj.RE_EXN_ID === Js_exn.$$Error) {
-    var m = obj._1.message;
-    if (m !== undefined) {
-      console.log("Caught a JS exception! Message: " + m);
-    }
-  } else {
-    throw obj;
-  }
-}
-```
-
-</CodeTab>
-
-The `obj` here is of type `Js.Exn.t`, intentionally opaque to disallow illegal operations. To operate on `obj`, do like the code above by using the standard library's [`Js.Exn`](api/js/exn) module's helpers.
-
-## Raise a JS Exception
-
-`raise(MyException)` raises a ReScript exception. To raise a JavaScript exception (whatever your purpose is), use `Js.Exn.raiseError`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let myTest = () => {
-  Js.Exn.raiseError("Hello!");
-};
-```
-```ml
-let myTest () =
-  Js.Exn.raiseError "Hello!"
-```
-```js
-var Js_exn = require("./stdlib/js_exn.js");
-
-function myTest() {
-  return Js_exn.raiseError("Hello!");
-}
-```
-
-</CodeTab>
-
-Then you can catch it from the JS side:
-
-```js
-// after importing `myTest`...
-try {
-  myTest()
-} catch (e) {
-  console.log(e.message) // "Hello!"
-}
-```
-
-## Catch ReScript Exceptions from JS
-
-The previous section is less useful than you think; to let your JS code work with your exception-throwing ReScript code, the latter doesn't actually need to throw a JS exception. ReScript exceptions can be used by JS code!
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-exception BadArgument({myMessage: string});
-
-let myTest = () => {
-  raise(BadArgument({myMessage: "Oops!"}));
-};
-```
-```ml
-exception BadArgument of {myMessage: string}
-
-let myTest () =
-  raise(BadArgument {myMessage = "Oops!"})
-```
-```js
-var Caml_exceptions = require("./stdlib/caml_exceptions.js");
-
-var BadArgument = Caml_exceptions.create("Playground.BadArgument");
-
-function myTest() {
-  throw {
-    RE_EXN_ID: BadArgument,
-    myMessage: "Oops!",
-    Error: new Error()
-  };
-}
-```
-
-</CodeTab>
-
-Then, in your JS:
-
-```js
-// after importing `myTest`...
-try {
-  myTest()
-} catch (e) {
-  console.log(e.myMessage) // "Oops!"
-  console.log(e.Error.stack) // the stack trace
-}
-```
-
-> Note: `RE_EXN_ID` is an internal field for bookkeeping purposes. Don't use it on the JS side. Use the other fields.
-
-The above `BadArgument` exception takes an inline record type. We special-case compile the exception as `{RE_EXN_ID, myMessage, Error}` for good ergonomics. If the exception instead took ordinary positional arguments, l like the standard library's `Invalid_argument("Oops!")`, which takes a single argument, the argument is compiled to JS as the field `_1` instead. A second positional argument would compile to `_2`, etc.
-
-## Tips & Tricks
-
-When you have ordinary variants, you often don't **need** exceptions. For example, instead of throwing when `item` can't be found in a collection, try to return an `option(item)` (`None` in this case) instead.
-
-### Catch Both ReScript and JS Exceptions in the Same `catch` Clause
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-try (someOtherJSFunctionThatThrows()) {
-| Not_found => ...  // catch a ReScript exception
-| Invalid_argument(_) => ... // catch a second ReScript exception
-| Js.Exn.Error(obj) => ... // catch the JS exception
-};
-```
-```ml
-try someOtherJSFunctionThatThrows() with
-| Not_found -> ... (* catch a ReScript exception *)
-| Invalid_argument _ -> ... (* catch a second ReScript exception *)
-| Js.Exn.Error obj -> ... (* catch the JS exception *)
-```
-```js
-var Js_exn = require("./stdlib/js_exn.js");
-var Caml_js_exceptions = require("./stdlib/caml_js_exceptions.js");
-
-try {
-  someOtherJSFunctionThatThrows();
-} catch (raw_obj) {
-  var obj = Caml_js_exceptions.internalToOCamlException(raw_obj);
-  if (
-    obj.RE_EXN_ID !== "Not_found" &&
-    obj.RE_EXN_ID !== "Invalid_argument" &&
-    obj.RE_EXN_ID !== Js_exn.$$Error
-  ) {
-    throw obj;
-  }
-}
-```
-
-</CodeTab>
-
-This technically works, but hopefully you don't ever have to work with such code...
diff --git a/pages/docs/manual/v8.0.0/external.mdx b/pages/docs/manual/v8.0.0/external.mdx
deleted file mode 100644
index dea30c09c..000000000
--- a/pages/docs/manual/v8.0.0/external.mdx
+++ /dev/null
@@ -1,104 +0,0 @@
----
-title: "External (Bind to Any JS Library)"
-description: "The external keyword"
-canonical: "/docs/manual/latest/external"
----
-
-# External (Bind to Any JS Library)
-
-`external` is the primary ReScript feature for bringing in and using JavaScript values.
-
-`external` is like a let binding, but:
-- The right side of `=` isn't a value; it's the name of the JS value you're referring to.
-- The type for the binding is mandatory, since we need to know what the type of that JS value is.
-- Can only exist at the top level of a file or module.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.val] external setTimeout: (unit => unit, int) => float = "setTimeout";
-```
-```ml
-external setTimeout: (unit -> unit) -> int -> float = "setTimeout" [@@bs.val]
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-There are several kinds of `external`s, differentiated and/or augmented through the `@bs` notation they carry. This page deals with the general, shared mechanism behind most `external`s. The different `@bs` annotations are documented in their respective pages later. A few notable ones:
-
-- `@bs.val`, `@bs.scope`: [bind to global JS values](bind-to-global-js-values).
-- `@bs.module`: [bind to JS imported/exported values](import-from-export-to-js).
-- `@bs.send`: [bind to JS methods](bind-to-js-function).
-
-## Usage
-
-Once declared, you can use an `external` as a normal value, just like a let binding.
-
-## Tips & Tricks
-
-`external` + ReScript objects are a wonderful combination for quick prototyping. Check the JS output tab:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```re
-// The type of document is just some random type 'a
-// that we won't bother to specify
-[@bs.val] external document: 'a = "document";
-
-// call a method
-document##addEventListener("mouseup", _event => {
-  Js.log("clicked!");
-});
-
-// get a property
-let loc = document##location;
-
-// set a property
-document##location##href = "rescript-lang.org";
-```
-```ml
-(* The type of document is just some random type 'a *)
-(* that we won't bother to specify *)
-external document: 'a = "document" [@@bs.val]
-
-(* call a method *)
-document##addEventListener "mouseup" (fun _event ->
-  Js.log "clicked!"
-)
-
-(* get a property *)
-let loc = document##location
-
-(* set a property *)
-document##location##href = "rescript-lang.org"
-```
-```js
-document.addEventListener("mouseup", function(_event) {
-  console.log("clicked!");
-});
-
-var loc = document.location;
-
-document.location.href = "rescript-lang.org";
-```
-
-</CodeTab>
-
-We've specified `document`'s type as `'a`, aka a placeholder type that's polymorphic. Any value can be passed there, so you're not getting much type safety (except the inferences at various call sites). However, this is excellent for quickly getting started using a JavaScript library in ReScript **without needing the equivalent of a repository of typed bindings** like TypeScript's `DefinitelyTyped` repo.
-
-However, if you want to more rigidly bind to the JavaScript library you want, keep reading the next few interop pages.
-
-## Performance & Output Readability
-
-`external`s declarations are inlined into their callers during compilation, **and completely disappear from the JS output**. This means any time you use one, you can be sure that you're not incurring extra JavaScript \<-> ReScript conversion cost.
-
-Additionally, no extra ReScript-specific runtime is better for output readability.
-
-## Design Decisions
-
-ReScript takes interoperating with existing code very seriously. Our type system has very strong guarantees. However, such strong feature also means that, without a great interop system, it'd be very hard to gradually convert a codebase over to ReScript. Fortunately, our interop are comprehensive and cooperate very well with most existing JavaScript code.
-
-The combination of a sound type system + great interop means that we get the benefits of a traditional gradual type system regarding incremental codebase coverage & conversion, without the downside of such gradual type system: complex features to support existing patterns, slow analysis, diminishing return in terms of type coverage, etc.
diff --git a/pages/docs/manual/v8.0.0/faq.mdx b/pages/docs/manual/v8.0.0/faq.mdx
deleted file mode 100644
index 0c4b8d947..000000000
--- a/pages/docs/manual/v8.0.0/faq.mdx
+++ /dev/null
@@ -1,53 +0,0 @@
----
-title: "FAQ"
-description: "Frequently asked questions about ReScript and its ecosystem"
-canonical: "/docs/manual/latest/faq"
----
-
-# Frequently Asked Questions
-
-**What's the goal of this project?**
-
-We aim to provide the best typed language experience for the JavaScript platform.
-
-**What’s ReScript's relationship with OCaml?**
-
-We reuse the same excellent type system with OCaml, and lots of other high quality components. Additionally, ReScript provides its own syntax build system, JS interop, extra language features, etc. We do sync up those OCaml components from time to time, but it’s not our goal to be tied to the OCaml release cycle and its toolchain.
-
-**What’s the relationship with BuckleScript?**
-
-See [here](/blog/bucklescript-is-rebranding). BuckleScript is ReScript's old branding, with a sharper focus on proper JS support and familiarity which we previously couldn't achieve to the degree we wanted, due to us needing to cater to various different crowds.
-
-**What’s the relationship with Reason?**
-
-Reason is a syntax layer for OCaml that BuckleScript also adopted. The current ReScript compiler also supports the old Reason syntax v3.6 for backward compatibility. We will support it for a long time to make sure existing users do not get breaking changes.
-
-**I come from Reason/OCaml. Will ReScript keep supporting X?**
-
-Please see our [blog post](/blog/a-note-on-bucklescripts-future-commitments) on this matter.
-
-**Where can I see the docs in old Reason syntax?**
-
-Switch the doc version to `v8.0.0` in the sidebar on the left!
-
-**Will ReScript support native compilation eventually?**
-
-Our focus is a solid JS story right now. In the future, if there’s strong demand, we might consider it.
-
-**What’s the current state of ReScript?**
-
-Currently, we're actively working on the editor support.
-
-**Why create a new syntax?**
-
-The existing Reason syntax is owned by a different team with a different vision. Reason aims to be 100% compatible with OCaml syntax and to support all versions of OCaml. In the last few years, we've drawn the conclusion that it’s very hard to deliver such goal without sacrificing user experience. The other reason is that we feel it’s better to have the same vision as a team so that we can make more coherent decisions.
-
-**Who is behind the project?**
-
-The ReScript team (Hongbo, Cheng, Cristiano, Maxim, Patrick, Ricky).
-
-**We have a new forum; will we also have our own Discord?**
-
-Not now. We've found that too much important information get casually passed in Discord then lost within the noise. We prefer folks to communicate on the [forum](https://forum.rescript-lang.org). This is nicer to the less active members.
-
-We also will never announce important news in chat.
diff --git a/pages/docs/manual/v8.0.0/function.mdx b/pages/docs/manual/v8.0.0/function.mdx
deleted file mode 100644
index 49c778c24..000000000
--- a/pages/docs/manual/v8.0.0/function.mdx
+++ /dev/null
@@ -1,725 +0,0 @@
----
-title: "Function"
-description: "Function syntax in ReScript"
-canonical: "/docs/manual/latest/function"
----
-
-# Function
-
-_Cheat sheet for the full function syntax at the end_.
-
-ReScript functions are declared with an arrow and return an expression, just like JS functions. They compile to clean JS functions too.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let greet = (name) => "Hello " ++ name;
-```
-```ml
-let greet name = "Hello " ^ name
-```
-```js
-function greet(name) {
-  return "Hello " + name;
-}
-```
-
-</CodeTab>
-
-This declares a function and assigns to it the name `greet`, which you can call like so:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-greet("world!"); // "Hello world!"
-```
-```ml
-greet "world!" (* "Hello world!" *)
-```
-```js
-greet("world!");
-```
-
-</CodeTab>
-
-Multi-arguments functions have arguments separated by comma:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let add = (x, y, z) => x + y + z;
-add(1, 2, 3); // 6
-```
-```ml
-let add x y z = (x + y) + z
-let () = add 1 2 3
-```
-```js
-function add(x, y, z) {
-  return (x + y | 0) + z | 0;
-}
-```
-
-</CodeTab>
-
-For longer functions, you'd surround the body with a block:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let greetMore = (name) => {
-  let part1 = "Hello";
-  part1 ++ " " ++ name;
-};
-```
-```ml
-let greetMore name =
-  let part1 = "Hello" in
-  part1 ^ " " ^ name
-```
-```js
-function greetMore(name) {
-  return "Hello " + name;
-}
-```
-
-</CodeTab>
-
-If your function has no argument, just write `let greetMore = () => {...}`.
-
-## Labeled Arguments
-
-Multi-arguments functions, especially those whose arguments are of the same type, can be confusing to call.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let addCoordinates = (x, y) => {
-  // use x and y here
-};
-// ...
-addCoordinates(5, 6); // which is x, which is y?
-```
-```ml
-let addCoordinates x t =
-  (* use x and y here *)
-(* ... *)
-addCoordinates 5 6 (* which is x, which is y? *)
-```
-```js
-function addCoordinates(x, y) {
-  // use x and y here
-}
-
-addCoordinates(5, 6);
-```
-
-</CodeTab>
-
-You can attach labels to an argument by prefixing the name with the `~` symbol:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let addCoordinates = (~x, ~y) => {
-  // use x and y here
-};
-// ...
-addCoordinates(~x=5, ~y=6);
-```
-```ml
-let addCoordinates ~x ~y =
-  (* use x and y here *)
-(* ... *)
-addCoordinates ~x=5 ~y=6
-```
-```js
-function addCoordinates(x, y) {
-  // use x and y here
-}
-
-addCoordinates(5, 6);
-```
-
-</CodeTab>
-
-You can provide the arguments in **any order**:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-addCoordinates(~y=6, ~x=5);
-```
-```ml
-addCoordinates ~y=6 ~x=5
-```
-```js
-addCoordinates(5, 6);
-```
-
-</CodeTab>
-
-The `~x` part in the declaration means the function accepts an argument labeled `x` and can refer to it in the function body by the same name. You can also refer to the arguments inside the function body by a different name for conciseness:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let drawCircle = (~radius as r, ~color as c) => {
-  setColor(c);
-  startAt(r, r);
-  // ...
-};
-
-drawCircle(~radius=10, ~color="red");
-```
-```ml
-let drawCircle ~radius:r ~color:c =
-  setColor c;
-  startAt r r;
-  (* ... *)
-
-let () = drawCircle ~radius:10 ~color:"red"
-```
-```js
-function drawCircle(r, c) {
-  setColor(c);
-  return startAt(r, r);
-}
-
-drawCircle(10, "red");
-```
-
-</CodeTab>
-
-As a matter of fact, `(~radius)` is just a shorthand for `(~radius as radius)`.
-
-Here's the syntax for typing the arguments:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let drawCircle = (~radius as r: int, ~color as c: string) => {
-  // code here
-};
-```
-```ml
-let drawCircle ~radius:(r : int) ~color:(c : string) =
-  (* code *)
-```
-```js
-function drawCircle(r, c) {
-  // code here
-}
-```
-
-</CodeTab>
-
-## Optional Labeled Arguments
-
-Labeled function arguments can be made optional during declaration. You can then omit them when calling the function.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-// radius can be omitted
-let drawCircle = (~color, ~radius=?, ()) => {
-  setColor(color);
-  switch (radius) {
-  | None => startAt(1, 1)
-  | Some(r_) => startAt(r_, r_)
-  };
-};
-```
-```ml
-(* radius can be omitted *)
-let drawCircle ~color ?radius () =
-  setColor color;
-  let () = match radius with
-  | None -> startAt 1 1
-  | Some r_ -> startAt r_ r_
-```
-```js
-var Caml_option = require("./stdlib/caml_option.js");
-
-function drawCircle(color, radius, param) {
-  setColor(color);
-  if (radius === undefined) {
-    return startAt(1, 1);
-  }
-  var r_ = Caml_option.valFromOption(radius);
-  return startAt(r_, r_);
-}
-```
-
-</CodeTab>
-
-When given in this syntax, `radius` is **wrapped** in the standard library's `option` type, defaulting to `None`. If provided, it'll be wrapped with a `Some`. So `radius`'s type value is `None | Some(int)` here.
-
-More on `option` type [here](null-undefined-option.md).
-
-**Note** for the sake of the type system, whenever you have an optional argument, you need to ensure that there's also at least one positional argument (aka non-labeled, non-optional argument) after it. If there's none, provide a dummy `unit` (aka `()`) argument.
-
-### Signatures and Type Annotations
-
-Functions with optional labeled arguments can be confusing when it comes to signature and type annotations. Indeed, the type of an optional labeled argument looks different depending on whether you're calling the function, or working inside the function body. Outside the function, a raw value is either passed in (`int`, for example), or left off entirely. Inside the function, the parameter is always there, but its value is an option (`option(int)`). This means that the type signature is different, depending on whether you're writing out the function type, or the parameter type annotation. The first being a raw value, and the second being an option.
-
-If we get back to our previous example and both add a signature and type annotations to its argument, we get this:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let drawCircle: (~color: color, ~radius: int=?, unit) => unit =
-  (~color: color, ~radius: option(int)=?, ()) => {
-    setColor(color);
-    switch (radius) {
-    | None => startAt(1, 1)
-    | Some(r_) => startAt(r_, r_)
-    };
-  };
-```
-```ml
-let drawCircle: color:color -> ?radius:int -> unit -> unit =
-  fun ~color:(color : color) ?radius:(radius : int option) () ->
-    setColor color;
-    let () = match radius with
-    | None -> startAt 1 1
-    | Some r_ -> startAt r_ r_
-```
-```js
-function drawCircle(color, radius, param) {
-  setColor(color);
-  if (radius !== undefined) {
-    return startAt(radius, radius);
-  } else {
-    return startAt(1, 1);
-  }
-}
-```
-
-</CodeTab>
-
-The first line is the function's signature, we would define it like that in an interface file (see [Signatures](module.md#signatures)). The function's signature describes the types that the **outside world** interacts with, hence the type `int` for `radius` because it indeed expects an `int` when called.
-
-In the second line, we annotate the arguments to help us remember the types of the arguments when we use them **inside** the function's body, here indeed `radius` will be an `option(int)` inside the function.
-
-So if you happen to struggle when writing the signature of a function with optional labeled arguments, try to remember this!
-
-### Explicitly Passed Optional
-
-Sometimes, you might want to forward a value to a function without knowing whether the value is `None` or `Some(a)`. Naively, you'd do:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let result =
-  switch (payloadRadius) {
-  | None => drawCircle(~color, ())
-  | Some(r) => drawCircle(~color, ~radius=r, ())
-  };
-```
-```ml
-let result =
-  match payloadRadius with
-  | None -> drawCircle ~color ()
-  | Some r -> drawCircle ~color ~radius:r ()
-```
-```js
-var r = payloadRadius;
-
-var result = r !== undefined
-  ? drawCircle(color, Caml_option.valFromOption(r), undefined)
-  : drawCircle(color, undefined);
-```
-
-</CodeTab>
-
-This quickly gets tedious. We provide a shortcut:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let result = drawCircle(~color, ~radius=?payloadRadius, ());
-```
-```ml
-let result = drawCircle ~color ?radius:payloadRadius ()
-```
-```js
-var result = drawCircle(1, undefined, undefined);
-```
-
-</CodeTab>
-
-This means "I understand `radius` is optional, and that when I pass it a value it needs to be an `int`, but I don't know whether the value I'm passing is `None` or `Some(val)`, so I'll pass you the whole `option` wrapper".
-
-### Optional with Default Value
-
-Optional labeled arguments can also be provided a default value. In this case, they aren't wrapped in an `option` type.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let drawCircle = (~radius=1, ~color, ()) => {
-  setColor(color);
-  startAt(radius, radius);
-};
-```
-```ml
-let drawCircle ?(radius=1) ~color () =
-  setColor color;
-  startAt radius radius
-```
-```js
-function drawCircle(radiusOpt, color, param) {
-  var radius = radiusOpt !== undefined ? radiusOpt : 1;
-  setColor(color);
-  return startAt(radius, radius);
-}
-```
-
-</CodeTab>
-
-## Recursive Functions
-
-ReScript chooses the sane default of preventing a function to be called recursively within itself. To make a function recursive, add the `rec` keyword after the `let`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let rec neverTerminate = () => neverTerminate()
-```
-```ml
-let rec neverTerminate () = neverTerminate ()
-```
-```js
-function neverTerminate(_param) {
-  while(true) {
-    _param = undefined;
-    continue ;
-  };
-}
-```
-
-</CodeTab>
-
-A simple recursive function may look like this:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-// Recursively check every item on the list until one equals the `item`
-// argument. If a match is found, return `true`, otherwise return `false`
-let rec listHas = (list, item) =>
-  switch (list) {
-  | [] => false
-  | [a, ...rest] => a === item || listHas(rest, item)
-  };
-```
-```ml
-(* Recursively check every item on the list until one equals the `item` *)
-(* argument. If a match is found, return `true`, otherwise return `false` *)
-
-let rec listHas list item =
-  match list with
-  | [] -> false
-  | a::rest -> (a == item) || (listHas rest item)
-```
-```js
-function listHas(_list, item) {
-  while(true) {
-    var list = _list;
-    if (!list) {
-      return false;
-    }
-    if (list.hd === item) {
-      return true;
-    }
-    _list = list.tl;
-    continue ;
-  };
-}
-```
-
-</CodeTab>
-
-Recursively calling a function is bad for performance and the call stack. However, ReScript intelligently compiles [tail recursion](https://stackoverflow.com/questions/33923/what-is-tail-recursion) into a fast JavaScript loop. Try checking the JS output of the above code!
-
-### Mutually Recursive Functions
-
-Mutually recursive functions start like a single recursive function using the
-`rec` keyword, and then are chained together with `and`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let rec callSecond = () => callFirst()
-and callFirst = () => callSecond();
-```
-```ml
-let rec callSecond () = callFirst ()
-and callFirst () = callSecond ()
-```
-```js
-function callSecond(_param) {
-  while(true) {
-    _param = undefined;
-    continue ;
-  };
-}
-
-function callFirst(_param) {
-  while(true) {
-    _param = undefined;
-    continue ;
-  };
-}
-```
-
-</CodeTab>
-
-## Uncurried Function
-
-ReScript's functions are curried by default, which is one of the few performance penalties we pay in the compiled JS output. The compiler does a best-effort job at removing those currying whenever possible. However, in certain edge cases, you might want guaranteed uncurrying. In those cases, put a dot in the function's parameter list:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let add = (. x, y) => x + y;
-
-add(. 1, 2);
-```
-```ml
-let add = (fun x y -> x + y) [@bs]
-let () = add 1 2 [@bs]
-```
-```js
-function add(x, y) {
-  return x + y | 0;
-}
-
-add(1, 2);
-```
-
-</CodeTab>
-
-If you write down the uncurried function's type, you'll add a dot there as well.
-
-**Note**: both the declaration site and the call site need to have the uncurry annotation. That's part of the guarantee/requirement.
-
-**This feature seems trivial**, but is actually one of our most important features, as a primarily functional language. We encourage you to use it if you'd like to remove any mention of `Curry` runtime in the JS output.
-
-## Tips & Tricks
-
-Cheat sheet for the function syntaxes:
-
-### Declaration
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```re
-// anonymous function
-(x, y) => 1;
-// bind to a name
-let add = (x, y) => 1;
-
-// labeled
-let add = (~first as x, ~second as y) => x + y;
-// with punning sugar
-let add = (~first, ~second) => first + second;
-
-// labeled with default value
-let add = (~first as x=1, ~second as y=2) => x + y;
-// with punning
-let add = (~first=1, ~second=2) => first + second;
-
-// optional
-let add = (~first as x=?, ~second as y=?) => switch (x) {...};
-// with punning
-let add = (~first=?, ~second=?) => switch (first) {...};
-```
-```ml
-(* anonymous function *)
-fun x y -> 1
-(* bind to a name *)
-let add x y = 1
-
-(* labeled *)
-let add ~first:x ~second:y = x + y
-(* with punning sugar *)
-let add ~first ~second = first + second
-
-(* labeled with default value *)
-let add ?first:(x=1) ?second:(y=2) = x + y
-(* with punning *)
-let add ?(first=1) ?(second=2) = first + second
-
-(* optional *)
-let add ?first:x ?second:y = match x with ...
-(* with punning *)
-let add ?first ?second = match x with ...
-```
-
-</CodeTab>
-
-#### With Type Annotation
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```re
-// anonymous function
-(x: int, y: int): int => 1;
-// bind to a name
-let add = (x: int, y: int): int => 1;
-
-// labeled
-let add = (~first as x: int, ~second as y: int) : int => x + y;
-// with punning sugar
-let add = (~first: int, ~second: int) : int => first + second;
-
-// labeled with default value
-let add = (~first as x: int=1, ~second as y: int=2) : int => x + y;
-// with punning sugar
-let add = (~first: int=1, ~second: int=2) : int => first + second;
-
-// optional
-let add = (~first as x: option(int)=?, ~second as y: option(int)=?) : int => switch (x) {...};
-// with punning sugar
-// note that the caller would pass an `int`, not `option(int)`
-// Inside the function, `first` and `second` are `option(int)`.
-let add = (~first: option(int)=?, ~second: option(int)=?) : int => switch (first) {...};
-```
-```ml
-(* anonymous function *)
-fun (x: int) (y: int) : int -> 1
-(* bind to a name *)
-let add (x: int) (y: int) : int = 1
-
-(* labeled *)
-let add ~first:(x: int) ~second:(y: int) : int = x + y
-(* no punning sugar *)
-
-(* labeled with default value *)
-let add ?first:((x: int)=1) ?second:((y: int)=2) : int = x + y
-(* no punning sugar *)
-(* optional *)
-let add ?first:(x: int option) ?second:(y: int option) : int = match x with ...
-(* no punning sugar *)
-```
-
-</CodeTab>
-
-### Application
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```re
-add(x, y);
-
-// labeled
-add(~first=1, ~second=2);
-// with punning sugar
-add(~first, ~second);
-
-// application with default value. Same as normal application
-add(~first=1, ~second=2);
-
-// explicit optional application
-add(~first=?Some(1), ~second=?Some(2));
-// with punning
-add(~first?, ~second?);
-```
-```ml
-add x y
-
-(* labeled *)
-add ~first:1 ~second:2
-(* with punning sugar *)
-add ~first ~second
-
-(* application with default value. Same as normal application *)
-add ~first:1 ~second:2
-
-(* explicit optional application *)
-add ?first:(Some 1) ?second:(Some 2)
-(* with punning *)
-add ?first ?second
-```
-
-</CodeTab>
-
-#### With Type Annotation
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```re
-// labeled
-add(~first=1: int, ~second=2: int);
-// with punning sugar
-add(~first: int, ~second: int);
-
-// application with default value. Same as normal application
-add(~first=1: int, ~second=2: int);
-
-// explicit optional application
-add(~first=?Some(1): option(int), ~second=?Some(2): option(int));
-// no punning sugar when you want to type annotate
-```
-```ml
-(* labeled *)
-add ~first:(1: int) ~second:(2: int)
-(* no punning sugar *)
-
-(* application with default value. Same as normal application *)
-add ~first:(1: int) ~second:(2: int)
-
-(* explicit optional application *)
-add ?first:(Some 1: int option) ?second:(Some 2: int option)
-(* no punning sugar when you want to type annotate *)
-```
-
-</CodeTab>
-
-### Standalone Type Signature
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```re
-// first arg type, second arg type, return type
-type add = (int, int) => int;
-
-// labeled
-type add = (~first: int, ~second: int) => int;
-
-// labeled
-type add = (~first: int=?, ~second: int=?, unit) => int;
-```
-```ml
-(* first arg type, second arg type, return type *)
-type add = int -> int -> int
-
-(* labeled *)
-type add = first:int -> second:int -> int
-
-(* labeled *)
-type add = ?first:int -> ?second:int -> unit -> int
-```
-
-</CodeTab>
-
-#### In Interface Files
-
-To annotate a function from the implementation file (`.re`) in your interface file (`.rei`):
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```re
-let add: (int, int) => int;
-```
-```ml
-val add: int -> int -> int
-```
-
-</CodeTab>
-
-The type annotation part is the same as the previous section on With Type Annotation.
-
-**Don't** confuse `let add: myType` with `type add = myType`. When used in `.rei` interface files, the former exports the binding `add` while annotating it as type `myType`. The latter exports the type `add`, whose value is the type `myType`.
diff --git a/pages/docs/manual/v8.0.0/generate-converters-accessors.mdx b/pages/docs/manual/v8.0.0/generate-converters-accessors.mdx
deleted file mode 100644
index 095404569..000000000
--- a/pages/docs/manual/v8.0.0/generate-converters-accessors.mdx
+++ /dev/null
@@ -1,994 +0,0 @@
----
-title: "Generate Converters & Helpers"
-description: "All about the @bs.deriving decorator, and how to generate code from types"
-canonical: "/docs/manual/latest/generate-converters-accessors"
----
-
-# Generate Converters & Helpers
-
-<!-- TODO: genType -->
-
-When using ReScript, you will sometimes come into situations where you want to
-
-- Automatically generate functions that convert between ReScript's internal and JS runtime values (e.g. variants).
-- Convert a record type into an abstract type with generated creation, accessor and method functions.
-- Generate some other helper functions, such as functions from record attribute names.
-
-You can use the `@bs.deriving` decorator to trigger code generation. All different options and configurations will be discussed on this page.
-
-**Note:** Please be aware that extensive use of code generation might make it harder to understand your programs (since the code being generated is not visible in the source code, and you just need to know what kind of functions / values a decorator generates).
-
-**Another Note:** Since `v8.3` you can drop the `bs.` prefix for all our decorators (e.g. `@bs.deriving` => `@deriving`).
-
-## Generate Functions & Plain Values for Variants
-
-Use `[@bs.deriving accessors]` on a variant type to create accessor functions for its constructors.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-[@bs.deriving accessors]
-type action =
-  | Click
-  | Submit(string)
-  | Cancel;
-```
-
-```ocaml
-type action =
-  | Click
-  | Submit of string
-  | Cancel
-  [@@bs.deriving accessors]
-```
-
-```js
-function submit(param_0) {
-  return /* Submit */[param_0];
-}
-
-var click = /* Click */0;
-
-var cancel = /* Cancel */1;
-
-exports.click  = click;
-exports.submit = submit;
-exports.cancel = cancel;
-```
-
-</CodeTab>
-
-Variants constructors with payloads generate functions, payload-less constructors generate plain integers (the internal representation of variants).
-
-**Note**:
-- The generated accessors are lower-cased.
-- You can now use these helpers on the JavaScript side! But don't rely on their actual values please.
-
-### Usage
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```reason
-let s = submit("hello"); /* gives Submit("hello") */
-```
-
-```ocaml
-let s = submit "hello" (* gives Submit("hello") *)
-```
-
-</CodeTab>
-
-This is useful:
-
-- When you're passing the accessor function as a higher-order function (which plain variant constructors aren't).
-- When you'd like the JS side to use these values & functions opaquely and pass you back a variant constructor (since JS has no such thing).
-
-Please note that in case you just want to _pipe a payload into a constructor_, you don't need to generate functions for that. Use the `->` syntax instead, e.g. `"test"->Submit`.
-
-## Generate Field Accessors for Records
-
-Use `[@bs.deriving accessors]` on a record type to create accessors for its record field names.
-
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-[@bs.deriving accessors]
-type pet = {
-  name: string,
-};
-
-let pets = [|{name: "bob"}, {name: "bob2"}|];
-
-pets
-  ->Belt.Array.map(name)
-  ->Js.Array2.joinWith("&")
-  ->Js.log;
-```
-
-```ocaml
-type pet = {
-  name: string;
-}[@@bs.deriving accessors]
-
-let pets = [|{ name = ("bob") }; { name = ("bob2") }|]
-
-let _ =
-  ((((pets |. Belt.Array.map) name) |. Js.Array2.joinWith)
-     ("&"))
-    |. Js.log
-```
-
-```js
-function name(param) {
-  return param.name;
-}
-
-var pets = [
-  {
-    name: "bob"
-  },
-  {
-    name: "bob2"
-  }
-];
-
-console.log(Belt_Array.map(pets, name).join("&"));
-```
-
-</CodeTab>
-
-## Generate Converters for JS Object and Record
-
-> **Note:** In ReScript >= v7 [records are already compiled to JS
-> objects](bind-to-js-object#bind-to-record-like-js-objects). `[@bs.deriving jsConverter]` is therefore
-> obsolete and will generate a no-op function for compatibility instead.
-
-Use `[@bs.deriving jsConverter]` on a record type to create convertion functions between records / JS object runtime values.
-
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```reason
-[@bs.deriving jsConverter]
-type coordinates = {
-  x: int,
-  y: int
-};
-```
-
-```ocaml
-type coordinates = {
-  x: int;
-  y: int;
-}[@@bs.deriving jsConverter]
-```
-
-</CodeTab>
-
-Generates 2 functions of the following types:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```reason
-let coordinatesToJs: coordinates => {. "x": int, "y": int};
-
-let coordinatesFromJs: {.. "x": int, "y": int} => coordinates;
-```
-
-```ocaml
-val coordinatesToJs : coordinates -> < x: int; y: int>  Js.t
-
-val coordinatesFromJs : < x: int; y: int ; .. >  Js.t -> coordinates
-```
-
-</CodeTab>
-
-**Note**:
-
-- `coordinatesFromJs` uses an open object type that accepts more fields, just to be more permissive.
-- The converters are shallow. They don't recursively drill into the fields and convert them. This preserves the speed and simplicity of output while satisfying 80% of use-cases.
-
-### Usage
-
-This exports a `jsCoordinates` JS object (not a record!) for JS files to use:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```reason
-let jsCoordinates = coordinatesToJs({x: 1, y: 2});
-```
-
-```ocaml
-let jsCoordinates = coordinatesToJs { x = 1; y = 2 }
-```
-
-</CodeTab>
-
-This binds to a `jsCoordinates` record (not a JS object!) that exists on the JS side, presumably created by JS calling the function `coordinatesFromJs`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```reason
-[@bs.module "myGame"] external jsCoordinates : coordinates = "jsCoordinates";
-```
-
-```ocaml
-external jsCoordinates : coordinates = "jsCoordinates"[@@bs.module "myGame"]
-```
-
-</CodeTab>
-
-### More Safety
-
-The above generated functions use `Js.t` object types. You can also hide this implementation detail by making the object type **abstract** by using the `newType` option with `[@bs.deriving jsConverter]`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```reason
-[@bs.deriving {jsConverter: newType}]
-type coordinates = {
-  x: int,
-  y: int
-};
-```
-
-```ocaml
-type coordinates = {
-  x: int ;
-  y: int
-} [@@bs.deriving { jsConverter = newType }]
-```
-
-</CodeTab>
-
-Generates 2 functions of the following types:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```reason
-let coordinatesToJs: coordinates => abs_coordinates;
-
-let coordinatesFromJs: abs_coordinates => coordinates;
-```
-
-```ocaml
-val coordinatesToJs : coordinates -> abs_coordinates
-
-val coordinatesFromJs : abs_coordinates -> coordinates
-```
-
-</CodeTab>
-
-#### Usage
-
-Using `newType`, you've now prevented consumers from inadvertently doing the following:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```reason
-let myCoordinates = {
-  x: 10,
-  y: 20
-};
-let jsCoords = coordinatesToJs(myCoordinates);
-
-let x = jsCoords##x; /* disallowed! Don't access the object's internal details */
-```
-
-```ocaml
-let myCoordinates = {
-  x = 10;
-  y = 20
-}
-
-let jsCoords = coordinatesToJs myCoordinates
-
-let x = jsCoords ## x (* disallowed! Don't access the object's internal details *)
-```
-
-</CodeTab>
-
-Same generated output. Isn't it great that types prevent invalid accesses you'd otherwise have to encode at runtime?
-
-## Generate Converters for JS Integer Enums and Variants
-
-Use `[@bs.deriving jsConverter]` on a variant type to create converter functions that allow back and forth conversion between JS integer enum and ReScript variant values.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```reason
-[@bs.deriving jsConverter]
-type fruit =
-  | Apple
-  | Orange
-  | Kiwi
-  | Watermelon;
-```
-
-```ocaml
-type fruit =
-  | Apple 
-  | Orange 
-  | Kiwi 
-  | Watermelon [@@bs.deriving jsConverter]
-```
-
-</CodeTab>
-
-This option causes `jsConverter` to, again, generate functions of the following types:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```reason
-let fruitToJs: fruit => int;
-
-let fruitFromJs: int => option(fruit);
-```
-
-```ocaml
-val fruitToJs : fruit -> int
-
-val fruitFromJs : int -> fruit option
-```
-
-</CodeTab>
-
-For `fruitToJs`, each fruit variant constructor would map into an integer, starting at 0, in the order they're declared.
-
-For `fruitFromJs`, the return value is an `option`, because not every int maps to a constructor.
-
-You can also attach a `[@bs.as alternativeIntValue]` to each constructor to customize their output.
-
-### Usage
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```reason
-[@bs.deriving jsConverter]
-type fruit =
-  | Apple
-  | [@bs.as 10] Orange
-  | [@bs.as 100] Kiwi
-  | Watermelon;
-
-let zero = fruitToJs(Apple); /* 0 */
-
-switch (fruitFromJs(100)) {
-| Some(Kiwi) => Js.log("this is Kiwi")
-| _ => Js.log("received something wrong from the JS side")
-};
-```
-
-```ocaml
-type fruit =
-  | Apple 
-  | Orange [@bs.as 10]
-  | Kiwi [@bs.as 100]
-  | Watermelon [@@bs.deriving jsConverter]
-
-let zero = fruitToJs Apple;;
-
-match fruitFromJs 100 with
-  | ((Some (Kiwi))[@explicit_arity ]) -> Js.log "this is Kiwi"
-  | _ -> Js.log "received something wrong from the JS side"
-```
-
-</CodeTab>
-
-**Note**: by using `bs.as` here, all subsequent number encoding changes. `Apple` is still `0`, `Orange` is `10`, `Kiwi` is `100` and `Watermelon` is **`101`**!
-
-### More Safety
-
-Similar to the JS object \<-> record deriving, you can hide the fact that the JS enum are ints by using the same `newType` option with `[@bs.deriving jsConverter]`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```reason
-[@bs.deriving {jsConverter: newType}]
-type fruit =
-  | Apple
-  | [@bs.as 100] Kiwi
-  | Watermelon;
-```
-
-```ocaml
-type fruit =
-  | Apple 
-  | Kiwi [@bs.as 100]
-  | Watermelon [@@bs.deriving { jsConverter = newType }]
-```
-
-</CodeTab>
-
-This option causes `jsConverter` to generate functions of the following types:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```reason
-let fruitToJs: fruit => abs_fruit;
-
-let fruitFromJs: abs_fruit => fruit;
-```
-
-```ocaml
-val fruitToJs : fruit -> abs_fruit
-
-val fruitFromJs : abs_fruit -> fruit
-```
-
-</CodeTab>
-
-For `fruitFromJs`, the return value, unlike the previous non-abstract type case, doesn't contain an `option`, because there's no way a bad value can be passed into it; the only creator of `abs_fruit` values is `fruitToJs`!
-
-#### Usage
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```reason
-[@bs.deriving {jsConverter: newType}]
-type fruit =
-  | Apple
-  | [@bs.as 100] Kiwi
-  | Watermelon;
-
-let opaqueValue = fruitToJs(Apple);
-
-[@bs.module "myJSFruits"] external jsKiwi : abs_fruit = "iSwearThisIsAKiwi";
-let kiwi = fruitFromJs(jsKiwi);
-
-let error = fruitFromJs(100); /* nope, can't take a random int */
-```
-
-```ocaml
-type fruit =
-  | Apple 
-  | Kiwi [@bs.as 100]
-  | Watermelon [@@bs.deriving { jsConverter = newType }]
-
-let opaqueValue = fruitToJs Apple
-
-external jsKiwi : abs_fruit = "iSwearThisIsAKiwi"[@@bs.module "myJSFruits"]
-
-let kiwi = fruitFromJs jsKiwi
-let error = fruitFromJs 100
-```
-
-</CodeTab>
-
-## Generate Converters for JS String Enums and Polymorphic Variants
-
-> **Note**: Since ReScript 8.2, polymorphic variants are already compiled to strings, so this feature is getting deprecated at some point. It's currently still useful for aliasing JS output with `@bs.as`.
-
-Similarly as with [generating int converters](#generate-converters-between-js-integer-enums-and-variants), use `[@bs.deriving jsConverter]` on a polymorphic variant type to create converter functions for JS string and ReScript poly variant values.
-
-### Usage
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```reason
-[@bs.deriving jsConverter]
-type fruit = [
-  | `Apple
-  | [@bs.as "miniCoconut"] `Kiwi
-  | `Watermelon
-];
-
-let appleString = fruitToJs(`Apple); /* "Apple" */
-let kiwiString = fruitToJs(`Kiwi); /* "miniCoconut" */
-```
-
-```ocaml
-type fruit = [
-  | `Apple 
-  | `Kiwi [@bs.as "miniCoconut"]
-  | `Watermelon
-] [@@bs.deriving jsConverter]
-
-let appleString = fruitToJs `Apple
-let kiwiString = fruitToJs `Kiwi
-```
-
-</CodeTab>
-
-You can also use `[@bs.deriving {jsConverter: newType}]` to generate abstract types instead.
-
-## Convert Record Type to Abstract Record
-
-> **Note**: For ReScript >= v7, we recommend using [plain records to compile to JS objects](bind-to-js-object#bind-to-record-like-js-objects). 
-> This feature might still be useful for certain scenarios, but the ergonomics might be worse 
-
-Use `[@bs.deriving abstract]` on a record type to expand the type into a creation, and a set of getter / setter functions for fields and methods.
-
-Usually you'd just use ReScript records to compile to JS objects of the same shape. There is still one particular use-case left where the `[@bs.deriving abstract]` convertion is still useful: Whenever you need compile a record with an optional field where the JS object attribute shouldn't show up in the resulting JS when undefined (e.g. `{name: "Carl", age: undefined}` vs `{name: "Carl"}`). Check the [Optional Labels](#optional-labels) section for more infos on this particular scenario.
-
-### Usage Example
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-[@bs.deriving abstract]
-type person = {
-  name: string,
-  age: int,
-  job: string,
-};
-
-[@bs.val] external john : person = "john";
-```
-
-```ocaml
-type person = {
-  name: string;
-  age: int;
-  job: string;
-} [@@bs.deriving abstract]
-
-external john : person = "john" [@@bs.val]
-```
-
-</CodeTab>
-
-**Note**: the `person` type is **not** a record! It's a record-looking type that uses the record's syntax and type-checking. The `[@bs.deriving abstract]` decorator turns it into an "abstract type" (aka you don't know what the actual value's shape).
-
-### Creation
-
-You don't have to bind to an existing `person` object from the JS side. You can also create such `person` JS object from ReScript's side.
-
-Since `[@bs.deriving abstract]` turns the above `person` record into an abstract type, you can't directly create a person record as you would usually. This doesn't work: `{name: "Joe", age: 20, job: "teacher"}`.
-
-Instead, you'd use the **creation function** of the same name as the record type, implicitly generated by the `[@bs.deriving abstract]` annotation:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-let joe = person(~name="Joe", ~age=20, ~job="teacher")
-```
-
-```ocaml
-let joe = person ~name:"Joe" ~age:20 ~job:"teacher"
-```
-
-```js
-var joe = {
-  name: "Joe",
-  age: 20,
-  job: "teacher"
-};
-```
-
-</CodeTab>
-
-Note how in the example above there is no JS runtime overhead.
-
-#### Rename Fields
-
-Sometimes you might be binding to a JS object with field names that are invalid in ReScript/Reason. Two examples would be `{type: "foo"}` (reserved keyword in ReScript/Reason) and `{"aria-checked": true}`. Choose a valid field name then use `[@bs.as]` to circumvent this:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-[@bs.deriving abstract]
-type data = {
-  [@bs.as "type"] type_: string,
-  [@bs.as "aria-label"] ariaLabel: string,
-};
-
-let d = data(~type_="message", ~ariaLabel="hello");
-```
-
-```ocaml
-type data = {
-  type_: string [@bs.as "type"];
-  ariaLabel: string [@bs.as "aria-label"];
-} [@@bs.deriving abstract]
-
-let d = data ~type_:"message" ~ariaLabel:"hello"
-```
-
-```js
-var d = {
-  type: "message",
-  "aria-label": "hello"
-};
-```
-
-</CodeTab>
-
-#### Optional Labels
-
-You can omit fields during the creation of the object:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-[@bs.deriving abstract]
-type person = {
-  [@bs.optional] name: string,
-  age: int,
-  job: string,
-};
-
-let joe = person(~age=20, ~job="teacher", ());
-```
-
-```ocaml
-type person = {
-  name: string [@bs.optional];
-  age: int;
-  job: string;
-} [@@bs.deriving abstract]
-
-let joe = person ~age:20 ~job:"teacher" ()
-```
-
-```js
-var joe = {
-  age: 20,
-  job: "teacher"
-};
-```
-
-</CodeTab>
-
-Optional values that are not defined, will not show up as an attribute in the resulting JS object. In the example above, you will see that `name` was omitted.
-
-**Note** that the `[@bs.optional]` tag turned the `name` field optional. Merely typing `name` as `option(string)` wouldn't work.
-
-**Note**: now that your creation function contains optional fields, we mandate an unlabeled `()` at the end to indicate that [you've finished applying the function](function#optional-labeled-arguments).
-
-### Accessors
-
-Again, since `[@bs.deriving abstract]` hides the actual record shape, you can't access a field using e.g. `joe.age`. We remediate this by generating getter and setters.
-
-#### Read
-
-One getter function is generated per `bs.deriving abstract` record type field. In the above example, you'd get 3 functions: `nameGet`, `ageGet`, `jobGet`. They take in a `person` value and return `string`, `int`, `string` respectively:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-let twenty = ageGet(joe)
-```
-
-```ocaml
-let twenty = ageGet joe
-```
-
-</CodeTab>
-
-Alternatively, you can use the [Pipe](pipe) operator (`->`) for a nicer-looking access syntax:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-let twenty = joe->ageGet
-```
-
-```ocaml
-let twenty = joe |. ageGet
-```
-
-</CodeTab>
-
-If you prefer shorter names for the getter functions, we also support a `light` setting:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-[@bs.deriving {abstract: light}]
-type person = {
-  name: string,
-  age: int,
-};
-
-let joe = person(~name="Joe", ~age=20);
-let joeName = name(joe);
-```
-
-```ocaml
-type person = {
-  name: string;
-  age: int;
-} [@@bs.deriving {abstract = light}]
-
-let joe = person ~name:"Joe" ~age:20
-let joeName = name joe
-```
-
-</CodeTab>
-
-The getter functions will now have the same names as the object fields themselves.
-
-#### Write
-
-A `[@bs.deriving abstract]` value is immutable by default. To mutate such value, you need to first mark one of the abstract record field as `mutable`, the same way you'd mark a normal record as mutable:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-[@bs.deriving abstract]
-type person = {
-  name: string,
-  mutable age: int,
-  job: string,
-};
-```
-
-```ocaml
-type person = {
-  name: string;
-  mutable age: int;
-  job: string;
-} [@@bs.deriving abstract]
-```
-
-</CodeTab>
-
-Then, a setter of the name `ageSet` will be generated. Use it like so:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-let joe = person(~name="Joe", ~age=20, ~job="teacher");
-ageSet(joe, 21);
-```
-
-```ocaml
-let joe = person ~name:"Joe" ~age:20 ~job:"teacher"
-let () = ageSet joe 21
-```
-
-</CodeTab>
-
-Alternatively, with the Pipe First syntax:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-joe->ageSet(21)
-```
-
-```ocaml
-joe |. ageSet 21
-```
-
-</CodeTab>
-
-### Methods
-
-You can attach arbitrary methods onto a type (_any_ type, as a matter of fact. Not just `[@bs.deriving abstract]` record types). See [Object Method](bind-to-js-function#object-method) in the "Bind to JS Function" section for more infos.
-
-### Tips & Tricks
-
-You can leverage `[@bs.deriving abstract]` for finer-grained access control.
-
-#### Mutability
-
-You can mark a field as mutable in the implementation (`ml`/`re`) file, while _hiding_ such mutability in the interface file:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-/* test.re */
-[@bs.deriving abstract]
-type cord = {
-  [@bs.optional] mutable x: int,
-  y: int,
-};
-```
-
-```ocaml
-(* test.ml *)
-type cord = {
-  mutable x: int [@bs.optional];
-  y: int;
-} [@@bs.deriving abstract]
-```
-
-</CodeTab>
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-/* test.rei */
-[@bs.deriving abstract]
-type cord = {
-  [@bs.optional] x: int,
-  y: int,
-};
-```
-
-```ocaml
-(* test.mli *)
-type cord = {
-  x: int [@bs.optional];
-  y: int;
-} [@@bs.deriving abstract]
-```
-
-</CodeTab>
-
-Tada! Now you can mutate inside your own file as much as you want, and prevent others from doing so!
-
-#### Hide the Creation Function
-
-Mark the record as `private` to disable the creation function:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-[@bs.deriving abstract]
-type cord = pri {
-  [@bs.optional] x: int,
-  y: int,
-};
-```
-
-```ocaml
-type cord = private {
-  x: int [@bs.optional];
-  y: int
-} [@@bs.deriving abstract]
-```
-
-</CodeTab>
-
-The accessors are still there, but you can no longer create such data structure. Great for binding to a JS object while preventing others from creating more such object!
-
-#### Use submodules to prevent naming collisions and binding shadowing
-
-Oftentimes you will have multiple abstract types with similar attributes. Since
-ReScript will expand all abstract getter, setter and creation functions in the
-same scope where the type is defined, you will eventually run into value shadowing problems.
-
-**For example:**
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-[@bs.deriving abstract]
-type person = {name: string};
-
-[@bs.deriving abstract]
-type cat = {
-  name: string,
-  isLazy: bool,
-};
-
-let person = person(~name="Alice");
-
-/* Error: This expression has type person but an expression was expected
-   of type cat */
-person->nameGet();
-```
-
-```ocaml
-type person = { name: string }[@@bs.deriving abstract]
-type cat = {
-  name: string;
-  isLazy: bool
-}[@@bs.deriving abstract]
-
-let person = person ~name:"Alice";;
-
-(person |. nameGet) ()
-```
-
-</CodeTab>
-
-To get around this issue, you can use modules to group a type with its related
-functions and later use them via local open statements:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-module Person = {
-  [@bs.deriving abstract]
-  type t = {name: string};
-};
-
-module Cat = {
-  [@bs.deriving abstract]
-  type t = {
-    name: string,
-    isLazy: bool,
-  };
-};
-
-let person = Person.t(~name="Alice");
-let cat = Cat.t(~name="Snowball", ~isLazy=true);
-
-/* We can use each nameGet function separately now */
-let shoutPersonName = Person.(person->nameGet->Js.String.toUpperCase);
-
-/* Note how we use a local open Cat.([some expression]) to 
-   get access to Cat's nameGet function */
-let whisperCatName = Cat.(cat->nameGet->Js.String.toLowerCase);
-```
-
-```ocaml
-module Person =
-  struct type t = { name: string }[@@bs.deriving abstract] end
-
-module Cat = struct type t = {
-  name: string;
-  isLazy: bool
-}[@@bs.deriving abstract] end
-
-let person = Person.t ~name:"Alice"
-let cat = Cat.t ~name:"Snowball" ~isLazy:true
-
-let shoutPersonName =
-  let open Person in (person |. nameGet) |. Js.String.toUpperCase
-
-let whisperCatName =
-  let open Cat in (cat |. nameGet) |. Js.String.toLowerCase
-```
-
-</CodeTab>
-
-## Convert External into JS Object Creation Function
-
-Use `@bs.obj` on an `external` binding to create a function that, when called, will evaluate to a `Js.t` object with fields corresponding to the function's parameter labels.
-
-This is very handy because you can make some of those labelled parameters optional and if you don't pass them in, the output object won't include the corresponding fields. Thus you can use it to dynamically create objects with the subset of fields you need at runtime.
-
-For example, suppose you need a JavaScript object like this:
-
-
-```js
-var homeRoute = {
-  method: "GET",
-  path: "/",
-  action: () => console.log("Home"),
-  // options: ...
-};
-```
-
-But only the first three fields are required; the options field is optional. You can declare the binding function like so:
-
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-[@bs.obj] external route: (
-  ~_method:string,
-  ~path:string,
-  ~action:(list(string) => unit),
-  ~options:Js.t({..})=?,
-  unit
-) => _ = "";
-```
-
-```ocaml
-external route :
-  _method:string ->
-  path:string ->
-  action:(string list -> unit) ->
-  ?options:< .. > Js.t ->
-  unit ->
-  _ = "" [@@bs.obj]
-```
-
-</CodeTab>
-
-**Note**: the ` = ""` part at the end is just a dummy placeholder, due to syntactic limitations. It serves no purpose currently.
-
-This function has four labelled parameters (the fourth one optional), one unlabelled parameter at the end (which we mandate for functions with [optional parameters](function#optional-labeled-arguments), and one parameter (`_method`) that requires an underscore prefix to avoid confusion with the ReScript keyword `method`.
-
-Also of interest is the return type: `_`, which tells ReScript to automatically infer the full type of the `Js.t` object, sparing you the hassle of writing down the type manually!
-
-The function is called like so:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```reason
-let homeRoute = route(~_method="GET", ~path="/", ~action=(_ => Js.log("Home")), ());
-```
-
-```ocaml
-let homeRoute = route ~_method:"GET" ~path:"/" ~action:(fun _ -> Js.log "Home") ()
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v8.0.0/import-export.mdx b/pages/docs/manual/v8.0.0/import-export.mdx
deleted file mode 100644
index 6700304d0..000000000
--- a/pages/docs/manual/v8.0.0/import-export.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: "Import & Export"
-description: "Importing / exporting in ReScript modules"
-canonical: "/docs/manual/latest/import-export"
----
-
-# Import & Export
-
-## Import a Module/File
-
-Unlike JavaScript, ReScript doesn't have or need import statements:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-// Inside School.re
-let studentMessage = Student.message;
-```
-```ml
-(* Inside School.re *)
-let studentMessage = Student.message
-```
-```js
-var Student = require("./Student.bs");
-var studentMessage = Student.message
-```
-
-</CodeTab>
-
-The above code refers to the `message` binding in the file `Student.re`. Every ReScript file is also a module, so accessing another file's content is the same as accessing another module's content!
-
-A ReScript project's file names need to be unique.
-
-## Export Stuff
-
-By default, every file's type declaration, binding and module is exported, aka publicly usable by another file. **This also means those values, once compiled into JS, are immediately usable by your JS code**.
-
-To only export a few selected things, use an [interface file](module.md#signatures).
-
-## Work with JavaScript Import & Export
-
-To see how to import JS modules and export stuff for JS consumption, see the JavaScript Interop section's [Import from/Export to JS](import-from-export-to-js.md).
diff --git a/pages/docs/manual/v8.0.0/import-from-export-to-js.mdx b/pages/docs/manual/v8.0.0/import-from-export-to-js.mdx
deleted file mode 100644
index 495ffcf1f..000000000
--- a/pages/docs/manual/v8.0.0/import-from-export-to-js.mdx
+++ /dev/null
@@ -1,144 +0,0 @@
----
-title: "Import from / Export to JS"
-description: "Importing / exporting JS module content in ReScript"
-canonical: "/docs/manual/latest/import-from-export-to-js"
----
-
-# Import from/Export to JS
-
-You've seen how ReScript's idiomatic [Import & Export](import-export.md) works. This section describes how we work with importing stuff from JavaScript and exporting stuff for JavaScript consumption.
-
-## Import From JavaScript
-
-### Import a JavaScript Module's Content
-
-Use the `bs.module` [external](external.md):
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-// Import nodejs' path.dirname
-[@bs.module "path"] external dirname: string => string = "dirname";
-let root = dirname("/User/github"); // returns "User"
-```
-```ml
-(* Import nodejs' path.dirname *)
-external dirname: string -> string = "dirname" [@@bs.module "path"]
-let root = dirname "/User/github" (* returns "User" *)
-```
-```js
-var Path = require("path");
-var root = Path.dirname("/User/github");
-```
-
-</CodeTab>
-
-Here's what the `external` does:
-
-- `[@bs.module "path"]`: pass the name of the JS module as a string; in this case, `"path"`. The string can be anything: `"./src/myJsFile"`, `"@myNpmNamespace/myLib"`, etc.
-- `external`: the general keyword for declaring a value that exists on the JS side.
-- `dirname`: the binding name you'll use on the ReScript side.
-- `string => string`: the type signature of `dirname`.
-- `= "dirname"`: the name of the variable inside the `path` JS module. There's repetition in writing the first and second `dirname`, because sometime the binding name you want to use on the ReScript side is different than the variable name the JS module exported.
-
-### Import a JavaScript Module Itself (CommonJS)
-
-By omitting the string argument to `bs.module`, you bind to the whole JS module:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.module] external leftPad: string => int => string = "./leftPad";
-let paddedResult = leftPad("hi", 5);
-```
-```ml
-external leftPad: string -> int -> string = "./leftPad" [@@bs.module]
-let paddedResult = leftPad "hi" 5
-```
-```js
-var LeftPad = require("./leftPad");
-var paddedResult = LeftPad("hi", 5);
-```
-
-</CodeTab>
-
-### Import a JavaScript Module Itself (ES6 Module Format)
-
-If your JS project is using ES6, you're likely using Babel to compile it to regular JavaScript. Babel's ES6 default export actually exports the default value under the name `default`. You'd bind to it like this:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.module "./student"] external studentName: string = "default";
-Js.log(studentName);
-```
-```ml
-external studentName: string = "default" [@@bs.module "./student"]
-let () = Js.log studentName
-```
-```js
-var Student = require("./student");
-console.log(Student.default);
-```
-
-</CodeTab>
-
-## Export To JavaScript
-
-As mentioned in ReScript's idiomatic [Import & Export](import-export.md), every let binding and module is exported by default to other ReScript modules. If you open up the compiled JS file, you'll see that these values can also directly be used by another _JavaScript_ file too.
-
-We support 2 JS export formats:
-
-- CommonJS (usable from JS as `require('myFile')`).
-- ES6 modules (usable from JS as `import * from 'myFile'`).
-
-The output format is [configurable in bsb](build-configuration.md#package-specs).
-
-### Export an ES6 default value
-
-If your JS project is using ES6 modules, you're likely exporting & importing some default values:
-
-```js
-// student.js
-export default name = "Al";
-```
-
-```js
-// teacher.js
-import studentName from 'student.js';
-```
-
-Technically, since a ReScript file maps to a module, there's no such thing as "default" export, only named ones. However, we've made an exception to support default module when you do the following:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-/* FavoriteStudent.re */
-let default = "Bob";
-```
-```re
-(* FavoriteStudent.re *)
-let default = "Bob"
-```
-```js
-var $$default = "Bob";
-
-exports.$$default = $$default;
-exports.default = $$default;
-exports.__esModule = true;
-```
-
-</CodeTab>
-
-You can then require the default as normal JS side:
-
-```js
-// teacher2.js
-import studentName from 'FavoriteStudent.js';
-```
-
-**Note**: the above JS snippet _only_ works if you're using that ES6 import/export syntax in JS. If you're still using `require`, you'd need to do:
-
-```js
-let studentName = require('FavoriteStudent').default;
-```
diff --git a/pages/docs/manual/v8.0.0/installation.mdx b/pages/docs/manual/v8.0.0/installation.mdx
deleted file mode 100644
index c92b34df2..000000000
--- a/pages/docs/manual/v8.0.0/installation.mdx
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: "Installation"
-description: "ReScript installation and setup instructions"
-canonical: "/docs/manual/latest/installation"
----
-
-# Installation
-
-Prerequisite: NPM, which comes with [NodeJS](https://nodejs.org/en/). [Yarn](https://yarnpkg.com/en/) also works.
-
-To install ReScript globally:
-
-```sh
-npm install -g bs-platform
-```
-
-## New Project
-
-**Note**: this starts a new project with the new syntax, not the old Reason syntax.
-
-```sh
-git clone https://github.com/rescript-lang/rescript-project-template
-cd rescript-project-template
-npm install
-npm run build
-node src/Demo.bs.js
-```
-
-<!-- TODO: rescript template -->
-
-That compiles your ReScript into JavaScript, then uses NodeJS to run said JavaScript. **We recommend you use our highly unique workflow of keeping a tab open for the generated `.bs.js` file**, so that you can learn how ReScript transforms to JavaScript. Not many languages output clean JavaScript code you can manually inspect!
-
-During development, instead of running `npm run build` each time to compile, use `npm run start` to start a watcher that recompiles automatically after file changes.
-
-Alternatively, **to start a [ReasonReact](https://reasonml.github.io/reason-react/en/) app**, follow the instructions [here](https://reasonml.github.io/reason-react/docs/en/installation).
-
-## Integrate Into Existing JS Project
-
-You can install the toolchain locally to an existing JS project, through the familiar command:
-
-```sh
-npm install --save-dev bs-platform
-```
-
-The rest is the same as above. Since we output clean `.bs.js` files, the rest of your existing toolchain (e.g. Babel and Webpack) should mostly just work. Nothing to learn on the bundling side!
diff --git a/pages/docs/manual/v8.0.0/interop-cheatsheet.mdx b/pages/docs/manual/v8.0.0/interop-cheatsheet.mdx
deleted file mode 100644
index 2dda1acc1..000000000
--- a/pages/docs/manual/v8.0.0/interop-cheatsheet.mdx
+++ /dev/null
@@ -1,280 +0,0 @@
----
-title: "Interop Cheatsheet"
-description: "Cheatsheet for various interop scenarios in ReScript"
-canonical: "/docs/manual/latest/interop-cheatsheet"
----
-
-# Interop Cheatsheet
-
-<!-- TODO: this should be a glossary instead -->
-
-## Raw JS
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let add = [%raw "(a, b) => a + b"];
-[%%raw "const a = 1"];
-```
-```ml
-let add = [%raw "(a, b) => a + b"]
-[%%raw "const a = 1"]
-```
-```js
-var add = ((a, b) => a + b);
-const a = 1
-```
-
-</CodeTab>
-
-## Global Value
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.val] external setTimeout: (unit => unit, int) => float = "setTimeout";
-```
-```ml
-external setTimeout: (unit -> unit) -> int -> float = "setTimeout" [@@bs.val]
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Global Module's Value
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.val] [@bs.scope "Math"]
-external random: unit => float = "random";
-
-let someNumber = random();
-
-[@bs.val] [@bs.scope ("window", "location", "ancestorOrigins")]
-external length: int = "length";
-```
-```ml
-external random: unit -> float = "random"
-[@@bs.val][@@bs.scope "Math"]
-
-let someNumber = random ()
-
-external length: int = "length"
-[@@bs.val][@@bs.scope ("window", "location", "ancestorOrigins")]
-```
-```js
-var someNumber = Math.random();
-```
-
-</CodeTab>
-
-## Nullable
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let a = Some(5); // compiles to 5
-let b = None; // compiles to undefined
-```
-```ml
-let a = Some 5 (* compiles to 5 *)
-let b = None (* compiles to undefined *)
-```
-```js
-var a = 5;
-var b;
-```
-
-</CodeTab>
-
-Handling a value that can be `undefined` and `null`, by ditching the `option` type and using `Js.Nullable.t`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let jsNull = Js.Nullable.null;
-let jsUndefined = Js.Nullable.undefined;
-let result1: Js.Nullable.t(string) = Js.Nullable.return("hello");
-let result2: Js.Nullable.t(int) = Js.Nullable.fromOption(Some(10));
-let result3: option(int) = Js.Nullable.toOption(Js.Nullable.return(10));
-```
-```ml
-let jsNull = Js.Nullable.null
-let jsUndefined = Js.Nullable.undefined
-let result1: string Js.Nullable.t = Js.Nullable.return "hello"
-let result2: int Js.Nullable.t = Js.Nullable.fromOption (Some 10)
-let result3: int option = Js.Nullable.toOption (Js.Nullable.return 10)
-```
-```js
-var Caml_option = require("./stdlib/caml_option.js");
-var Js_null_undefined = require("./stdlib/js_null_undefined.js");
-
-var jsNull = null;
-var jsUndefined;
-var result1 = "hello";
-var result2 = Js_null_undefined.fromOption(10);
-var result3 = Caml_option.nullable_to_opt(10);
-```
-
-</CodeTab>
-
-## JS Object
-
-- [Bind to a JS object as a ReScript record](bind-to-js-object#bind-to-record-like-js-objects).
-- [Bind to a JS object that acts like a hash map](bind-to-js-object#bind-to-hash-map-like-js-object).
-- [Bind to a JS object that's a class](bind-to-js-object#bind-to-a-js-object-thats-a-class).
-
-## Function
-
-### Object Method & Chaining
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.send] external map: (array('a), 'a => 'b) => array('b) = "map";
-[@bs.send] external filter: (array('a), 'a => 'b) => array('b) = "filter";
-[|1, 2, 3|]
-  ->map(a => a + 1)
-  ->filter(a => a mod 2 == 0)
-  ->Js.log;
-```
-```ml
-external map: 'a array -> ('a -> 'b) -> 'b array = "map" [@@bs.send]
-external filter: 'a array -> ('a -> 'b) -> 'b array = "filter" [@@bs.send]
-[|1; 2; 3|]
-  |. map(fun a -> a + 1)
-  |. filter(fun a -> a mod 2 = 0)
-  |. Js.log
-```
-```js
-console.log(
-  [1, 2, 3]
-    .map(function (a) {
-      return (a + 1) | 0;
-    })
-    .filter(function (a) {
-      return a % 2 === 0;
-    })
-);
-```
-
-</CodeTab>
-
-### Variadic Arguments
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.module "path"] [@bs.variadic]
-external join: array(string) => string = "join";
-```
-```ml
-external join: string array -> string = "join"
-[@@bs.module "path"][@@bs.variadic]
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-### Polymorphic Function
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.module "Drawing"] external drawCat: unit => unit = "draw";
-[@bs.module "Drawing"] external drawDog: (~giveName: string) => unit = "draw";
-```
-```ml
-external drawCat: unit -> unit = "draw" [@@bs.module "Drawing"]
-external drawDog: giveName:string -> unit = "draw" [@@bs.module "Drawing"]
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.val]
-external padLeft: (
-  string,
-  [@bs.unwrap] [
-    | `Str(string)
-    | `Int(int)
-  ])
-  => string = "padLeft";
-
-padLeft("Hello World", `Int(4));
-padLeft("Hello World", `Str("Message from ReScript: "));
-```
-```ml
-external padLeft:
-  string ->
-  (([
-    | `Str of string
-    | `Int of int
-  ]) [@bs.unwrap]) ->
-  string = "padLeft" [@@bs.val]
-
-let _ = padLeft "Hello World" (`Int 4)
-let _ = padLeft "Hello World" (`Str "Message from ReScript: ")
-```
-```js
-padLeft("Hello World", 4);
-padLeft("Hello World", "Message from ReScript: ");
-```
-
-</CodeTab>
-
-## JS Module Interop
-
-[See here](import-from-export-to-js.md)
-
-## Dangerous Type Cast
-
-Final escape hatch converter. Do not abuse.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-external convertToFloat: int => float = "%identity";
-let age = 10;
-let gpa = 2.1 +. convertToFloat(age);
-```
-```ml
-external convertToFloat: int => float = "%identity"
-let age = 10
-let gpa = 2.1 +. (convertToFloat age)
-```
-```js
-var age = 10;
-var gpa = 2.1 + 10;
-```
-
-</CodeTab>
-
-## List of `@bs` Decorators
-
-- `@bs.as`
-- `@bs.get`
-- `@bs.inline`
-- `@bs.int`
-- `@bs.meth`
-- `@bs.new`
-- `@bs.return`
-- `@bs.scope`
-- `@bs.send`
-- `@bs.set`
-- `@bs.string`
-- `@bs.this`
-- `@bs.uncurry`
-- `@bs.unwrap`
-- `@bs.val`
-- `@bs.variadic`
diff --git a/pages/docs/manual/v8.0.0/interop-with-js-build-systems.mdx b/pages/docs/manual/v8.0.0/interop-with-js-build-systems.mdx
deleted file mode 100644
index 0913040e2..000000000
--- a/pages/docs/manual/v8.0.0/interop-with-js-build-systems.mdx
+++ /dev/null
@@ -1,57 +0,0 @@
----
-title: "Interop with JS Build Systems"
-description: "Documentation on how to interact with existing JS build systems"
-canonical: "/docs/manual/latest/interop-with-js-build-systems"
----
-
-# Interop with JS Build Systems
-
-If you come from JS, chances are that you already have a build system in your existing project. Here's an overview of the role bsb would play in your build pipeline, if you want to introduce some ReScript code into the codebase.
-
-> As much as possible, please try not to wrap bsb into your own incremental build framework. ReScript's compilation is very hard to get right, and you'll inevitably run into stale or badly performing builds (therefore erasing much of our value proposition) if you create your own meta layer on top.
-
-## Popular JS Build Systems
-
-The JS ecosystem uses a few build systems: [browserify](http://browserify.org/), [rollup](https://github.com/rollup/rollup), [webpack](https://webpack.js.org/), etc. The latter's probably the most popular of the three (as of 2019 =P). These build systems do both the compilation and the linking (aka, bundling many files into one or few files).
-
-ReScript and bsb only take care of the compilation step; it maps one `.re`/`.rei` file into one JS output file. As such, in theory, no build system integration is needed from our side. From e.g. the webpack watcher's perspective, the JS files ReScript generates are almost equivalent to your hand-written JS files. We also recommend that you initially check in those ReScript-generated JS files, as this workflow means:
-
-- You can introduce ReScript silently into your codebase without disturbing existing infra.
-- You have a **visual** diff of the performance & correctness of your JS file when you update the `.re` files and the JS artifacts change.
-- You can let teammates hot-patch the JS files in emergency situations, without needing to first start learning ReScript.
-- You can remove ReScript completely from your codebase and things will still work (in case your company decides to stop using us for whatever reason).
-
-For what it's worth, you can also turn bsb into an automated step in your build pipeline, e.g. into a webpack loader; but such approach is error-prone and therefore discouraged.
-
-### Tips & Tricks
-
-You can make ReScript JS files look even more idiomatic through the in-source + bs suffix config in `bsconfig.json`:
-
-```json
-{
-  "package-specs": {
-    "module": "commonjs", // or whatever module system your project uses
-    "in-source": true
-  },
-  "suffix": ".bs.js"
-}
-```
-
-This will:
-
-- Generate the JS files alongside your ReScript source files.
-- Use the file extension `.bs.js`, so that you can require these files on the JS side through `require('./MyFile.bs')`, without needing a loader.
-
-## Use Loaders on ReScript Side
-
-"What if my build system uses a CSS/png/whatever loader and I'd like to use it in ReScript?"
-
-Loaders are indeed troublesome; in the meantime, please use e.g. `%raw("require('./myStyles.css')")` at the top of your file. This just uses [`raw`](embed-raw-javascript.md) to compile the snippet into an actual JS require.
-
-## Getting Project's Dependencies
-
-`bsb` generates one `MyFile.mlast.d` file per `MyFile` source file; you'll find them in `lib/bs`. These are human readable, machine-friendly list of the dependencies of said `MyFile`. You can read into them for your purpose (though mind the IO overhead). Use these files instead of creating your own dependency graph; we did the hard work of tracking the dependencies as best as possible (including inner modules, `open`s, module names overlap, etc).
-
-## Run Script Per File Built
-
-See [js-post-build](build-configuration#js-post-build). Though please use it sparingly; if you hook up a node.js script after each file built, you'll incur the node startup time per file!
diff --git a/pages/docs/manual/v8.0.0/introduction.mdx b/pages/docs/manual/v8.0.0/introduction.mdx
deleted file mode 100644
index 654a991ce..000000000
--- a/pages/docs/manual/v8.0.0/introduction.mdx
+++ /dev/null
@@ -1,79 +0,0 @@
----
-title: "Introduction"
-description: "The hows and whys of ReScript"
-canonical: "/docs/manual/latest/introduction"
----
-
-# ReScript
-
-Ever wanted a language like JavaScript, but without the warts, with a great type system, and with a lean build toolchain that doesn't waste your time?
-
-ReScript looks like JS, acts like JS, and compiles to the highest quality of clean, readable and performant JS, directly runnable in browsers and Node.
-
-**This means you can pick up ReScript and access the vast JavaScript ecosystem and tooling as if you've known ReScript for a long time**!
-
-**ReScript is the language for folks who don't necessarily love JavaScript, but who still acknowledge its importance**.
-
-## Difference vs TypeScript
-
-We respect TypeScript very much and think that it's a positive force in the JavaScript ecosystem. ReScript shares some of the same goals as TypeScript, but is different enough regarding some important nuances:
-
-- TypeScript's (admittedly noble) goal is to cover the entire JavaScript feature set and more. **ReScript covers only a curated subset of JavaScript**. For example, we emphasize plain data + functions over classes, clean [pattern matching](pattern-matching-destructuring.md) over fragile `if`s and dynamic object dispatches, [proper data modeling](variant.md) over string abuse, etc. JavaScript supersets will only grow larger over time; ReScript doesn't. \*
-
-- Consequently, TypeScript's type system is necessarily complex, pitfalls-ridden, potentially requires tweaking, sometime slow, and requires quite a bit of noisy annotations that often feel like manual bookkeeping rather than clear documentation. In contrast, ReScript's type system:
-  - Is deliberately curated to be a simple subset most folks will have an easier time to use.
-  - Has **no** pitfalls, aka the type system is "sound" (the types will always be correct). E.g. If a type isn't marked as nullable, its value will never lie and let through some `undefined` value silently. **ReScript code has no null/undefined errors**.
-  - Is the same for everyone. No knobs, no bikeshedding opportunity.
-  - Runs extremely fast precisely thanks to its simplicity and curation. We're one of the fastest compiler & build system for JavaScript development.
-  - **Doesn't need type annotations**. Annotate as much or as little as you'd like. The types are inferred by the language (and, again, are guaranteed correct).
-
-- Migrating to TypeScript is done "breadth-first", whereas migrating to ReScript is done "depth-first". You can convert your codebase to TypeScript by "turning it on" for all files and annotate here and there; but how much type safety did you gain? How do you measure it? Type errors can still slip in and out of the converted pieces. For ReScript, our interop features draws clear boundaries: there's pure ReScript code, and there's JS interop code. Every piece of converted ReScript code is 100% clean. You'd convert file by file and each conversion increases your safety monotonically.
-
-\* When you absolutely need to write or interoperate with free-for-all JavaScript, we expose enough escape hatches for you.
-
-## Other Highlights
-
-Aside from the aforementioned simple, robust and fast type system, ReScript presents a few more advantages.
-
-### Faster than JavaScript
-
-JavaScript's been aggressively optimized by talented engineers over a long span. Unfortunately, even for seasoned JS devs, it can be hard to know how to properly leverage JS' performance. ReScript's type system and compiler naturally guides you toward writing code that's very often performant by default, with good leverage of various Just-In-Time optimizations (hidden classes, inline caching, avoiding deopts, etc.).
-
-A widespread adage to write fast JavaScript code is to write as if there's a type system (in order to trigger JS engines' good optimization heuristics); ReScript gives you a real one and generates code that's friendly to optimizations by default.
-
-### High Quality Dead Code Elimination
-
-The JavaScript ecosystem is very reliant on dependencies. Shipping the final product inevitably drags in a huge amount of code, lots of which the project doesn't actually use. These regions of dead code impact loading, parsing and interpretation speed. ReScript provides powerful dead code elimination at all levels:
-
-- Function and module level code elimination is facilitated by the well-engineered type system and purity analysis.
-- At the global level, ReScript generates code that are naturally friendly to dead code elimination done by bundling tools such as [Rollup](https://github.com/rollup/rollup) and [Closure Compiler](https://developers.google.com/closure/compiler/), after its own sophisticated elimination pass.
-- The same applies for ReScript's own tiny runtime (which is written in ReScript itself).
-
-### Tiny JS Output
-
-A `Hello world` ReScript program generates **20 bytes** JS code. Additionally, the standard library pieces you require in are only include when needed.
-
-### Fast Iteration Loop
-
-ReScript's build time is **one or two orders of magnitude** faster than alternatives. In its watcher mode, the build system usually finishes before you switch screen from the editor to the terminal tab (two digits of milliseconds). A fast iteration cycle reduces need of keeping one's mental state around longer; this in turns allows one to stay in the flow longer and more often.
-
-### Readable Output & Great Interop
-
-Unreadable JavaScript code generated from other compiled-to-js languages makes it so that it could be, practically speaking:
-
-- Hard to debug (cryptic stack trace, mangled variable names)
-- Hard to learn from (non-straightforward mapping of concepts from one language to another)
-- Hard to profile for performance (unclear what runtime performance cost there is)
-- Hard to integrate with existing hand-written JS code
-
-ReScript's JS output is very readable. This is especially important while learning, where users might want to understand how the code's compiled, and to audit for bugs.
-
-This characteristic, combined with a fully-featured JS interop system, allows ReScript code to be inserted into an existing JavaScript codebase almost unnoticed.
-
-### Preservation of Code Structure
-
-ReScript maps one source file to one JavaScript output file. This eases the integration of existing tools such as bundlers and test runners. You can even start writing a single file without much change your build setup. Each file's code structure is approximately preserved, too.
-
-## Conclusion
-
-We hope the above gave you enough of an idea of ReScript and its differentiators. Feel free to [try it online](/try) to get a feel!
diff --git a/pages/docs/manual/v8.0.0/json.mdx b/pages/docs/manual/v8.0.0/json.mdx
deleted file mode 100644
index 3e21ab7b0..000000000
--- a/pages/docs/manual/v8.0.0/json.mdx
+++ /dev/null
@@ -1,69 +0,0 @@
----
-title: "JSON"
-description: "Interacting with JSON in ReScript"
-canonical: "/docs/manual/latest/json"
----
-
-# JSON
-
-## Parse
-
-Bind to JavaScript's `JSON.parse` and type the return value as the type you're expecting:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-// declare the shape of the json you're binding to
-type data = {names: array(string)};
-
-// bind to JS' JSON.parse
-[@bs.scope "JSON"] [@bs.val]
-external parseIntoMyData: string => data = "parse";
-
-let result = parseIntoMyData({|{"names": ["Luke", "Christine"]}|});
-let name1 = result.names[0];
-```
-```ml
-(* declare the shape of the json you're binding to *)
-type data = {names: string array}
-
-(* bind to JS' JSON.parse *)
-external parseIntoMyData: string -> data = "parse"
-[@@bs.scope "JSON"] [@@bs.val]
-
-let result = parseIntoMyData {|{"names": ["Luke", "Christine"]}|}
-let name1 = (result.names).(0)
-```
-```js
-var result = JSON.parse("{\"names\": [\"Luke\", \"Christine\"]}");
-var name1 = result.names[0];
-```
-
-</CodeTab>
-
-Where `data` can be any type you assume the JSON is. As you can see, this compiles to a straightforward `JSON.parse` call. As with regular JS, this is convenient, but has no guarantee that e.g. the data is correctly shaped, or even syntactically valid. Slightly dangerous.
-
-## Stringify
-
-Use `Js.Json.stringify`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-Js.log(Js.Json.stringifyAny([|"Amy", "Joe"|]));
-```
-```ml
-Js.log (Js.Json.stringifyAny [|"Amy"; "Joe"|])
-```
-```js
-console.log(JSON.stringify([
-  "Amy",
-  "Joe"
-]));
-```
-
-</CodeTab>
-
-## Advanced
-
-The [Js.Json](api/js/json) module provides slightly safer, low-level building blocks for power users who want to parse JSON on a per-field basis. See the examples in the API docs.
diff --git a/pages/docs/manual/v8.0.0/jsx.mdx b/pages/docs/manual/v8.0.0/jsx.mdx
deleted file mode 100644
index 6639bad08..000000000
--- a/pages/docs/manual/v8.0.0/jsx.mdx
+++ /dev/null
@@ -1,299 +0,0 @@
----
-title: "JSX"
-description: "JSX syntax in ReScript and React"
-canonical: "/docs/manual/latest/jsx"
----
-
-# JSX
-
-Would you like some HTML syntax in your ReScript? If not, quickly skip over this section and pretend you didn't see anything!
-
-ReScript supports the JSX syntax, with some slight differences compared to the one in [ReactJS](https://facebook.github.io/react/docs/introducing-jsx.html). ReScript JSX isn't tied to ReactJS; they translate to normal function calls:
-
-**Note** for [ReasonReact](https://reasonml.github.io/reason-react/en/) readers: this isn't what ReasonReact turns JSX into, in the end. See Usage section for more info.
-
-## Capitalized Tag
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-<MyComponent name={"ReScript"} />;
-```
-```ml
-(* doesn't exist in old ML syntax *)
-```
-```js
-React.createElement(
-  MyComponent.make,
-  MyComponent.makeProps("ReScript", undefined)
-);
-```
-
-</CodeTab>
-
-becomes
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@JSX] MyComponent.createElement(~name="ReScript", ~children=[], ());
-```
-```ml
-MyComponent.createElement ~name:"ReScript" ~children:[] [@JSX]
-```
-```js
-React.createElement(
-  MyComponent.make,
-  MyComponent.makeProps("ReScript", undefined)
-);
-```
-
-</CodeTab>
-
-## Uncapitalized Tag
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-<div onClick={handler}> child1 child2 </div>;
-```
-```ml
-(* doesn't exist in old ML syntax *)
-```
-```js
-React.createElement("div", {
-  onClick: handler
-}, child1, child2);
-```
-
-</CodeTab>
-
-becomes
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@JSX] div(~onClick=handler, ~children=[child1, child2], ());
-```
-```ml
-div ~onClick:handler ~children:[child1; child2] () [@@JSX]
-```
-```js
-React.createElement("div", {
-  onClick: handler
-}, child1, child2);
-```
-
-</CodeTab>
-
-## Fragment
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-<> child1 child2 </>;
-```
-```ml
-(* doesn't exist in old ML syntax *)
-```
-```js
-React.createElement(React.Fragment, undefined, child1, child2);
-```
-
-</CodeTab>
-
-becomes
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@JSX] [child1, child2];
-```
-```ml
-[child1; child2] [@@JSX]
-```
-```js
-React.createElement(React.Fragment, undefined, child1, child2);
-```
-
-</CodeTab>
-
-### Children
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-<MyComponent> child1 child2 </MyComponent>;
-```
-```ml
-(* doesn't exist in old ML syntax *)
-```
-```js
-React.createElement(MyComponent.make, MyComponent.makeProps(null, undefined), child1, child2);
-```
-
-</CodeTab>
-
-This is the syntax for passing a list of two items, `child1` and `child2`, to the children position. It desugars to a list containing `child1` and `child2`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@JSX] MyComponent.createElement(~children=[child1, child2], ());
-```
-```ml
-MyComponent.createElement ~children:[child1; child2] () [@@JSX]
-```
-```js
-React.createElement(MyComponent.make, MyComponent.makeProps(null, undefined), child1, child2);
-```
-
-</CodeTab>
-
-**Note** again that this isn't the transform for ReasonReact; ReasonReact turns the final list into an array. But the idea still applies.
-
-So naturally, `<MyComponent> myChild </MyComponent>` desugars to `@JSX MyComponent.createElement(~children=[myChild], ())`. I.e. whatever you do, the arguments passed to the children position will be wrapped in a list. What if you don't want that? **What if you want to directly pass `myChild` without an extra wrapping**?
-
-#### Children Spread
-
-To solve the above problem, we've introduced
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-<MyComponent> ...myChild </MyComponent>;
-```
-```ml
-(* doesn't exist in old ML syntax *)
-```
-```js
-React.createElement(MyComponent.make, MyComponent.makeProps(myChild, undefined));
-```
-
-</CodeTab>
-
-This passes the value `myChild` _without_ wrapping it in a list (or array, in the case of ReasonReact). Aka, this desugars to:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@JSX] MyComponent.createElement(~children=myChild, ());
-```
-```ml
-MyComponent.createElement ~children:myChild () [@@JSX]
-```
-```js
-React.createElement(MyComponent.make, MyComponent.makeProps(myChild, undefined));
-```
-
-</CodeTab>
-
-This is extra useful in the cases where you are handled `myChild` that is already a list of things, and want to forward that without wrapping it an extra time (which would be a type error) \*. It also allows you to pass arbitrary data structures at `children` position (remember, JSX `children` is really just a totally normal prop):
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-<MyComponent> ...((theClassName) => <div className=theClassName />) </MyComponent>;
-
-<MyForm> ...("Hello", "Submit") </MyForm>;
-```
-```ml
-(* doesn't exist in old ML syntax *)
-```
-```js
-React.createElement(
-  make,
-  makeProps(function (theClassName) {
-    return React.createElement("div", {
-      className: theClassName,
-    });
-  }, undefined)
-);
-
-React.createElement(MyForm.make, MyForm.makeProps(["Hello", "Submit"], undefined));
-```
-
-</CodeTab>
-
-## Usage
-
-See [ReasonReact JSX](https://reasonml.github.io/reason-react/docs/en/jsx) for an example application of JSX, which transforms the above calls into a ReasonReact-specific call.
-
-Here's a JSX tag that shows most of the features.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-<MyComponent
-  booleanAttribute={true}
-  stringAttribute="string"
-  intAttribute=1
-  forcedOptional=?{Some("hello")}
-  onClick={handleClick}>
-  <div> {React.string("hello")} </div>
-</MyComponent>;
-```
-```ml
-(* doesn't exist in old ML syntax *)
-```
-```js
-React.createElement(
-  MyComponent.make,
-  MyComponent.makeProps(
-    true,
-    "string",
-    1,
-    "hello",
-    handleClick,
-    React.createElement("div", undefined, "hello"),
-    undefined
-  )
-);
-```
-
-</CodeTab>
-
-## Departures From JS JSX
-
-- Attributes and children don't mandate `{}`, but we show them anyway for ease of learning. Once you format your file, some of them go away and some turn into parentheses.
-- There is no support for JSX prop spread: `<Comp {...props} />`. Though somewhat related,  we do have children spread, described above: `<Comp> ...children </Comp>`.
-- Punning!
-
-### Punning
-
-"Punning" refers to the syntax shorthand for when a label and a value are the same. For example, in JavaScript, instead of doing `return {name: name}`, you can do `return {name}`.
-
-Reason JSX supports punning. `<input checked />` is just a shorthand for `<input checked=checked />`. The formatter will help you format to the punned syntax whenever possible. This is convenient in the cases where there are lots of props to pass down:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-<MyComponent isLoading text onClick />;
-```
-```ml
-(* doesn't exist in old ML syntax *)
-```
-```js
-React.createElement(
-  MyComponent.make,
-  MyComponent.makeProps(isLoading, text, onClick, undefined)
-);
-```
-
-</CodeTab>
-
-Consequently, a Reason JSX component can cram in a few more props before reaching for extra libraries solutions that avoids props passing.
-
-**Note** that this is a departure from ReactJS JSX, which does **not** have punning. ReactJS' `<input checked />` desugars to `<input checked=true />`, in order to conform to DOM's idioms and for backward compatibility.
-
-## Tip & Tricks
-
-For library authors wanting to take advantage of the JSX: the `@JSX` attribute above is a hook for potential ppx macros to spot a function wanting to format as JSX. Once you spot the function, you can turn it into any other expression.
-
-This way, everyone gets to benefit the JSX syntax without needing to opt into a specific library using it, e.g. ReasonReact.
-
-JSX calls supports the features of [labeled functions](function.md#labeled-arguments): optional, explicitly passed optional and optional with default.
-
-## Design Decisions
-
-\* You might wonder why you never needed such children spread in ReactJS; ReactJS uses some special runtime logic + special syntax transforms + variadic argument detection & marking to avoid most of these cases ([see here](https://github.com/facebook/react/blob/9b36df86c6ccecb73ca44899386e6a72a83ad445/packages/react/src/ReactElement.js#L207)). Such dynamic usage complexifies the type system detection _quite a bit_. Since we control the whole syntax and ReasonReact, we decided to introduce children spread to disambiguate between the case of wrapping vs not wrapping, without compile-time & runtime cost!
diff --git a/pages/docs/manual/v8.0.0/lazy-values.mdx b/pages/docs/manual/v8.0.0/lazy-values.mdx
deleted file mode 100644
index a19828f35..000000000
--- a/pages/docs/manual/v8.0.0/lazy-values.mdx
+++ /dev/null
@@ -1,362 +0,0 @@
----
-title: "Lazy Values"
-description: "Data type for deferred computation in ReScript"
-canonical: "/docs/manual/latest/lazy-values"
----
-
-# Lazy Values
-
-A lazy value represents a deferred computation which will automatically memoize the result on the first run, and then return the memoized result on any repeated execution.
-
-This is useful for defining functions and expressions for complex procedures that always return the same value, for example:
-
-- Doing expensive DOM traversals over the same tree over and over again
-- Doing file system operations on a static set of files that won't change
-- Doing expensive requests to an API server that would always return the same data
-
-A lazy value has a type of `Lazy.t('a)`, where `'a` is the return value of the computation. All its functionality is encapsulated with the globally available `Lazy` module.
-
-## Creating a lazy value
-
-Lazy values are part of the language. You can either use the `lazy` keyword to create a lazy value from an expression...
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re example
-// We only want getFiles to read the file system once,
-// so we wrap it in a lazy value
-let getFiles =
-  lazy({
-    Js.log("Reading dir");
-    Node.Fs.readdirSync("./pages");
-  });
-
-// On the first call, the computation takes place
-Lazy.force(getFiles)->Js.log;
-
-// The second call will just return the already calculated files
-Lazy.force(getFiles)->Js.log;
-```
-```ml
-(* We only want getFiles to read the file system once, *)
-(* so we wrap it in a lazy value *)
-let getFiles = lazy (
-  Js.log "Reading dir";
-  Node.Fs.readdirSync "./pages"
-)
-
-(* On the first call, the computation takes place *)
-let () = (Lazy.force getFiles) |. Js.log
-
-(* The second call will just return the already calculated files *)
-let () = (Lazy.force getFiles) |. Js.log
-```
-```js
-var Fs = require("fs");
-var CamlinternalLazy = require("./stdlib/camlinternalLazy.js");
-
-var getFiles = {
-  LAZY_DONE: false,
-  VAL: function () {
-    console.log("Reading dir");
-    return Fs.readdirSync("./pages");
-  },
-};
-
-console.log(CamlinternalLazy.force(getFiles));
-console.log(CamlinternalLazy.force(getFiles));
-```
-
-</CodeTab>
-
-...or you can also wrap an existing function to make it lazy:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re example
-// Example for wrapping a function with 0 parameters
-let getFiles = () => {
-  Node.Fs.readdirSync("./pages");
-};
-
-// Here we wrap our function in the lazy value
-let lazyGetFiles = Lazy.from_fun(getFiles);
-```
-```ml
-(* Example for wrapping a function with 0 parameters *)
-let getFiles () =
-  Node.Fs.readdirSync "./pages"
-
-(* Here we wrap our function in the lazy value *)
-let lazyGetFiles = Lazy.from_fun getFiles
-```
-```js
-var Fs = require("fs");
-var Lazy = require("./stdlib/lazy.js");
-
-function getFiles(param) {
-  return Fs.readdirSync("./pages");
-}
-
-var lazyGetFiles = Lazy.from_fun(getFiles);
-```
-
-</CodeTab>
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re example
-// Example for wrapping a function with parameters
-let doesFileExist = name => {
-  Node.Fs.readdirSync("./pages")->Js.Array2.find(s => name === s);
-};
-
-// Here we use the lazy syntax again
-// since we can't use Lazy.from_fun
-let lazyDoesFileExist = lazy(doesFileExist("blog.re"));
-```
-```ml
-(* Example for wrapping a function with parameters *)
-let doesFileExist name =
-  Node.Fs.readdirSync "./pages" |. Js.Array2.find(fun s -> name == s)
-
-(* Here we use the lazy syntax again *)
-(* since we can't use Lazy.from_fun *)
-let lazyDoesFileExist = lazy(doesFileExist "blog.re")
-```
-```js
-var Fs = require("fs");
-var Caml_option = require("./stdlib/caml_option.js");
-
-function doesFileExist(name) {
-  return Caml_option.undefined_to_opt(
-    Fs.readdirSync("./pages").find(function (s) {
-      return name === s;
-    })
-  );
-}
-
-var lazyDoesFileExist = {
-  LAZY_DONE: false,
-  VAL: function () {
-    return doesFileExist("blog.re");
-  },
-};
-```
-
-</CodeTab>
-
-Whenever we want to wrap a function `unit => 'a`, we use `Lazy.from_fun`, otherwise we use the `lazy(expr)` keyword to wrap an expression or a function with 1 or more arguments.
-
-## Force a lazy computation
-
-Lazy values need to be explicitly executed to be able to return a value. Use the `Lazy.force`to start the execution:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re example
-let computation = lazy(1);
-
-// Returns 1
-Lazy.force(computation);
-```
-```ml
-let computation = lazy 1;
-
-(* Returns 1 *)
-Lazy.force computation
-```
-```js
-var CamlinternalLazy = require("./stdlib/camlinternalLazy.js");
-
-var computation = {
-  LAZY_DONE: true,
-  VAL: 1,
-};
-
-CamlinternalLazy.force(computation);
-```
-
-</CodeTab>
-
-It is also possible to use pattern matching to force a lazy value to compute, this includes `switch` expressions and similar syntax such as tuple destructuring:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re example
-// Extract a lazy value via pattern matching
-let computation = lazy("computed");
-
-switch computation {
-| lazy("computed") => Js.log("ok")
-| _ => Js.log("not ok")
-};
-```
-```ml
-(* Extract a lazy value via pattern matching *)
-let computation = lazy "computed"
-
-let () = match computation with
-| lazy "computed" -> Js.log "ok"
-| _ -> Js.log "not ok"
-```
-```js
-var CamlinternalLazy = require("./stdlib/camlinternalLazy.js");
-
-var computation = {
-  LAZY_DONE: true,
-  VAL: "computed",
-};
-
-var match = CamlinternalLazy.force(computation);
-
-if (match === "computed") {
-  console.log("ok");
-} else {
-  console.log("not ok");
-}
-```
-
-</CodeTab>
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re example
-// Destructuring a single value
-// Note: currently the formatter will reprint this
-//       as `let lazy word = ...`
-let lazy(word) = lazy("hello");
-
-// Output: "hello"
-Js.log(word);
-```
-```ml
-let lazy word = lazy "hello"
-
-(* Output: "hello" *)
-Js.log word
-```
-```js
-var CamlinternalLazy = require("./stdlib/camlinternalLazy.js");
-
-var match = {
-  LAZY_DONE: true,
-  VAL: "hello",
-};
-
-var word = CamlinternalLazy.force(match);
-
-console.log(word);
-```
-
-</CodeTab>
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re example
-// Destructing a tuple
-let lazyValues = (lazy("hello"), lazy("world"));
-let (lazy(word1), lazy(word2)) = lazyValues;
-
-// Output: "hello world"
-Js.log2(word1, word2);
-let lazy(word) = lazy("hello");
-```
-```ml
-(* Destructing a tuple *)
-let lazyValues = (lazy "hello", lazy "world")
-let (lazy word1, lazy word2) = lazyValues
-
-(* Output: "hello world" *)
-Js.log2(word1, word2)
-let lazy word = lazy "hello"
-```
-```js
-var CamlinternalLazy = require("./stdlib/camlinternalLazy.js");
-
-var lazyValues_0 = {
-  LAZY_DONE: true,
-  VAL: "hello",
-};
-
-var lazyValues_1 = {
-  LAZY_DONE: true,
-  VAL: "world",
-};
-
-var lazyValues = [lazyValues_0, lazyValues_1];
-
-var word1 = CamlinternalLazy.force(lazyValues_0);
-
-var word2 = CamlinternalLazy.force(lazyValues_1);
-
-console.log(word1, word2);
-
-var match = {
-  LAZY_DONE: true,
-  VAL: "hello",
-};
-
-var word = CamlinternalLazy.force(match);
-```
-
-</CodeTab>
-
-As you can see, the `lazy` syntax is a really great way for creating and handling lazy computations!
-
-## Exception handling
-
-Whenever a lazy value computation raises an exception, the same exception will be thrown by `Lazy.force`.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re example
-let readFile =
-  lazy({
-    raise(Not_found)
-  });
-
-try (Lazy.force(readFile)) {
-| Not_found => Js.log("No file")
-};
-```
-```ml
-let readFile = lazy (raise Not_found)
-let () = try Lazy.force readFile with
-| Not_found -> Js.log "No file"
-```
-```js
-var CamlinternalLazy = require("./stdlib/camlinternalLazy.js");
-var Caml_js_exceptions = require("./stdlib/caml_js_exceptions.js");
-
-var readFile = {
-  LAZY_DONE: false,
-  VAL: function () {
-    throw {
-      RE_EXN_ID: "Not_found",
-      Error: new Error(),
-    };
-  },
-};
-
-try {
-  CamlinternalLazy.force(readFile);
-} catch (raw_exn) {
-  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-  if (exn.RE_EXN_ID === "Not_found") {
-    console.log("No file");
-  } else {
-    throw exn;
-  }
-}
-```
-
-</CodeTab>
-
-Nothing new here, since we are using the `try` expression to match the exception raised in the lazy computation!
-
-Please remember: Exceptions should be used sparsely!
-
-## Notes
-
-A lazy value is **not** a [shared data type](shared-data-types.md). Don't rely on the runtime representation on the JS side.
diff --git a/pages/docs/manual/v8.0.0/let-binding.mdx b/pages/docs/manual/v8.0.0/let-binding.mdx
deleted file mode 100644
index 834509559..000000000
--- a/pages/docs/manual/v8.0.0/let-binding.mdx
+++ /dev/null
@@ -1,221 +0,0 @@
----
-title: "Let Binding"
-description: "Let binding syntax for binding to values in ReScript"
-canonical: "/docs/manual/latest/let-binding"
----
-
-# Let Binding
-
-A "let binding", in other languages, might be called a "variable declaration". `let` _binds_ values to names. They can be seen and referenced by code that comes _after_ them.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let greeting = "hello!";
-let score = 10;
-let newScore = 10 + score;
-```
-```ml
-let greeting = "hello!"
-let score = 10
-let newScore = 10 + score
-```
-```js
-var greeting = "hello!";
-var score = 10;
-var newScore = 20;
-```
-
-</CodeTab>
-
-## Block Scope
-
-Bindings can be scoped through `{}`.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let message = {
-  let part1 = "hello";
-  let part2 = "world";
-  part1 ++ " " ++ part2;
-};
-// `part1` and `part2` not accessible here!
-```
-```ml
-let message =
-  let part1 = "hello" in
-  let part2 = "world" in
-  part1 ++ " " ++ part2
-
-(* `part1` and `part2` not accessible here! *)
-```
-```js
-var message = "hello world";
-```
-
-</CodeTab>
-
-The value of the last line of a scope is implicitly returned.
-
-### Design Decisions
-
-ReScript's `if`, `while` and functions all use the same block scoping mecanism. The code below works **not** because of some special "if scope"; but simply because it's the same scope syntax and feature you just saw:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-if (displayGreeting) {
-  let message = "Enjoying the docs so far?";
-  Js.log(message);
-}
-// `message` not accessible here!
-```
-```re
-if displayGreeting then
-  let message = "Enjoying the docs so far?" in
-  Js.log message
-(* `message` not accessible here! *)
-```
-```js
-if (displayGreeting) {
-  console.log("Enjoying the docs so far?");
-}
-```
-
-</CodeTab>
-
-## Bindings Are Immutable
-
-Let bindings are "immutable", aka "cannot change". This helps our type system deduce and optimize much more than other languages (and in turn, help you more).
-
-## Binding Shadowing
-
-The above restriction might sound unpractical at first. How would you change a value then? Usually, 2 ways:
-
-The first is to realize that many times, what you want isn't to mutate a variable's value. For example, this JavaScript pattern:
-
-```js
-var result = 0;
-result = calculate(result);
-result = calculateSomeMore(result);
-```
-
-...is really just to comment on intermediate steps. You didn't need to mutate `result` at all! You could have just written this JS:
-
-```js
-var result1 = 0;
-var result2 = calculate(result1);
-var result3 = calculateSomeMore(result2);
-```
-
-In ReScript, this obviously works too:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let result1 = 0;
-let result2 = calculate(result1);
-let result3 = calculateSomeMore(result2);
-```
-```ml
-let result1 = 0
-let result2 = calculate result1
-let result3 = calculateSomeMore result2
-```
-```js
-var result1 = 0;
-var result2 = calculate(0);
-var result3 = calculateSomeMore(result2);
-```
-
-</CodeTab>
-
-Additionally, reusing the same let binding name overshadows the previous bindings with the same name. So you can write this too:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let result = 0;
-let result = calculate(result);
-let result = calculateSomeMore(result);
-```
-```ml
-let result = 0
-let result = calculate result
-let result = calculateSomeMore result
-```
-```js
-var result = calculate(0);
-var result$1 = calculateSomeMore(result);
-```
-
-</CodeTab>
-
-(Though for the sake of clarity, we don't recommend this).
-
-As a matter of fact, even this is valid code:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let result = "hello";
-Js.log(result); // prints "hello"
-let result = 1;
-Js.log(result); // prints 1
-```
-```ml
-let result = "hello"
-let () = Js.log result (* prints "hello" *)
-let result = 1
-let () = Js.log result (* prints 1 *)
-```
-```js
-var result = 1;
-console.log("hello");
-console.log(1);
-```
-
-</CodeTab>
-
-The binding you refer to is whatever's the closest upward. No mutation here!
-If you need _real_ mutation, e.g. passing a value around, have it modified by many pieces of code, we provide a slightly heavier [mutation feature](mutation.md).
-
-
-## Private let bindings
-
-Private let bindings are introduced in the release [7.2](https://rescript-lang.org/blog/bucklescript-release-7-2).
-
-In the module system, everything is public by default, 
-the only way to hide some values is by providing a separate signature to 
-list public fields and their types:
-
-```res
-module A: {
-  let b: int
-} = {
-  let a = 3
-  let b = 4
-}
-```
-`%private` gives you an option to mark private fields directly
-
-```res
-module A = {
-  %%private(let a = 3)
-  let b = 4
-}
-```
-
-`%private` also applies to file level modules, so in some cases, 
-users do not need to provide a separate interface file just to hide some particular values.
-
-Note interface files are still recommended as a general best practice since they give you better 
-separate compilation units and also they're better for documentation. 
-
-Still, `%private` is useful in the following scenarios:
-
-- Code generators. Some code generators want to hide some values but it is sometimes very hard or time consuming for code generators to synthesize the types for public fields.
-
-- Quick prototyping. During prototyping, we still want to hide some values, but the interface file is not stable yet. `%private` provides you such convenience.
-
diff --git a/pages/docs/manual/v8.0.0/libraries.mdx b/pages/docs/manual/v8.0.0/libraries.mdx
deleted file mode 100644
index 2d5e3f9c6..000000000
--- a/pages/docs/manual/v8.0.0/libraries.mdx
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: "Libraries"
-description: "ReScript libraries"
-canonical: "/docs/manual/latest/libraries"
----
-
-# Libraries
-
-ReScript libraries are just like JavaScript libraries: hosted on [NPM](http://npmjs.com).
-
-If you can't find what you're looking for: sometimes **you don't need a wrapper** to use a JS library:
-
-- Most JS data types, such as array and objects, [map over cleanly to ReScript and vice-versa](shared-data-types.md).
-- You also have access to the familiar [JS API](api/js).
-- You can use a JavaScript library without needing to bind to them first. Check the [`external`](external) page.
diff --git a/pages/docs/manual/v8.0.0/migrate-from-bucklescript-reason.mdx b/pages/docs/manual/v8.0.0/migrate-from-bucklescript-reason.mdx
deleted file mode 100644
index 44df12624..000000000
--- a/pages/docs/manual/v8.0.0/migrate-from-bucklescript-reason.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: "Migrate to ReScript Syntax"
-description: "Instructions on upgrading from Reason to ReScript"
-canonical: "/docs/manual/latest/migrate-to-new-syntax"
----
-
-# Migrate to New Syntax
-
-Starting from `v8.2.0`, BuckleScript and the JS part of Reason are now fused into the new ReScript. We've also introduced a new syntax similar to the old Reason syntax, but [tremendously improved](https://reasonml.org/blog/bucklescript-8-1-new-syntax).
-
-The old ML and Reason syntax are still supported (see our support commitment [here](https://reasonml.org/blog/a-note-on-bucklescripts-future-commitments)). The gist is: this is mostly just a rebranding and shouldn't affect your existing code much.
-
-## Upgrade Your Codebase
-
-There are lots of exciting improvements in the new syntax (features, speed, error messages, etc.). The upgrade is trivial, backward-compatible and can be done on a per-file basis:
-
-- Upgrade your project to `bs-platform 8.2.0` or later.
-- `node_modules/.bin/bsc -format MyFile.re > MyFile.res`
-
-**That's it**! `MyFile.re` could be any `.re`, `.rei`, `.ml` and `.mli` file.
-
-Enjoy the improved experience!
-
-## Difference With Old Reason
-
-- Complete removal of semicolon (you can still write them).
-- No need for parentheses around `if`, `switch` and `try`.
-- Type arguments: from `option(int)` to `option<int>`.
-- Old interpolated string: from `{j|hello ${name}|j}` to `` j`hello ${name}` ``. Now with proper unicode support!
-- New interpolated string: `` `hello world` ``. Also supports multiline and unicode. `"hello world"` string is now singleline.
-- Polymorphic variants: from `` `red`` to `#red`.
-- Arrays: from `[|1,2,3|]` to `[1,2,3]`. In JS, arrays are the right default.
-- Lists: from `[1,2,3]` to `list[1,2,3]` (_8.1.1 update_: now it is `list{1, 2, 3}`). This ties with upcoming plans to access containers in a uniform way: `set[...]` and `map[...]`. Maybe temporary.
-- Exception: from `try (compute()) { | Not_found => Js.log("oops")}` to `try compute() catch { | Not_found => Js.log("oops")}`.
-- First class module: from `(module S: Student)` to `module(S: Student)`.
-- No custom infix operator for now (including `mod`).
-- Object access: from `settings##visible #= true` to `settings["visible"] = true`. Rejoice!
-- Object: from `Js.t({"age": int})` to just `{"age": int}`. The `Js.t` part is now implicit.
-- Attribute: from `[@bs.deriving accessors]` to `@bs.deriving(accessors)`. From `[%re bla]` to `%re(bla)`.
-- Removed dereference syntax `result^`. Just use `result.contents`.
-- `fun` pattern matching syntax removed.
-- Type declaration is non-recursive by default, consistent with let bindings. To have recursive types, use `type rec myList<'a> = Nil | Cons('a, myList<'a>)`.
-- Use any words, including reserved keywords, as your identifier name: `let \"try" = true`.
diff --git a/pages/docs/manual/v8.0.0/module.mdx b/pages/docs/manual/v8.0.0/module.mdx
deleted file mode 100644
index 568f74e20..000000000
--- a/pages/docs/manual/v8.0.0/module.mdx
+++ /dev/null
@@ -1,645 +0,0 @@
----
-title: "Module"
-description: "ReScript modules, module signatures and interface files"
-canonical: "/docs/manual/latest/module"
----
-
-# Module
-
-## Basics
-
-**Modules are like mini files**! They can contain type definitions, `let`
-bindings, nested modules, etc.
-
-### Creation
-
-To create a module, use the `module` keyword. The module name must start with a
-**capital letter**. Whatever you could place in a `.re` file, you may place
-inside a module definition's `{}` block.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-module School = {
-  type profession = Teacher | Director;
-
-  let person1 = Teacher;
-  let getProfession = (person) =>
-    switch person {
-    | Teacher => "A teacher"
-    | Director => "A director"
-    };
-};
-```
-```ml
-module School = struct
-  type profession = Teacher | Director
-
-  let person1 = Teacher
-  let getProfession person =
-    match person with
-    | Teacher -> "A teacher"
-    | Director -> "A director"
-end
-```
-```js
-function getProfession(person) {
-  if (person) {
-    return "A director";
-  } else {
-    return "A teacher";
-  }
-}
-
-var School = {
-  person1: /* Teacher */0,
-  getProfession: getProfession
-};
-```
-
-</CodeTab>
-
-A module's contents (including types!) can be accessed much like a record's,
-using the `.` notation. This demonstrates modules' utility for namespacing.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let anotherPerson: School.profession = School.Teacher;
-Js.log(School.getProfession(anotherPerson)); /* "A teacher" */
-```
-```ml
-let anotherPerson: School.profession = School.Teacher
-Js.log (School.getProfession anotherPerson) (* "A teacher" *)
-```
-```js
-var anotherPerson = /* Teacher */0;
-console.log("A teacher");
-```
-
-</CodeTab>
-
-Nested modules work too.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-module MyModule = {
-  module NestedModule = {
-    let message = "hello"
-  };
-};
-
-let message = MyModule.NestedModule.message;
-```
-```ml
-module MyModule = struct
-  module NestedModule = struct
-    let message = "hello"
-  end
-end
-
-let message = MyModule.NestedModule.message
-```
-```js
-var NestedModule = {
-  message: message
-};
-
-var MyModule = {
-  NestedModule: NestedModule
-};
-
-var message = MyModule.NestedModule.message;
-```
-
-</CodeTab>
-
-### `open`ing a module
-
-Constantly referring to a value/type in a module can be tedious. Instead, we can "open" a module and refer to its contents without always prepending them with the
-module's name. Instead of writing:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let p = School.getProfession(School.person1);
-```
-```ml
-let p = School.getProfession School.person1
-```
-```js
-var p = School.getProfession(School.person1);
-```
-
-</CodeTab>
-
-We can write:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-open School;
-let p = getProfession(person1);
-```
-```ml
-open School
-let p = getProfession person1
-```
-```js
-var p = School.getProfession(School.person1);
-```
-
-</CodeTab>
-
-The content of `School` module are made visible (**not** copied into the file, but simply made visible!) in scope. `profession`, `getProfession` and `person1` will thus correctly be found.
-
-**Use `open` this sparingly, it's convenient, but makes it hard to know where some values come from**. You should usually use `open` in a local scope:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let p = {
-  open School;
-  getProfession(person1);
-};
-/* School's content isn't visible here anymore */
-```
-```ml
-let p =
-  let open School in
-  getProfession person1
-(* School's content isn't visible here anymore *)
-```
-```js
-var p = School.getProfession(School.person1);
-```
-
-</CodeTab>
-
-### Extending modules
-
-Using `include` in a module statically "spreads" a module's content into a new one, thus often fulfill the role of "inheritance" or "mixin".
-
-**Note**: this is equivalent to a compiler-level copy paste. **We heavily discourage `include`**. Use it as last resort!
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-module BaseComponent = {
-  let defaultGreeting = "Hello";
-  let getAudience = (~excited) => excited ? "world!" : "world";
-};
-
-module ActualComponent = {
-  /* the content is copied over */
-  include BaseComponent;
-  /* overrides BaseComponent.defaultGreeting */
-  let defaultGreeting = "Hey";
-  let render = () => defaultGreeting ++ " " ++ getAudience(~excited=true);
-};
-```
-```ml
-module BaseComponent = struct
-  let defaultGreeting = "Hello"
-  let getAudience ~excited = if excited then "world!" else "world"
-end
-
-module ActualComponent = struct
-  (* the content is copied over *)
-  include BaseComponent
-  (* overrides BaseComponent.defaultGreeting *)
-  let defaultGreeting = "Hey"
-  let render () = defaultGreeting ^ " " ^ (getAudience ~excited:true)
-end
-```
-```js
-function getAudience(excited) {
-  if (excited) {
-    return "world!";
-  } else {
-    return "world";
-  }
-}
-
-var BaseComponent = {
-  defaultGreeting: "Hello",
-  getAudience: getAudience
-};
-
-var defaultGreeting = "Hey";
-
-function render(param) {
-  return "Hey world!";
-}
-
-var ActualComponent = {
-  getAudience: getAudience,
-  defaultGreeting: defaultGreeting,
-  render: render
-};
-```
-
-</CodeTab>
-
-**Note**: `open` and `include` are very different! The former brings a module's content into your current scope, so that you don't have to refer to a value by prefixing it with the module's name every time. The latter **copies over** the definition of a module statically, then also do an `open`.
-
-### Every `.re` file is a module
-
-Every ReScript file is itself compiled to a module of the same name as the file name, capitalized. The file `React.re` implicitly forms a module `React`, which can be seen by other source files.
-
-**Note**: ReScript file names should, by convention, be capitalized so that their casing matches their module name. Uncapitalized file names are not invalid, but will be implicitly transformed into a capitalized module name. I.e. `file.res` will be compiled into the module `File`. To simplify and minimize the disconnect here, the convention is therefore to capitalize file names.
-
-## Signatures
-
-A module's type is called a "signature", and can be written explicitly. If a
-module is like a `.re` (implementation) file, then a module's signature is like
-a `.rei` (interface) file.
-
-### Creation
-
-To create a signature, use the `module type` keyword. The signature name must start with a
-**capital letter**. Whatever you could place in a `.rei` file, you may place
-inside a signature definition's `{}` block.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-/* Picking up previous section's example */
-module type EstablishmentType = {
-  type profession;
-  let getProfession: profession => string;
-};
-```
-```ml
-(* Picking up previous section's example *)
-module type EstablishmentType  = sig
-  type profession
-  val getProfession: profession -> string
-end
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-A signature defines the list of requirements that a module must satisfy in order
-for that module to match the signature. Those requirements are of the form:
-
-- `let x: int` requires a `let` binding named `x`, of type `int`.
-- `type t = someType` requires a type field `t` to be equal to `someType`.
-- `type t` requires a type field `t`, but without imposing any requirements on the actual, concrete type of `t`. We'd use `t` in other entries in the signature to describe relationships, e.g. `let makePair: t => (t, t)` but we cannot, for example, assume that `t` is an `int`. This gives us great, enforced abstraction abilities.
-
-To illustrate the various kinds of type entries, consider the above signature
-`EstablishmentType` which requires that a module:
-
-- Declare a type named `profession`.
-- Must include a function that takes in a value of the type `profession` and returns a string.
-
-**Note**:
-
-Modules of the type `EstablishmentType` can contain more fields than the
-signature declares, just like the module `School` in the previous section (if we
-choose to assign it the type `EstablishmentType`. Otherwise, `School` exposes
-every field). This effectively makes the `person1` field an enforced
-implementation detail! Outsiders can't access it, since it's not present in the
-signature; the signature **constrained** what others can access.
-
-The type `EstablishmentType.profession` is **abstract**: it doesn't have a
-concrete type; it's saying "I don't care what the actual type is, but it's used
-as input to `getProfession`". This is useful to fit many modules under the same
-interface:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-module Company: EstablishmentType = {
-  type profession = CEO | Designer | Engineer | ...
-
-  let getProfession = (person) => ...
-  let person1 = ...
-  let person2 = ...
-};
-```
-```ml
-module Company: EstablishmentType = struct
-  type profession = CEO | Designer | Engineer | ...
-
-  let getProfession person = ...
-  let person1 = ...
-  let person2 = ...
-end
-```
-```js
-function getProfession(person) {
-  ...
-}
-
-var person1 = ...
-
-var person2 = ...
-
-var Company = {
-  getProfession: getProfession,
-  person1: person1,
-  person2: person2
-};
-```
-
-</CodeTab>
-
-It's also useful to hide the underlying type as an implementation detail others
-can't rely on. If you ask what the type of `Company.profession` is, instead of
-exposing the variant, it'll only tell you "it's `Company.profession`".
-
-### Extending module signatures
-
-Like modules themselves, module signatures can also be extended by other module signatures using `include`. Again, **heavily discouraged**:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-module type BaseComponent = {
-  let defaultGreeting: string;
-  let getAudience: (~excited: bool) => string;
-};
-
-module type ActualComponent = {
-  /* the BaseComponent signature is copied over */
-  include BaseComponent;
-  let render: unit => string;
-};
-```
-```ml
-module type BaseComponent = sig
-  val defaultGreeting: string
-  val getAudience: excited:bool -> string
-end
-
-module type ActualComponent = sig
-  (* the BaseComponent signature is copied over *)
-  include BaseComponent
-  val render: unit -> string
-end
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-**Note**: `BaseComponent` is a module **type**, not an actual module itself!
-
-If you do not have a defined module type, you can extract it from an actual module
-using `include (module type of ActualModuleName)`. For example, we can extend the
-`List` module from the standard library, which does not define a module
-type.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-module type MyList = {
-  include (module type of List);
-  let myListFun: list('a) => list('a);
-};
-```
-```ml
-module type MyList = sig
-  include module type of List
-  val myListFun: 'a list -> 'a list
-end
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-### Every `.rei` file is a signature
-
-Similar to how a `React.re` file implicitly defines a module `React`, a file
-`React.rei` implicitly defines a signature for `React`. If `React.rei` isn't
-provided, the signature of `React.re` defaults to exposing all the fields of the
-module. Because they don't contain implementation files, `.rei` files are used
-in the ecosystem to also document the public API of their corresponding modules.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-/* file React.re (implementation. Compiles to module React) */
-type state = int;
-let render = (str) => str;
-```
-```ml
-(* file React.ml (implementation. Compiles to module React) *)
-type state = int
-let render str = str
-```
-```js
-function render(str) {
-  return str;
-}
-```
-
-</CodeTab>
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-/* file React.rei (interface. Compiles to the signature of React.re) */
-type state = int;
-let render: string => string;
-```
-```ml
-(* file React.mli (interface. Compiles to the signature of React.re) *)
-type state = int
-val render: str -> str
-```
-
-</CodeTab>
-
-## Module Functions (functors)
-
-Modules can be passed to functions! It would be the equivalent of passing a file
-as a first-class item. However, modules are at a different "layer" of the
-language than other common concepts, so we can't pass them to *regular*
-functions. Instead, we pass them to special functions called "functors".
-
-The syntax for defining and using functors is very much like the syntax
-for defining and using regular functions. The primary differences are:
-
-- Functors use the `module` keyword instead of `let`.
-- Functors take modules as arguments and return a module.
-- Functors *require* annotating arguments.
-- Functors must start with a capital letter (just like modules/signatures).
-
-Here's an example `MakeSet` functor, that takes in a module of the type
-`Comparable` and returns a new set that can contain such comparable items.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-module type Comparable = {
-  type t;
-  let equal: (t, t) => bool;
-}
-
-module MakeSet = (Item: Comparable) => {
-  // let's use a list as our naive backing data structure
-  type backingType = list(Item.t);
-  let empty = [];
-  let add = (currentSet: backingType, newItem: Item.t): backingType =>
-    // if item exists
-    if (List.exists(x => Item.equal(x, newItem), currentSet)) {
-      currentSet; // return the same (immutable) set (a list really)
-    } else {
-      [
-        newItem,
-        ...currentSet // prepend to the set and return it
-      ]
-    };
-};
-```
-```ml
-module type Comparable = sig
-  type t
-  val equal: t -> t -> bool
-end
-
-module MakeSet (Item: Comparable) = struct
-  (* let's use a list as our naive backing data structure *)
-  type backingType = Item.t list
-  let empty = []
-  let add (currentSet: backingType) (newItem: Item.t) : backingType =
-    (* if item exists *)
-    if List.exists (fun x -> Item.equal x newItem) currentSet then
-      currentSet (* return the same (immutable) set (a list really) *)
-    else
-      newItem::currentSet (* prepend to the set and return it *)
-end
-```
-```js
-var List = require("./stdlib/list.js");
-
-function MakeSet(Item) {
-  var add = function(currentSet, newItem) {
-    if (
-      List.exists(function(x) {
-        return Item.equal(x, newItem);
-      }, currentSet)
-    ) {
-      return currentSet;
-    } else {
-      return {
-        hd: newItem,
-        tl: currentSet,
-      };
-    }
-  };
-  return {
-    empty: /* [] */ 0,
-    add: add,
-  };
-}
-```
-
-</CodeTab>
-
-Functors can be applied using function application syntax. In this case, we're
-creating a set, whose items are pairs of integers.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-module IntPair = {
-  type t = (int, int);
-  let equal = ((x1: int, y1: int), (x2, y2)) => x1 == x2 && y1 == y2;
-  let create = (x, y) => (x, y);
-};
-
-/* IntPair abides by the Comparable signature required by MakeSet */
-module SetOfIntPairs = MakeSet(IntPair);
-```
-```ml
-module IntPair = struct
-  type t = int * int
-  let equal ((x1: int), (y1: int)) (x2,y2) = (x1 = x2) && (y1 = y2)
-  let create x y = (x, y)
-end
-
-(* IntPair abides by the Comparable signature required by MakeSet *)
-module SetOfIntPairs = MakeSet(IntPair)
-```
-```js
-function equal(param, param$1) {
-  if (param[0] === param$1[0]) {
-    return param[1] === param$1[1];
-  } else {
-    return false;
-  }
-}
-
-function create(x, y) {
-  return [x, y];
-}
-
-var IntPair = {
-  equal: equal,
-  create: create,
-};
-
-var SetOfIntPairs = {
-  empty: /* [] */ 0,
-  add: add,
-};
-```
-
-</CodeTab>
-
-### Module functions types
-
-Like with module types, functor types also act to constrain and hide what we may
-assume about functors. The syntax for functor types are consistent with those
-for function types, but with types capitalized to represent the signatures of
-modules the functor accepts as arguments and return values. In the
-previous example, we're exposing the backing type of a set; by giving `MakeSet`
-a functor signature, we can hide the underlying data structure!
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-module type Comparable = ...
-
-module type MakeSetType = (Item: Comparable) => {
-  type backingType;
-  let empty: backingType;
-  let add: (backingType, Item.t) => backingType;
-};
-
-module MakeSet: MakeSetType = (Item: Comparable) => {
-  ...
-};
-```
-```ml
-module type Comparable = ...
-
-module type MakeSetType = functor (Item : Comparable) -> sig
-  type backingType
-  val empty: backingType
-  val add: backingType -> Item.t -> backingType
-end
-
-module MakeSet: MakeSetType = functor (Item: Comparable) -> struct
-  ...
-end
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Tips & Tricks
-
-Modules and functors are at a different "layer" of language than the rest (functions, let bindings, data structures, etc.). For example, you can't easily pass them into a tuple or record. Use them judiciously, if ever! Lots of times, just a record or a function is enough.
diff --git a/pages/docs/manual/v8.0.0/mutation.mdx b/pages/docs/manual/v8.0.0/mutation.mdx
deleted file mode 100644
index 050cd3275..000000000
--- a/pages/docs/manual/v8.0.0/mutation.mdx
+++ /dev/null
@@ -1,89 +0,0 @@
----
-title: "Mutation"
-description: "Imperative and mutative programming capabilities in ReScript"
-canonical: "/docs/manual/latest/mutation"
----
-
-# Mutation
-
-ReScript has great traditional imperative & mutative programming capabilities. You should use these features sparingly, but sometimes they allow your code to be more performant and written in a more familiar pattern.
-
-## Mutate Let-binding
-
-Let-bindings are immutable, but you can wrap it with a `ref`, exposed as a record with a single mutable field in the standard library:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let myValue = ref(5);
-```
-```ml
-let myValue = ref 5
-```
-```js
-var myValue = {
-  contents: 5
-};
-```
-
-</CodeTab>
-
-## Usage
-
-You can get the actual value of a `ref` box through accessing its `contents` field:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let five = myValue.contents; // 5
-```
-```ml
-let five = myValue.contents (* 5 *)
-```
-```js
-var five = myValue.contents;
-```
-
-</CodeTab>
-
-We provide a syntax shortcut for `myValue.contents`: `myValue^`. Though we no longer encourage it.
-
-Assign a new value to `myValue` like so:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-myValue.contents = 6;
-```
-```ml
-myValue.contents = 6
-```
-```js
-myValue.contents = 6;
-```
-
-</CodeTab>
-
-We provide a syntax sugar for this:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-myValue := 6;
-```
-```ml
-myValue := 6
-```
-```js
-myValue.contents = 6;
-```
-
-</CodeTab>
-
-Note that the previous binding `five` stays `5`, since it got the underlying item on the `ref` box, not the `ref` itself.
-
-**Note**: you might see in the JS output tabs above that `ref` allocates an object. Worry not; local, non-exported `ref`s allocations are optimized away.
-
-## Tip & Tricks
-
-Before reaching for `ref`, know that you can achieve lightweight, local "mutations" through [overriding let bindings](let-binding.md#binding-shadowing).
diff --git a/pages/docs/manual/v8.0.0/newcomer-examples.mdx b/pages/docs/manual/v8.0.0/newcomer-examples.mdx
deleted file mode 100644
index 30c4921a7..000000000
--- a/pages/docs/manual/v8.0.0/newcomer-examples.mdx
+++ /dev/null
@@ -1,174 +0,0 @@
----
-title: "Newcomer Examples"
-description: "Quick examples for users new to ReScript"
-canonical: "/docs/manual/latest/newcomer-examples"
----
-
-# Newcomer Examples
-
-<!-- TODO: this whole page needs a revamp -->
-
-An example is worth a thousand words.
-
-This section is dedicated to newcomers trying to figure out general idioms & conventions. If you're a beginner who's got a good idea for an example, please suggest an edit!
-
-## Use the [`option` type](null-undefined-option.md)
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let possiblyNullValue1 = None;
-let possiblyNullValue2 = Some("Hello");
-
-switch (possiblyNullValue2) {
-| None => Js.log("Nothing to see here.")
-| Some(message) => Js.log(message)
-};
-```
-```ml
-let possiblyNullValue1 = None
-let possiblyNullValue2 = Some "Hello"
-
-let () = match possiblyNullValue2 with
-| None -> Js.log "Nothing to see here."
-| Some(message) -> Js.log message
-```
-```js
-var possiblyNullValue1;
-var possiblyNullValue2 = "Hello";
-
-if (possiblyNullValue2 !== undefined) {
-  console.log(possiblyNullValue2);
-} else {
-  console.log("Nothing to see here.");
-}
-
-```
-
-</CodeTab>
-
-## Create a Parametrized Type
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type universityStudent = {gpa: float};
-
-type response('studentType) = {
-  status: int,
-  student: 'studentType,
-};
-```
-```ml
-type universityStudent = {gpa: float}
-
-type 'studentType response = {
-  status: int;
-  student: 'studentType;
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Creating a JS Object
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let student1 = {
-  "name": "John",
-  "age": 30,
-};
-```
-```ml
-let student1 = [%bs.obj {
-  name = "John";
-  age = 30
-}]
-```
-```js
-var student1 = {
-  name: "John",
-  age: 30,
-};
-```
-
-</CodeTab>
-
-Or using [record](record.md):
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type payload = {
-  name: string,
-  age: int,
-};
-
-let student1 = {
-  name: "John",
-  age: 30,
-};
-```
-```ml
-type payload = {
-  name: string;
-  age: int;
-}
-
-let student1 = {
-  name = "John";
-  age = 30;
-}
-```
-```js
-var student1 = {
-  name: "John",
-  age: 30,
-};
-```
-
-</CodeTab>
-
-## Modeling a JS Module with Default Export
-
-See [here](import-from-export-to-js.md#import-a-javascript-module-itself-es6-module-format).
-
-## Checking for JS nullable types using the `option` type
-
-For a function whose argument is passed a JavaScript value that's potentially `null` or `undefined`, it's idiomatic to convert it to an `option`. The conversion is done through the helper functions in ReScript's [`Js.Nullable`](api/js/nullable#t) module. In this case, `toOption`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let greetByName = (possiblyNullName) => {
-  let optionName = Js.Nullable.toOption(possiblyNullName);
-  switch (optionName) {
-  | None => "Hi"
-  | Some(name) => "Hello " ++ name
-  }
-};
-```
-```ml
-let greetByName possiblyNullName =
-  let optionName = Js.Nullable.toOption possiblyNullName in
-  match optionName with
-  | None -> "Hi"
-  | Some name -> "Hello " ^ name
-```
-```js
-function greetByName(possiblyNullName) {
-  if (possiblyNullName == null) {
-    return "Hi";
-  } else {
-    return "Hello " + possiblyNullName;
-  }
-}
-```
-
-</CodeTab>
-
-This check compiles to `possiblyNullName == null` in JS, so checks for the presence of `null` or `undefined`.
diff --git a/pages/docs/manual/v8.0.0/null-undefined-option.mdx b/pages/docs/manual/v8.0.0/null-undefined-option.mdx
deleted file mode 100644
index 1c3277ae6..000000000
--- a/pages/docs/manual/v8.0.0/null-undefined-option.mdx
+++ /dev/null
@@ -1,243 +0,0 @@
----
-title: "Null, Undefined and Option"
-description: "JS interop with nullable and optional values in ReScript"
-canonical: "/docs/manual/latest/null-undefined-option"
----
-
-# Null, Undefined and Option
-
-ReScript itself doesn't have the notion of `null` or `undefined`. This is a _great_ thing, as it wipes out an entire category of bugs. No more `undefined is not a function`, and `cannot access someAttribute of undefined`!
-
-However, the **concept** of a potentially nonexistent value is still useful, and safely exists in our language.
-
-We represent the existence and nonexistence of a value by wrapping it with the `option` type. Here's its definition from the standard library:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type option('a) = None | Some('a);
-```
-type 'a option = | None | Some of 'a
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-It means "a value of type option is either None (representing nothing) or that actual value wrapped in a Some".
-
-**Note** how the `option` type is just a regular [variant](variant.md).
-
-## Example
-
-Here's a normal value:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let licenseNumber = 5;
-```
-```ml
-let licenseNumber = 5
-```
-```js
-var licenseNumber = 5;
-```
-
-</CodeTab>
-
-To represent the concept of "maybe null", you'd turn this into an `option` type by wrapping it. For the sake of a more illustrative example, we'll put a condition around it:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let licenseNumber =
-  if (personHasACar) {
-    Some(5);
-  } else {
-    None;
-  };
-```
-```ml
-let licenseNumber =
-  if personHasACar then
-    Some 5
-  else
-    None
-```
-```js
-var licenseNumber = personHasACar ? 5 : undefined;
-```
-
-</CodeTab>
-
-Later on, when another piece of code receives such value, it'd be forced to handle both cases through [pattern matching](pattern-matching-destructuring.md):
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-switch (licenseNumber) {
-| None =>
-  Js.log("The person doesn't have a car");
-| Some(number) =>
-  Js.log("The person's license number is " ++ Js.Int.toString(number));
-};
-```
-```ml
-let () = match licenseNumber with
-| None ->
-  Js.log "The person doesn't have a car"
-| Some number ->
-  Js.log ("The person's license number is " ^ (Js.Int.toString number))
-```
-```js
-var number = licenseNumber;
-
-if (number !== undefined) {
-  console.log("The person's license number is " + number.toString());
-} else {
-  console.log("The person doesn't have a car");
-}
-```
-
-</CodeTab>
-
-By turning your ordinary number into an `option` type, and by forcing you to handle the `None` case, the language effectively removed the possibility for you to mishandle, or forget to handle, a conceptual `null` value! **A pure ReScript program doesn't have null errors**.
-
-## Interoperate with JavaScript `undefined` and `null`
-
-The `option` type is common enough that we special-case it when compiling to JavaScript:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let x = Some(5);
-```
-```ml
-let x = Some 5
-```
-```js
-var x = 5;
-```
-
-</CodeTab>
-
-simply compiles down to `5`, and
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let x = None;
-```
-```ml
-let x = None
-```
-```js
-var x;
-```
-
-</CodeTab>
-
-compiles to `undefined`! If you've got e.g. a string in JavaScript that you know might be `undefined`, type it as `option(string)` and you're done! Likewise, you can send a `Some(5)` or `None` to the JS side and expect it to be interpreted correctly =)
-
-### Caveat 1
-
-The option-to-undefined translation isn't perfect, because on our side, `option` values can be composed:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let x = Some(Some(Some(5)));
-```
-```ml
-let x = Some (Some (Some 5))
-```
-```js
-var x = 5;
-```
-
-</CodeTab>
-
-This still compiles to `5`, but this gets troublesome:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let x = Some(None);
-```
-```ml
-let x = Some None
-```
-```js
-var Caml_option = require("./stdlib/caml_option.js");
-
-var x = Caml_option.some(undefined);
-```
-
-(See output tab).
-
-</CodeTab>
-
-What's this `Caml_option.some` thing? Why can't this compile to `undefined`? Long story short, when dealing with a polymorphic `option` type (aka `option('a)`, for any `'a`), many operations become tricky if we don't mark the value with some special annotation. If this doesn't make sense, don't worry; just remember the following rule:
-
-- **Never, EVER, pass a nested `option` value (e.g. `Some(Some(Some(5)))`) into the JS side.**
-- **Never, EVER, annotate a value coming from JS as `option('a)`. Always give the concrete, non-polymorphic type.**
-
-### Caveat 2
-
-Unfortunately, lots of times, your JavaScript value might be _both_ `null` or `undefined`. In that case, you unfortunately can't type such value as e.g. `option(int)`, since our `option` type only checks for `undefined` and not `null` when dealing with a `None`.
-
-#### Solution: More Sophisticated `undefined` & `null` Interop
-
-To solve this, we provide access to more elaborate `null` and `undefined` helpers through the [`Js.Nullable`](api/js/nullable) module. This somewhat works like an `option` type, but is different from it.
-
-#### Examples
-
-To create a JS `null`, use the value `Js.Nullable.null`. To create a JS `undefined`, use `Js.Nullable.undefined` (you can naturally use `None` too, but that's not the point here; the `Js.Nullable.*` helpers wouldn't work with it).
-
-If you're receiving, for example, a JS string that can be `null` and `undefined`, type it as:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.module "MyConstant"] external myId: Js.Nullable.t(string) = "myId";
-```
-```ml
-external myId: string Js.Nullable.t = "myId" [@@bs.module "MyConstant"]
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-To create such a nullable string from our side (presumably to pass it to the JS side, for interop purpose), do:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.module "MyIdValidator"] external validate: Js.Nullable.t(string) => bool = "validate";
-let personId: Js.Nullable.t(string) = Js.Nullable.return("abc123");
-
-let result = validate(personId);
-```
-```ml
-external validate: string Js.Nullable.t -> bool = "validate" [@@bs.module "MyIdValidator"]
-let personId: string Js.Nullable.t = Js.Nullable.return "abc123"
-
-let result = validate personId
-```
-```js
-var MyIdValidator = require("MyIdValidator");
-var personId = "abc123";
-var result = MyIdValidator.validate(personId);
-```
-
-</CodeTab>
-
-The `return` part "wraps" a string into a nullable string, to make the type system understand and track the fact that, as you pass this value around, it's not just a string, but a string that can be `null` or `undefined`.
-
-#### Convert to/from `option`
-
-`Js.Nullable.fromOption` converts from a `option` to `Js.Nullable.t`. `Js.Nullable.toOption` does the opposite.
diff --git a/pages/docs/manual/v8.0.0/object.mdx b/pages/docs/manual/v8.0.0/object.mdx
deleted file mode 100644
index 15d76c063..000000000
--- a/pages/docs/manual/v8.0.0/object.mdx
+++ /dev/null
@@ -1,218 +0,0 @@
----
-title: "Object"
-description: "Interoping with JS objects in ReScript"
-canonical: "/docs/manual/latest/object"
----
-
-# Object
-
-ReScript objects are like [records](record.md), but:
-
-- No type declaration needed.
-- Structural and more polymorphic, [unlike records](record.md#record-types-are-found-by-field-name).
-- Doesn't support updates unless the object comes from the JS side.
-- Doesn't support [pattern matching](pattern-matching-destructuring.md).
-
-<!-- TODO: support update man -->
-
-Although ReScript records compile to clean JavaScript objects, ReScript objects are a better candidate for emulating/binding to JS objects, as you'll see.
-
-## Type Declaration
-
-**Optional**, unlike for records. The type of an object is inferred from the value, so you never really need to write down is type definition. Nevertheless, here's its type declaration syntax:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type person = {
-  .
-  "age": int,
-  "name": string
-};
-```
-```re
-type person = <
-  age :int;
-  name :string> Js.t
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Visually similar to record type's syntax, with the field names quoted.
-
-## Creation
-
-To create a new object:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let me = {
-  "age": 5,
-  "name": "Big ReScript"
-};
-```
-```ml
-let me = [%bs.obj {
-  age = 5;
-  name = "Big ReScript";
-}]
-```
-```js
-var me = {
-  "age": 5,
-  "name": "Big ReScript"
-};
-```
-
-</CodeTab>
-
-**Note**: as said above, unlike for record, this `me` value does **not** try to find a conforming type declaration with the field `"age"` and `"name"`; rather, the type of `me` is inferred as `{"age": int, "name": string}`. This is convenient, but also means this code passes type checking without errors:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type person = {
-  .
-  "age": int
-};
-
-let me = {
-  "age": "hello!" // age is a string. No error.
-};
-```
-```ml
-type person = <
-  age :int
-> Js.t
-
-let me = [%bs.obj {
-  age = "hello!" (* age is a string. No error. *)
-}]
-```
-```js
-var me = {
-  "age": "hello!"
-};
-```
-
-</CodeTab>
-
-Since the type checker doesn't try to match `me` with the type `person`. If you ever want to force an object value to be of a predeclared object type, just annotate the value:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```re
-let me: person = {
-  "age": "hello!"
-}
-```
-```ml
-let me: person = [%bs.obj {
-  age = "hello!"
-}]
-```
-
-</CodeTab>
-
-Now the type system will error properly.
-
-## Access
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let age = me##age;
-```
-```ml
-let age = me##age
-```
-```js
-var age = me["age"];
-```
-
-</CodeTab>
-
-## Update
-
-Disallowed unless the object is a binding that comes from the JavaScript side. In that case, use `=`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type student = {
-  [@bs.set] "age": int,
-  [@bs.set] "name": string,
-};
-[@bs.module "MyJSFile"] external student1: student = "student1";
-
-student1##name = "Mary";
-```
-```ml
-type student = <
-  age: int [@bs.set];
-  name: string [@bs.set];
-> Js.t
-external student1: student = "student1" [@@bs.module "MyJSFile"]
-
-student1##name = "Mary"
-```
-```js
-var MyJSFile = require("MyJSFile");
-MyJSFile.student1.name = "Mary";
-```
-
-</CodeTab>
-
-## Tips & Tricks
-
-Since objects don't require type declarations, and since ReScript infers all the types for you, you get to very quickly and easily (and dangerously) bind to any JavaScript API. Check the JS output tab:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-// The type of document is just some random type 'a
-// that we won't bother to specify
-[@bs.val] external document: 'a = "document";
-
-// call a method
-document##addEventListener("mouseup", _event => {
-  Js.log("clicked!");
-});
-
-// get a property
-let loc = document##location;
-
-// set a property
-document##location##href = "rescript-lang.org";
-```
-```ml
-// The type of document is just some random type 'a
-// that we won't bother to specify
-external document: 'a = "document" [@@bs.val]
-
-// call a method
-let () = document##addEventListener "mouseup" (fun _event ->
-  Js.log "clicked!"
-)
-
-// get a property
-let loc = document##location
-
-// set a property
-document##location##href = "rescript-lang.org"
-```
-```js
-document.addEventListener("mouseup", function(_event) {
-  console.log("clicked!");
-});
-var loc = document.location;
-document.location.href = "rescript-lang.org";
-```
-
-</CodeTab>
-
-The `external` feature and the usage of this trick are also documented in the [external](external#tips--tricks) section later. It's an excellent way to start writing some ReScript code without worrying about whether bindings to a particular library exists.
diff --git a/pages/docs/manual/v8.0.0/overview.mdx b/pages/docs/manual/v8.0.0/overview.mdx
deleted file mode 100644
index cc92f72b1..000000000
--- a/pages/docs/manual/v8.0.0/overview.mdx
+++ /dev/null
@@ -1,244 +0,0 @@
----
-title: "Overview"
-metaTitle: "Language Features Overview"
-description: "A quick overview on ReScript's syntax"
-canonical: "/docs/manual/latest/overview"
----
-
-# Overview
-
-## Comparison to JS
-
-**Note**: the comparison is against our Reason syntax, not our ML syntax.
-
-### Semicolon
-
-| JavaScript                           | Us                   |
-| ------------------------------------ | -------------------- |
-| Rules enforced by linter/formatter   | No semicolon needed! |
-
-### Comments
-
-| JavaScript        | Us          |
-| ----------------- | ----------- |
-| `/* Comment */`   | Same        |
-| `// Line comment` | Same        |
-
-### Variable
-
-| JavaScript              | Us                             |
-| ----------------------- | ------------------------------ |
-| `const x = 5;`          | `let x = 5`                    |
-| `var x = y;`            | No equivalent (thankfully)     |
-| `let x = 5; x = x + 1;` | `let x = ref(5); x := x.contents + 1` |
-
-### String & Character
-
-| JavaScript                | Us                      |
-| --------------------------| ----------------------- |
-| `"Hello world!"`          | Same                    |
-| `'Hello world!'`          | Strings must use `"`    |
-| `"hello " + "world"`      | `"hello " ++ "world"`   |
-| `` `hello ${message}` ``  | `\{j|Hello $(message)|j}`|
-
-### Boolean
-
-| JavaScript                           | Us                                             |
-| ------------------------------------ | ---------------------------------------------- |
-| `true`, `false`                      | Same                                           |
-| `!true`                              | Same                                           |
-| `\|\|`, `&&`, `<=`, `>=`, `<`, `>`   | Same                                           |
-| `a === b`, `a !== b`                 | Same                                           |
-| No deep equality (recursive compare) | `a == b`, `a != b`                             |
-| `a == b`                             | No equality with implicit casting (thankfully) |
-
-### Number
-
-| JavaScript  | Us           |
-| ----------- | ------------ |
-| `3`         | Same \*      |
-| `3.1415`    | Same         |
-| `3 + 4`     | Same         |
-| `3.0 + 4.5` | `3.0 +. 4.5` |
-| `5 % 3`     | `5 mod 3`    |
-
-\* JS has no distinction between integer and float.
-
-### Object/Record
-
-| JavaScript          | Us                                      |
-| ------------------- | --------------------------------------- |
-| no types            | `type point = {x: int, mutable y: int}` |
-| `{x: 30, y: 20}`    | Same                                    |
-| `point.x`           | Same                                    |
-| `point.y = 30;`     | Same                                    |
-| `{...point, x: 30}` | Same                                    |
-
-### Array
-
-| JavaScript            | Us                                 |
-| --------------------- | ---------------------------------- |
-| `[1, 2, 3]`           | <code>[&#124;1, 2, 3&#124;]</code> |
-| `myArray[1] = 10`     | Same                               |
-| `[1, "Bob", true]`    | `(1, "Bob", true)` \*              |
-
-\* Heterogenous arrays in JS are disallowed for us. Use tuple instead.
-
-### Null
-
-| JavaScript          | Us        |
-| ------------------- | --------- |
-| `null`, `undefined` | `None` \* |
-
-\* Again, only a spiritual equivalent; we don't have nulls, nor null bugs! But we do have an `option` type for when you actually need nullability.
-
-### Function
-
-| JavaScript                      | Us                           |
-| ------------------------------- | ---------------------------- |
-| `arg => retVal`                 | Same                         |
-| `function named(arg) {...}`     | `let named = (arg) => {...}` |
-| `const f = function(arg) {...}` | `let f = (arg) => {...}`     |
-| `add(4, add(5, 6))`             | Same                         |
-
-### Blocks
-
-<table>
-  <thead>
-    <tr>
-      <th>JavaScript</th>
-      <th>US</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>
-      ```
-      const myFun = (x, y) => {
-        const doubleX = x + x;
-        const doubleY = y + y;
-        return doubleX + doubleY;
-      };
-      ```
-      </td>
-      <td>
-      ```
-      let myFun = (x, y) => {
-        let doubleX = x + x
-        let doubleY = y + y
-        doubleX + doubleY
-      }
-      ```
-      </td>
-    </tr>
-  </tbody>
-</table>
-
-
-### If-else
-
-| JavaScript            | Us                                                                  |
-| --------------------- | ------------------------------------------------------------------- |
-| `if (a) {b} else {c}` | `if (a) {b} else {c}` \*                                            |
-| `a ? b : c`           | Same                                                                |
-| `switch`              | `switch` but [super-powered pattern matching!](pattern-matching-destructuring.md) |
-
-\* Our conditionals are always expressions! You can write `let result = if (a) {"hello"} else {"bye"}`
-
-### Destructuring
-
-| JavaScript                    | Us                                            |
-| ----------------------------- | --------------------------------------------- |
-| `const {a, b} = data`         | `let {a, b} = data`                           |
-| `const [a, b] = data`         | <code>let [&#124;a, b&#124;] = data</code> \* |
-| `const {a: aa, b: bb} = data` | `let {a: aa, b: bb} = data`                   |
-
-\* Gives good compiler warning that `data` might not be of length 2.
-
-### Loop
-
-| JavaScript                            | Us                             |
-| ------------------------------------- | ------------------------------ |
-| `for (let i = 0; i <= 10; i++) {...}` | `for (i in 0 to 10) {...}`     |
-| `for (let i = 10; i >= 0; i--) {...}` | `for (i in 10 downto 0) {...}` |
-| `while (true) {...}`                  | `while (true) {...}`           |
-
-### JSX
-
-| JavaScript                                | Us                         |
-| ----------------------------------------- | -------------------------- |
-| `<Comp message="hi" onClick={handler} />` | Same                       |
-| `<Comp message=message />`                | `<Comp message />` \*      |
-| `<input checked />`                       | `<input checked=true />`   |
-| No children spread                        | `<Comp>...children</Comp>` |
-
-\* Argument punning!
-
-### Exception
-
-| JavaScript                                | Us                                         |
-| ----------------------------------------- | ------------------------------------------ |
-| `throw new SomeError(...)`                | `raise(SomeError(...))`                    |
-| `try {a} catch (Err) {...} finally {...}` | `try a catch { \| Err => ...}` \* |
-
-\* No finally.
-
-### Blocks
-
-The last expression of a block delimited by `{}` implicitly returns (including function body). In JavaScript, this can only be simulated via an immediately-invoked function expression (since function bodies have their own local scope).
-
-<table>
-  <thead>
-    <tr>
-      <th>JavaScript</th>
-      <th>US</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>
-      ```
-      let result = (function() {
-        const x = 23;
-        const y = 34;
-        return x + y;
-      })();
-      ```
-      </td>
-      <td>
-      ```
-      let result = {
-        let x = 23
-        let y = 34
-        x + y
-      }
-      ```
-      </td>
-    </tr>
-  </tbody>
-</table>
-
-## Common Features' JS Output
-
-Feature                         | Example                              | JavaScript Output
---------------------------------|--------------------------------------|----------------------
-String                          | `"Hello"`                            | `"Hello"`
-String Interpolation            | `\{j|Hello $(message)|j}`             | `"Hello " + message`
-Character (disrecommended)      | `'x'`                                | `120` (char code)
-Integer                         | `23`, `-23`                          | `23`, `-23`
-Float                           | `23.0`, `-23.0`                      | `23.0`, `-23.0`
-Integer Addition                | `23 + 1`                             | `23 + 1`
-Float Addition                  | `23.0 +. 1.0`                        | `23.0 + 1.0`
-Integer Division/Multiplication | `2 / 23 * 1`                         | `2 / 23 * 1`
-Float Division/Multiplication   | `2.0 /. 23.0 *. 1.0`                 | `2.0 / 23.0 * 1.0`
-Float Exponentiation            | `2.0 ** 3.0`                         | `Math.pow(2.0, 3.0)`
-String Concatenation            | `"Hello " ++ "World"`                | `"Hello " + "World"`
-Comparison                      | `>`, `<`, `>=`, `<=`                 | `>`, `<`, `>=`, `<=`
-Boolean operation               | `!`, `&&`, `\|\|`                    | `!`, `&&`, `\|\|`
-Shallow and deep Equality       | `===`, `==`                          | `===`, `==`
-List (disrecommended)           | `[1, 2, 3]`                          | `{hd: 1, tl: {hd: 2, tl: {hd: 3, tl: 0}}}`
-List Prepend                    | `[a1, a2, ...oldList]`               | `{hd: a1, tl: {hd: a2, tl: theRest}}`
-Array                           | <code>[&#124;1, 2, 3&#124;]</code>   | `[1, 2, 3]`
-Record                          | `type t = {b: int}; let a = {b: 10}` | `var a = {b: 10}`
-Multiline Comment               | `/* Comment here */`                 | Not in output
-Single line Comment             | `// Comment here`                    | Not in output
diff --git a/pages/docs/manual/v8.0.0/pattern-matching-destructuring.mdx b/pages/docs/manual/v8.0.0/pattern-matching-destructuring.mdx
deleted file mode 100644
index 275af4b23..000000000
--- a/pages/docs/manual/v8.0.0/pattern-matching-destructuring.mdx
+++ /dev/null
@@ -1,872 +0,0 @@
----
-title: "Pattern Matching / Destructuring"
-description: "Pattern matching and destructuring complex data structures in ReScript"
-canonical: "/docs/manual/latest/pattern-matching-destructuring"
----
-
-# Pattern Matching / Destructuring
-
-One of ReScript's **best** feature is our pattern matching. Pattern matching combines 3 brilliant features into one:
-
-- Destructuring.
-- `switch` based on shape of data.
-- Exhaustiveness check.
-
-We'll dive into each aspect below.
-
-## Destructuring
-
-Even JavaScript has destructuring, which is "opening up" a data structure to extract the parts we want and assign variable names to them:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let coordinates = (10, 20, 30);
-let (x, _, _) = coordinates;
-Js.log(x); // 10
-```
-```ml
-let coordinates = (10, 20, 30)
-let (x, _, _) = coordinates
-Js.log x (* 10 *)
-```
-```js
-var coordinates = [10, 20, 30];
-var x = 10;
-console.log(10);
-```
-
-</CodeTab>
-
-Destructuring works with most built-in data structures:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-// Record
-type student = {name: string, age: int};
-let student1 = {name: "John", age: 10};
-let {name} = student1; // "John" assigned to `name`
-
-// Variant
-type result =
-  | Success(string);
-let myResult = Success("You did it!");
-let Success(message) = myResult; // "You did it!" assigned to `message`
-
-// Array
-let myArray = [|1, 2, 3|];
-let [|item1, item2, _|] = myArray; // 1 assigned to `item1`, 2 assigned to `item2`, 3rd item ignored
-
-// List
-let myList = [1, 2, 3];
-let [head, ...tail] = myList; // 1 assigned to `head`, `[2, 3]` assigned to tail
-```
-```ml
-// Record
-type student = {name: string; age: int}
-let student1 = {name = "John"; age = 10}
-let {name} = student1; (* "John" assigned to `name` *)
-
-(* Variant *)
-type result =
-  | Success of string
-let myResult = Success "You did it!"
-let Success message = myResult (* "You did it!" assigned to `message` *)
-
-(* Array *)
-let myArray = [|1; 2; 3|]
-let [|item1; item2; _|] = myArray (* 1 assigned to `item1`, 2 assigned to `item2`, 3rd item ignored *)
-
-(* List *)
-let myList = [1; 2; 3]
-let head::tail = myList (* 1 assigned to `head`, `[2, 3]` assigned to tail *)
-```
-```js
-var student1 = {
-  name: "John",
-  age: 10
-};
-var name = "John";
-
-var myResult = /* Success */{
-  _0: "You did it!"
-};
-var message = "You did it!"
-
-var myArray = [1, 2, 3];
-if (myArray.length !== 2) {
-  throw {
-    RE_EXN_ID: "Match_failure",
-    _1: [
-      "playground.res",
-      14,
-      4
-    ],
-    Error: new Error()
-  };
-}
-var item1 = myArray[0];
-var item2 = myArray[1];
-
-var myList = {
-  hd: 1,
-  tl: {
-    hd: 2,
-    tl: {
-      hd: 3,
-      tl: /* [] */0
-    }
-  }
-};
-// ...
-```
-
-</CodeTab>
-
-You can also use destructuring anywhere you'd usually put a binding:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type result =
-  | Success(string);
-let displayMessage = (Success(m)) => {
-  // we've directly extracted the success message
-  // string by destructuring the parameter
-  Js.log(m);
-}
-displayMessage(Success("You did it!"));
-```
-```ml
-type result =
-  | Success of string
-let displayMessage (Success m) =
-  (* we've directly extracted the success message *)
-  (* string by destructuring the parameter *)
-  Js.log m
-
-let () = displayMessage (Success "You did it!")
-```
-```js
-function displayMessage(m) {
-  console.log(m._0);
-}
-
-displayMessage(/* Success */{
-  _0: "You did it!"
-});
-```
-
-</CodeTab>
-
-For a record, you can rename the field while destructuring:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let {name: n} = student1; // "John" assigned to `n`
-```
-```ml
-let {name = n} = student1 (* "John" assigned to `n` *)
-```
-```js
-var n = "John";
-```
-
-</CodeTab>
-
-## `switch` Based on Shape of Data
-
-While the destructuring aspect of pattern matching is nice, it doesn't really change the way you think about structuring your code. One paradigm-changing way of thinking about your code is to execute some code based on the shape of the data.
-
-Consider a variant:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type payload =
-  | BadResult(int)
-  | GoodResult(string)
-  | NoResult;
-```
-```ml
-type payload =
-  | BadResult of int
-  | GoodResult of string
-  | NoResult
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-We'd like to handle each of the 3 cases differently. For example, print a success message if the value is `GoodResult(...)`, do something else when the value is `NoResult`, etc.
-
-In other languages, you'd end up with a series of if-elses that are hard to read and error-prone. In ReScript, you can instead use the supercharged `switch` pattern matching facility to destructure the value while calling the right code based on what you destructured:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let data = GoodResult("Product shipped!");
-switch (data) {
-| GoodResult(theMessage) =>
-  Js.log("Success! " ++ theMessage)
-| BadResult(errorCode) =>
-  Js.log("Something's wrong. The error code is: " ++ Js.Int.toString(errorCode))
-| NoResult =>
-  Js.log("Bah.")
-};
-```
-```ml
-let data = GoodResult ("Product shipped!")
-let () = match data with
-| GoodResult theMessage ->
-  Js.log ("Success! " ^ theMessage)
-| BadResult errorCode ->
-  Js.log ("Something's wrong. The error code is: " ^ (Js.Int.toString errorCode))
-| NoResult -> Js.log "Bah."
-```
-```js
-var data = {
-  TAG: /* GoodResult */1,
-  _0: "Product shipped!"
-};
-
-if (typeof data === "number") {
-  console.log("Bah.");
-} else if (data.TAG) {
-  console.log("Success! Product shipped!");
-} else {
-  console.log("Something's wrong. The error code is: " + "Product shipped!".toString());
-}
-```
-
-</CodeTab>
-
-In this case, `message` will have the value `"Success! Product shipped!"`.
-
-Suddenly, your if-elses that messily checks some structure of the value got turned into a clean, compiler-verified, linear list of code to execute based on exactly the shape of the value.
-
-### Complex Examples
-
-Here's a real-world scenario that'd be a headache to code in other languages. Given this data structure:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type status = Vacations(int) | Sabbatical(int) | Sick | Present;
-type reportCard = {passing: bool, gpa: float};
-type person =
-  | Teacher({
-    name: string,
-    age: int,
-  })
-  | Student({
-    name: string,
-    status: status,
-    reportCard: reportCard,
-  });
-```
-```ml
-type status = Vacations of int | Sabbatical of int | Sick | Present
-type reportCard = {passing: bool; gpa: float}
-type person =
-  | Teacher of {
-    name: string;
-    age: int;
-  }
-  | Student of {
-    name: string;
-    status: status;
-    reportCard: reportCard;
-  }
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Imagine this requirement:
-
-- Informally greet a person who's a teacher and if his name is Mary or Joe.
-- Greet other teachers formally.
-- If the person's a student, congratulate him/her score if they passed the semester.
-- If the student has a gpa of 0 and is on vacations or sabbatical, display a different message.
-- A catch-all message for a student.
-
-ReScript can do this easily!
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let message = switch (person1) {
-| Teacher({name: "Mary" | "Joe"}) =>
-  "Hey, still going to the party on Saturday?"
-| Teacher({name}) =>
-  // this is matched only if `name` isn't "Joe"
-  {j|Hello $(name).|j}
-| Student({name, reportCard: {passing: true, gpa}}) =>
-  "Congrats " ++ name + ", nice GPA of " ++ Js.Float.toString(gpa) ++ " you got there!"
-| Student({
-    reportCard: {gpa: 0.0},
-    status: Vacations(daysLeft) | Sabbatical(daysLeft)
-  }) =>
-  "Come back in " ++ Js.Int.toString(daysLeft) ++ " days!"
-| Student({status: Sick}) =>
-  "How are you feeling?"
-| Student({name}) =>
-  {j|Good luck next semester $(name)!|j}
-};
-```
-```ml
-let message = match person1 with
-| Teacher {name = "Mary" | "Joe"} ->
-  "Hey, still going to the party on Saturday?"
-| Teacher {name} ->
-  (* this is matched only if `name` isn't "Joe" *)
-  {j|Hello $(name).|j}
-| Student {name; reportCard = {passing = true; gpa}} ->
-  "Congrats " ++ name + ", nice GPA of " ++ Js.Float.toString(gpa) ++ " you got there!"
-| Student {
-    reportCard = {gpa = 0.0};
-    status = (Vacations daysLeft) | (Sabbatical daysLeft)
-  } ->
-  "Come back in " ++ (Js.Int.toString daysLeft) ++ " days!"
-| Student {status = Sick} ->
-  "How are you feeling?"
-| Student {name} ->
-  {j|Good luck next semester $(name)!|j}
-```
-```js
-var message;
-
-if (person1.TAG) {
-  var match$1 = person1.status;
-  var name = person1.name;
-  var match$2 = person1.reportCard;
-  message = match$2.passing
-    ? "Congrats " +
-      name +
-      ", nice GPA of " +
-      match$2.gpa.toString() +
-      " you got there!"
-    : typeof match$1 === "number"
-    ? match$1 !== 0
-      ? "Good luck next semester " + name + "!"
-      : "How are you feeling?"
-    : person1.reportCard.gpa !== 0.0
-    ? "Good luck next semester " + name + "!"
-    : "Come back in " + match$1._0.toString() + " days!";
-} else {
-  var name$1 = person1.name;
-  switch (name$1) {
-    case "Joe":
-    case "Mary":
-      message = "Hey, still going to the party on Saturday?";
-      break;
-    default:
-      message = "Hello " + name$1 + ".";
-  }
-}
-```
-
-</CodeTab>
-
-**Note** how we've:
-- drilled deep down into the value concisely
-- using a nested pattern check `"Mary" | "Joe"` and `Vacations | Sabbatical`
-- while extracting the `daysLeft` number from the latter case
-- and assigned the greeting to the binding `message`.
-
-Here's another example of pattern matching, this time on an inline tuple.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type animal = Dog | Cat | Bird;
-let categoryId = switch (isBig, myAnimal) {
-| (true, Dog) => 1
-| (true, Cat) => 2
-| (true, Bird) => 3
-| (false, Dog | Cat) => 4
-| (false, Bird) => 5
-};
-```
-```ml
-type animal = Dog | Cat | Bird
-let categoryId = match (isBig, myAnimal) with
-| (true, Dog) -> 1
-| (true, Cat) -> 2
-| (true, Bird) -> 3
-| (false, (Dog | Cat)) -> 4
-| (false, Bird) -> 5
-```
-```js
-var categoryId = isBig ? (myAnimal + 1) | 0 : myAnimal >= 2 ? 5 : 4;
-```
-
-</CodeTab>
-
-**Note** how pattern matching on a tuple is equivalent to a 2D table:
-
-isBig \ myAnimal | Dog | Cat | Bird
------------------|-----|-----|------
-true             |  1  |  2  |  3
-false            |  4  |  4  |  5
-
-### Ignore Part of a Value
-
-If you have a value like `Teacher(payload)` where you just want to pattern match on the `Teacher` part and ignore the `payload` completely, you can use the `_` wildcard like this:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-switch (person) {
-| Teacher(_) => Js.log("Hi teacher")
-| Student(_) => Js.log("Hey student")
-};
-```
-```ml
-let () = match person with
-| Teacher _ -> Js.log "Hi teacher"
-| Student _ -> Js.log "Hey student"
-```
-```js
-if (person.TAG) {
-  console.log("Hey student");
-} else {
-  console.log("Hi teacher");
-}
-```
-
-</CodeTab>
-
-`_` also works at the top level of the pattern like `| _ => ...` if you want to execute catch-all condition.
-
-### When Clause
-
-Sometime, you want to check more than the shape of a value. You want to also run some arbitrary check on it. You might be tempted to write this:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-switch (person) {
-| Teacher(_) => () // do nothing
-| Student({reportCard: {gpa}}) =>
-  if (gpa < 0.5) {
-    Js.log("What's happening")
-  } else {
-    Js.log("Heyo")
-  }
-};
-```
-```ml
-let () = match person with
-| Teacher _ -> () (* do nothing *)
-| Student {reportCard = {gpa}} ->
-  if gpa < 0.5 then
-    Js.log "What's happening"
-  else
-    Js.log "Heyo"
-```
-```js
-if (person.TAG) {
-  if (person.reportCard.gpa < 0.5) {
-    console.log("What's happening");
-  } else {
-    console.log("Heyo");
-  }
-}
-```
-
-</CodeTab>
-
-`switch` patterns support a shortcut for the arbitrary `if` check, to keep your pattern linear-looking:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-switch (person) {
-| Teacher(_) => () // do nothing
-| Student({reportCard: {gpa}}) when gpa < 0.5 =>
-  Js.log("What's happening");
-| Student(_) =>
-  // fall-through, catch-all case
-  Js.log("Heyo");
-}
-```
-```ml
-let () = match person with
-| Teacher _ -> () (* do nothing *)
-| Student {reportCard = {gpa}} when gpa < 0.5 ->
-  Js.log "What's happening"
-| Student _ ->
-  (* fall-through, catch-all case *)
-  Js.log "Heyo"
-```
-```js
-if (person.TAG) {
-  if (person.reportCard.gpa < 0.5) {
-    console.log("What's happening");
-  } else {
-    console.log("Heyo");
-  }
-}
-```
-
-</CodeTab>
-
-### Match on Exceptions
-
-If the function throws an exception (covered later), you can also match on _that_, in addition to the function's normally returned values.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-switch (List.find(i => i === theItem, myItems)) {
-| item => Js.log(item)
-| exception Not_found => Js.log("No such item found!")
-};
-```
-```ml
-let () = match List.find (fun i -> i == theItem) myItems with
-| item -> Js.log item
-| exception Not_found -> Js.log "No such item found!"
-```
-```js
-var exit = 0;
-
-var item;
-
-try {
-  item = List.find(function(i) {
-    return i === theItem;
-  }, myItems);
-  exit = 1;
-}
-catch (raw_exn){
-  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-  if (exn.RE_EXN_ID === "Not_found") {
-    console.log("No such item found!");
-  } else {
-    throw exn;
-  }
-}
-
-if (exit === 1) {
-  console.log(item);
-}
-```
-
-</CodeTab>
-
-### Small Pitfall
-
-**Note**: you can only pass literals (i.e. concrete values) as a pattern, not let-binding names or other things. The following doesn't work as expected:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let coordinates = (10, 20, 30)
-let centerY = 20
-switch (coordinates) {
-| (x, centerY, _) => /* code */
-}
-```
-```ml
-let coordinates = (10, 20, 30)
-let centerY = 20
-let () = match coordinates with
-| (x, centerY, _) => (* code *)
-```
-```js
-var coordinates = [10, 20, 30];
-var centerY = 20;
-
-console.log(10);
-```
-
-</CodeTab>
-
-A first time ReScript user might accidentally write that code, assuming that it's matching on `coordinates` when the second value is of the same value as `centerY`. In reality, this is interpreted as matching on coordinates and assigning the second value of the tuple to the name `centerY`, which isn't what's intended.
-
-## Exhaustiveness Check
-
-As if the above features aren't enough, ReScript also provides arguably the most important pattern matching feature: **compile-time check of missing patterns**.
-
-Let's revisit one of the above examples:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let message = switch (person) {
-| Teacher({name: "Mary" | "Joe"}) =>
-  "Hey, still going to the party on Saturday?"
-| Student({name, reportCard: {passing: true, gpa}}) =>
-  "Congrats " ++ name ++ ", nice GPA of " ++ Js.Float.toString(gpa) ++ " you got there!"
-| Student({
-    reportCard: {gpa: 0.0},
-    status: Vacations(daysLeft) | Sabbatical(daysLeft)
-  }) =>
-  "Come back in " ++ Js.Int.toString(daysLeft) ++ " days!"
-| Student({status: Sick}) =>
-  "How are you feeling?"
-| Student({name}) =>
-  "Good luck next semester " ++ name ++ "!"
-}
-```
-```ml
-let message = match person with
-| Teacher {name = "Mary" | "Joe"} ->
-  "Hey, still going to the party on Saturday?"
-| Student {name; reportCard = {passing = true; gpa}} ->
-  "Congrats " ^ name ^ ", nice GPA of " ^ (Js.Float.toString gpa) ^ " you got there!"
-| Student {
-    reportCard = {gpa = 0.0};
-    status = (Vacations daysLeft) | (Sabbatical daysLeft)
-  } ->
-  "Come back in " ^ (Js.Int.toString daysLeft) ^ " days!"
-| Student {status = Sick} ->
-    "How are you feeling?"
-| Student {name} ->
-  "Good luck next semester "^ name ^ "!"
-```
-```js
-if (person.TAG) {
-  var match$1 = person.status;
-  var name = person.name;
-  var match$2 = person.reportCard;
-  if (match$2.passing) {
-    "Congrats " + name + ", nice GPA of " + match$2.gpa.toString() + " you got there!";
-  } else if (typeof match$1 === "number") {
-    if (match$1 !== 0) {
-      "Good luck next semester " + name + "!";
-    } else {
-      "How are you feeling?";
-    }
-  } else if (person.reportCard.gpa !== 0.0) {
-    "Good luck next semester " + name + "!";
-  } else {
-    "Come back in " + match$1._0.toString() + " days!";
-  }
-} else {
-  switch (person.name) {
-    case "Joe":
-    case "Mary":
-      break;
-    default:
-      throw {
-        RE_EXN_ID: "Match_failure",
-        _1: [
-          "playground.res",
-          13,
-          0
-        ],
-        Error: new Error()
-      };
-  }
-}
-```
-
-</CodeTab>
-
-Did you see what we removed? This time, we've omitted the handling of the case where `person` is `Teacher({name})` when `name` isn't Mary or Joe.
-
-Failing to handle every scenario of a value likely constitutes the majority of program bugs out there. This happens very often when you refactor a piece of code someone else wrote. Fortunately for ReScript, the compiler will tell you so:
-
-```
-Warning 8: this pattern-matching is not exhaustive.
-Here is an example of a value that is not matched:
-Some({name: ""})
-```
-
-**BAM**! You've just erased an entire category of important bugs before you even ran the code. In fact, this is how most of nullable values is handled:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-switch (myNullableValue) {
-| Some(v) => Js.log("value is present")
-| None => Js.log("value is absent")
-};
-```
-```ml
-match myNullableValue with
-| Some v -> Js.log "value is present"
-| None -> Js.log "value is absent"
-```
-```js
-if (myNullableValue !== undefined) {
-  console.log("value is present");
-} else {
-  console.log("value is absent");
-}
-```
-
-</CodeTab>
-
-If you don't handle the `None` case, the compiler warns. No more `undefined` bugs in your code!
-
-## Conclusion & Tips & Tricks
-
-Hopefully you can see how pattern matching is a game changer for writing correct code, through the concise destructuring syntax, the proper conditions handling of `switch`, and the static exhaustiveness check.
-
-Here are some advices.
-
-Do not abuse the wildcard `_` too much. This prevents the compiler from giving you better exhaustiveness check, which would be especially important after a refactoring where you add a new case to a variant. Try only using `_` against infinite possibilities, e.g. string, int, etc.
-
-Use `when` clause sparingly.
-
-**Flatten your pattern-match whenever you can**. This is a real bug remover. Here's a series of examples, from worst to best:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let optionBoolToBool = opt => {
-  if (opt == None) {
-    false
-  } else if (opt === Some(true)) {
-    true
-  } else {
-    false
-  }
-}
-```
-```ml
-let optionBoolToBool opt =
-  if opt = None
-    then false
-  else if opt == Some true then
-    true
-  else false
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt === undefined) {
-    return false;
-  } else {
-    return opt === true;
-  }
-}
-```
-
-</CodeTab>
-
-Now that's just silly =). Let's turn it into pattern-matching:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let optionBoolToBool = opt => {
-  switch (opt) {
-  | None => false
-  | Some(a) => a ? true : false
-  }
-};
-```
-```ml
-let optionBoolToBool opt =
-  match opt with
-  | None -> false
-  | Some a -> if a then true else false
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt !== undefined && opt) {
-    return true;
-  } else {
-    return false;
-  }
-}
-```
-
-</CodeTab>
-
-Slightly better, but still nested. Pattern-matching allows you to do this:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let optionBoolToBool = opt => {
-  switch (opt) {
-  | None => false
-  | Some(true) => true
-  | Some(false) => false
-  }
-};
-```
-```ml
-let optionBoolToBool opt =
-  match opt with
-  | None -> false
-  | Some true -> true
-  | Some false -> false
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt !== undefined && opt) {
-    return true;
-  } else {
-    return false;
-  }
-}
-```
-
-</CodeTab>
-
-Much more linear-looking! Now, you might be tempted to do this:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let optionBoolToBool = opt => {
-  switch (opt) {
-  | Some(true) => true
-  | _ => false
-  }
-};
-```
-```ml
-let optionBoolToBool opt =
-  match opt with
-  | Some true -> true
-  | _ -> false
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt !== undefined && opt) {
-    return true;
-  } else {
-    return false;
-  }
-}
-```
-
-</CodeTab>
-
-Which is much more concise, but kills the exhaustiveness check mentioned above; refrain from using that. This is the best:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let optionBoolToBool opt =
-  match opt with
-  | Some trueOrFalse -> trueOrFalse
-  | None -> false
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt !== undefined) {
-    return opt;
-  } else {
-    return false;
-  }
-}
-```
-
-</CodeTab>
-
-Pretty darn hard to make a mistake in this code at this point! Whenever you'd like to use an if-else with many branches, prefer pattern matching instead. It's more concise and [performant](variant#design-decisions) too.
diff --git a/pages/docs/manual/v8.0.0/pipe.mdx b/pages/docs/manual/v8.0.0/pipe.mdx
deleted file mode 100644
index e5138e25a..000000000
--- a/pages/docs/manual/v8.0.0/pipe.mdx
+++ /dev/null
@@ -1,308 +0,0 @@
----
-title: "Pipe"
-description: "The Pipe operator (->)"
-canonical: "/docs/manual/latest/pipe"
----
-
-# Pipe
-
-ReScript provides a tiny but surprisingly useful operator `->`, called the "pipe", that allows you to "flip" your code inside-out. `a(b)` becomes `b->a`. It's a simple piece of syntax that doesn't have any runtime cost.
-
-Why would you use it? Imagine you have the following:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-validateAge(getAge(parseData(person)));
-```
-```ml
-validateAge (getAge (parseData person))
-```
-```js
-validateAge(getAge(parseData(person)));
-```
-
-</CodeTab>
-
-This is slightly hard to read, since you need to read the code from the innermost part, to the outer parts. Use pipe to streamline it:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-person
-  ->parseData
-  ->getAge
-  ->validateAge;
-```
-```ml
-person
-  |. parseData
-  |. getAge
-  |. validateAge
-```
-```js
-validateAge(getAge(parseData(person)));
-```
-
-</CodeTab>
-
-Basically, `parseData(person)` is transformed into `person->parseData`, and `getAge(person->parseData)` is transformed into `person->parseData->getAge`, etc.
-
-**This works when the function takes more than one argument too**.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-a(one, two, three);
-```
-```ml
-a one two three
-```
-```js
-a(one, two, three);
-```
-
-</CodeTab>
-
-is the same as
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-one->a(two, three);
-```
-```ml
-one |. a two three
-```
-```js
-a(one, two, three);
-```
-
-</CodeTab>
-
-This also works with labeled arguments.
-
-Pipes are used to emulate object-oriented programming, e.g. what's `myStudent.getName` in other languages like Java would be `myStudent->getName` in ReScript (aka `getName(myStudent)`). This allows us to have the readability of the good parts of OOP without its downside of dragging in a huge class system just to call a function on a piece of data.
-
-## Tips & Tricks
-
-Do **not** to abuse pipes; they're a means to an end. Inexperienced engineers sometimes shape a library's API to take advantage of the pipe. This is backward.
-
-## JS Method Chaining
-
-_This section requires understanding of [our binding API](bind-to-js-function.md#object-method)_.
-
-JavaScript's APIs are often attached to objects, and often chainable, like so:
-
-```js
-const result = [|1, 2, 3|].map(a => a + 1).filter(a => a % 2 === 0);
-
-asyncRequest()
-  .setWaitDuration(4000)
-  .send();
-```
-
-Assuming we don't need the chaining behavior above, we'd bind to each case this using `bs.send` from the previous section:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.send] external map: (array('a), 'a => 'b) => array('b) = "map";
-[@bs.send] external filter: (array('a), 'a => bool) => array('a) = "filter";
-
-type request;
-[@bs.val] external asyncRequest: unit => request = "asyncRequest";
-[@bs.send] external setWaitDuration: (request, int) => request = "setWaitDuration";
-[@bs.send] external send: request => unit = "send";
-```
-```ml
-external map: 'a array -> ('a -> 'b) -> 'b array = "map" [@@bs.send]
-external filter: 'a array -> ('a -> bool) -> 'a array = "filter" [@@bs.send]
-
-type request
-external asyncRequest: unit -> request = "asyncRequest" [@@bs.val]
-external setWaitDuration: request -> int -> request = "setWaitDuration" [@@bs.send]
-external send: request -> unit = "send" [@@bs.send]
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-You'd use them like this:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let result = Js.Array2.filter(
-  Js.Array2.map([|1, 2, 3|], a => a + 1),
-  a => a mod 2 == 0
-);
-
-send(setWaitDuration(asyncRequest(), 4000));
-```
-```ml
-let result = Js.Array2.filter
-  (Js.Array2.map [|1; 2; 3|] (fun a -> a + 1))
-  (fun a -> (a mod 2) = 0)
-
-let () = send (setWaitDuration (asyncRequest ()) 4000)
-```
-```js
-var result = [1, 2, 3].map(function(a) {
-  return a + 1 | 0;
-}).filter(function(a) {
-  return a % 2 === 0;
-});
-
-asyncRequest().setWaitDuration(4000).send();
-```
-
-</CodeTab>
-
-This looks much worse than the JS counterpart! Clean it up visually with pipe:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let result = [|1, 2, 3|]
-  ->map(a => a + 1)
-  ->filter(a => a mod 2 == 0)
-
-asyncRequest()->setWaitDuration(4000)->send
-```
-```ml
-let result = [|1; 2; 3|]
-  |. map(fun a -> a + 1)
-  |. filter(fun a -> a mod 2 = 0)
-
-asyncRequest()->setWaitDuration(4000)->send
-```
-```js
-var result = [1, 2, 3].map(function(a) {
-  return a + 1 | 0;
-}).filter(function(a) {
-  return a % 2 === 0;
-});
-
-asyncRequest().setWaitDuration(4000).send();
-```
-
-</CodeTab>
-
-## Pipe Into Variants
-
-You can pipe into a variant's constructor as if it was a function:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let result = name->preprocess->Some;
-```
-```ml
-let result = name |. preprocess |. Some
-```
-```js
-var result = preprocess(name);
-```
-
-</CodeTab>
-
-We turn this into:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let result = Some(preprocess(name));
-```
-```ml
-let result = Some (preprocess name)
-```
-```js
-var result = preprocess(name);
-```
-
-</CodeTab>
-
-**Note** that using a variant constructor as a function wouldn't work anywhere else beside here.
-
-## Pipe Placeholders
-
-A placeholder is written as an underscore and it tells ReScript that you want to fill in an argument of a function later. These two have equivalent meaning:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```re
-let addTo7 = (x) => add3(3, x, 4);
-let addTo7 = add3(3, _, 4);
-```
-```ml
-(* doesn't exist in old ML syntax *)
-```
-
-</CodeTab>
-
-Sometimes you don't want to pipe the value you have into the first position. In these cases you can mark a placeholder value to show which argument you would like to pipe into.
-
-Let's say you have a function `namePerson`, which takes a `person` then a `name` argument. If you are transforming a person then pipe will work as-is:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-makePerson(~age=47, ())
-  ->namePerson("Jane");
-```
-```ml
-makePerson ~age=47 ()
-  |. namePerson("Jane")
-```
-```js
-namePerson(makePerson(47), "Jane");
-```
-
-</CodeTab>
-
-If you have a name that you want to apply to a person object, you can use a placeholder:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-getName(input)
-  ->namePerson(personDetails, _);
-```
-```ml
-(* doesn't exist in old ML syntax *)
-```
-```js
-var __x = getName(input);
-namePerson(personDetails, __x);
-```
-
-</CodeTab>
-
-This allows you to pipe into any positional argument. It also works for named arguments:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-getName(input)
-  ->namePerson(~person=personDetails, ~name=_);
-```
-```ml
-(* doesn't exist in old ML syntax *)
-```
-```js
-var __x = getName(input);
-namePerson(personDetails, __x);
-```
-
-</CodeTab>
-
-## Triangle Pipe (Deprecated)
-
-You might see usages of another pipe, `|>`, in some codebases. These are deprecated.
-
-Unlike `->` pipe, the `|>` pipe puts the subject as the last (not first) argument of the function. `a |> f(b)` turns into `f(b, a)`.
-
-For a more thorough discussion on the rationale and differences between the two operators, please refer to the [Data-first and Data-last comparison by Javier Chávarri](https://www.javierchavarri.com/data-first-and-data-last-a-comparison/)
diff --git a/pages/docs/manual/v8.0.0/primitive-types.mdx b/pages/docs/manual/v8.0.0/primitive-types.mdx
deleted file mode 100644
index 73a59978a..000000000
--- a/pages/docs/manual/v8.0.0/primitive-types.mdx
+++ /dev/null
@@ -1,164 +0,0 @@
----
-title: "Primitive Types"
-description: "Primitive Data Types in ReScript"
-canonical: "/docs/manual/latest/primitive-types"
----
-
-# Primitive Types
-
-ReScript comes with the familiar primitive types like `string`, `int`, `float`, etc.
-
-## String
-
-ReScript `string`s are delimited using **double** quotes (single quotes are reserved for the character type below).
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let greeting = "Hello world!";
-let multilineGreeting = "Hello
- world!";
-```
-```ml
-let greeting = "Hello world!"
-let multilineGreeting = "Hello
- world!";
-```
-```js
-var greeting = "Hello world!";
-var multilineGreeting = "Hello\n world!";
-```
-
-</CodeTab>
-
-To concatenate strings, use `++`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let greetings = "Hello " ++ "world!";
-```
-```ml
-let greetings = "Hello " ^ "world!"
-```
-```js
-var greetings = "Hello world!";
-```
-
-</CodeTab>
-
-### String Interpolation
-
-There's a special syntax for string that allows
-
-- multiline string just like before
-- Interpolation
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let greeting = {j|Hello
-World
-$(name)
-|j}
-```
-```ml
-let greeting = {j|Hello
-World
-$(name)
-|j}
-```
-```js
-var greeting = "Hello\nWorld\n" + name + "\n";
-```
-
-</CodeTab>
-
-This is just like JavaScript's backtick string interpolation.
-
-### Usage
-
-See the familiar `Js.String` API in the [API docs](api/js/string). Since a ReScript string maps to a JavaScript string, you can mix & match the string operations in both standard libraries.
-
-### Tips & Tricks
-
-**You have a good type system now**! In an untyped language, you'd often overload the meaning of string by using it as:
-
-- a unique id: `var BLUE_COLOR = "blue"`
-- an identifier into a data structure: `var BLUE = "blue" var RED = "red" var colors = [BLUE, RED]`
-- the name of an object field: `person["age"] = 24`
-- an enum: `if (audio.canPlayType() === 'probably') {...}` [(ಠ_ಠ)](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/canPlayType#Return_value)
-- other crazy patterns you'll soon find horrible, after getting used to ReScript's alternatives.
-
-The more you overload the poor string type, the less the type system (or a teammate) can help you! ReScript provides concise, fast and maintainable types & data structures alternatives to the use-cases above (e.g. variants, in a later section).
-
-## Char
-
-ReScript has a type for a string with a single letter:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let firstLetterOfAlphabet = 'a';
-```
-```ml
-let firstLetterOfAlphabet = 'a'
-```
-```js
-var firstLetterOfAlphabet = /* "a" */97;
-```
-
-</CodeTab>
-
-**Note**: Char doesn't support Unicode or UTF-8 and is therefore not recommended.
-
-To convert a String to a Char, use `"a".[0]`. To convert a Char to a String, use `String.make(1, 'a')`.
-
-## Regular Expression
-
-ReScript regular expressions compile cleanly to their JavaScript counterpart:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let r = [%re "/b/g"];
-```
-```ml
-let r = [%re "/b/g"]
-```
-```js
-var r = /b/g;
-```
-
-</CodeTab>
-
-A regular expression like the above has the type `Js.Re.t`. The [Js.Re](api/js/re) module contains the regular expression helpers you have seen in JS.
-
-## Boolean
-
-A ReScript boolean has the type `bool` and can be either `true` or `false`. Common operations:
-
-- `&&`: logical and.
-- `||`: logical or.
-- `!`: logical not.
-- `<=`, `>=`, `<`, `>`
-- `==`: structural equal, compares data structures deeply: `(1, 2) == (1, 2)` is `true`. Convenient, but use with caution.
-- `===`: referential equal, compares shallowly. `(1, 2) === (1, 2)` is `false`. `let myTuple = (1, 2); myTuple === myTuple` is `true`.
-- `!=`: structural unequal.
-- `!==`: referential unequal.
-
-ReScript's `true/false` compiles into a JavaScript `true/false`.
-
-## Integers
-
-32-bits, truncated when necessary. We provide the usual operations on them: `+`, `-`, `*`, `/`, etc. See [Js.Int](api/js/int) for helper functions.
-
-**Careful when you bind to JavaScript numbers**! Long ones might be truncated. Bind JS number (especially Dates) as **float** instead.
-
-## Floats
-
-Float requires other operators: `+.`, `-.`, `*.`, `/.`, etc. Like `0.5 +. 0.6`. See [Js.Float](api/js/float) for helper functions.
-
-## Unit
-
-The `unit` type has a single value, `()`. It compiles to JavaScrit's `undefined`. It's a dummy type used as a placeholder in various places. You won't need it until you see it.
diff --git a/pages/docs/manual/v8.0.0/project-structure.mdx b/pages/docs/manual/v8.0.0/project-structure.mdx
deleted file mode 100644
index 93e77f0f0..000000000
--- a/pages/docs/manual/v8.0.0/project-structure.mdx
+++ /dev/null
@@ -1,57 +0,0 @@
----
-title: "Project Structure"
-description: "Notes on project structure and other rough ReScript guidelines"
-canonical: "/docs/manual/latest/project-structure"
----
-
-# Project Structure
-
-These are the existing, non-codified community practices that are currently propagated through informal agreement. We might remove some of them at one point, and enforce some others. Right now, they're just recommendations for ease of newcomers.
-
-## File Casing
-
-Capitalized file names (aka first letter upper-cased).
-
-**Justification**: Module names can only be capitalized. Newcomers often ask how a file maps to a module, and why `draw.res` maps to the module `Draw`, and sometimes try to refer to a module through uncapitalized identifiers. Using `Draw.res` makes this mapping more straightforward. It also helps certain file names that'd be awkward in uncapitalized form: `uRI.res`.
-
-## Ignore `.merlin` File
-
-This is generated by the build system and you should not have to manually edit it. Don't check it into the repo.
-
-**Justification**: `.merlin` is for editor tooling. The file contains absolute paths, which are also not cross-platform (e.g. Windows paths are different).
-
-## Folders
-
-Try not to have too many nested folders. Keep your project flat, and have fewer files (reminder: you can use nested modules).
-
-**Justification**: The file system is a _tree_, but your code's dependencies are a _graph_. Because of that, any file & folder organization is usually imperfect. While it's still valuable to group related files together in a folder, the time wasted debating & getting decision paralysis over these far outweight their benefits. We'll always recommend you to Get Work Done instead of debating about these issues.
-
-## Third-party Dependencies
-
-Keep them to a minimum.
-
-**Justification**: A compiled, statically typed language cannot model its dependencies easily by muddling along like in a dynamic language, especially when we're still piggy-backing on NPM/Yarn (to reduce learning overhead in the medium-term). Keeping dependencies simple & lean helps reduce possibility of conflicts (e.g. two diamond dependencies, or clashing interfaces).
-
-## Documentation
-
-Have them. Spend more effort making them great (examples, pitfalls) and professional rather than _just_ fancy-looking. Do use examples, and avoid using names such as `foo` and `bar`. There's always more concrete names (it's an example, no need to be abstract/generalized just yet. The API docs will do this plentily). For blog posts, don't repeat the docs themselves, describe the _transition_ from old to new, and why (e.g. "it was a component, now it's a function, because ...").
-
-**Justification**: It's hard for newcomers to distinguish between a simple/decent library and one that's fancy-looking. For the sake of the community, don't try too hard to one-up each other's libraries. Do spread the words, but use your judgement too.
-
-## PPX & Other Meta-tools
-
-Keep them to a minimum. PPX, unless used in renown cases (printer, accessors and serializer/deserializer generation), can cause big learning churn for newcomers; on top of the syntax, semantics, types, build tool & FFI that they already have to learn, learning per-library custom transformations of the code is an extra step. More invasive macros makes the code itself less semantically meaningful too, since the essence would be hiding somewhere else.
-
-## Paradigm
-
-Don't abuse overly fancy features. Do leave some breathing room for future APIs but don't over-architect things.
-
-**Justification**: Simple code helps newcomers understand and potentially contribute to your code. Contributing is the best way for them to learn. The extra help you receive might also surpass the gain of using a slightly more clever language trick. But do try new language tricks in some of more casual projects! You might discover new ways of architecting code.
-
-## Publishing
-
-If it's a wrapper for a JS library, don't publish the JS artifacts. If it's a legit library, publish the artifacts in lib/js if you think JS consumers might use it. This is especially the case when you gradually convert a JS lib to ReScript while not breaking existing JS consumers.
-
-Do put the keywords `"rescript"` in your package.json `keywords` field. This allows us to find the library much more easily for future purposes.
-
-**Justification**: Be nice to JS consumers of your library. They're your future ReScripters.
diff --git a/pages/docs/manual/v8.0.0/promise.mdx b/pages/docs/manual/v8.0.0/promise.mdx
deleted file mode 100644
index 46adf62d7..000000000
--- a/pages/docs/manual/v8.0.0/promise.mdx
+++ /dev/null
@@ -1,102 +0,0 @@
----
-title: "Promise"
-description: "JS Promise handling in ReScript"
-canonical: "/docs/manual/latest/promise"
----
-
-# Promise
-
-ReScript has built-in support for [JavaScript promises](api/js/promise). The 3 functions you generally need are:
-
-- `Js.Promise.resolve: 'a => Js.Promise.t('a)`
-- `Js.Promise.then_: ('a => Js.Promise.t('b), Js.Promise.t('a)) => Js.Promise.t('b)`
-- `Js.Promise.catch: (Js.Promise.error => Js.Promise.t('a), Js.Promise.t('a)) => Js.Promise.t('a)`
-
-Additionally, here's the type signature for creating a promise on the ReScript side:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```rei
-Js.Promise.make: (
-  (
-    ~resolve: (. 'a) => unit,
-    ~reject: (. exn) => unit
-  ) => unit
-) => Js.Promise.t('a);
-```
-```mli
-Js.Promise.make: (
-  resolve:(('a -> unit) [@bs]) ->
-  reject:((exn -> unit) [@bs]) ->
-  unit
-) -> 'a Js.Promise.t
-```
-
-</CodeTab>
-
-This type signature means that `make` takes a callback that takes 2 named arguments, `resolve` and `reject`. Both arguments are themselves [uncurried callbacks](
-function.md#uncurried-function) (with a dot). `make` returns the created promise.
-
-## Usage
-
-Using the [pipe operator](pipe.md):
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let myPromise = Js.Promise.make((~resolve, ~reject) => resolve(. 2));
-
-myPromise
-|> Js.Promise.then_(value => {
-     Js.log(value);
-     Js.Promise.resolve(value + 2);
-   })
-|> Js.Promise.then_(value => {
-     Js.log(value);
-     Js.Promise.resolve(value + 3);
-   })
-|> Js.Promise.catch(err => {
-     Js.log2("Failure!!", err);
-     Js.Promise.resolve(-2);
-   });
-```
-```ml
-let myPromise = Js.Promise.make (fun ~resolve ~reject -> ((resolve 2) [@bs]))
-
-let () = myPromise
-|> Js.Promise.then_(fun value ->
-     Js.log value;
-     Js.Promise.resolve (value + 2)
-   )
-|> Js.Promise.then_(fun value ->
-     Js.log value;
-     Js.Promise.resolve (value + 3)
-   )
-|> Js.Promise.catch(fun err ->
-     Js.log2 "Failure!!", err;
-     Js.Promise.resolve -2
-   )
-```
-```js
-var myPromise = new Promise(function (resolve, reject) {
-  return resolve(2);
-});
-
-myPromise
-  .then(function (value) {
-    console.log(value);
-    return Promise.resolve((value + 2) | 0);
-  })
-  .then(function (value) {
-    console.log(value);
-    return Promise.resolve((value + 3) | 0);
-  })
-  .catch(function (err) {
-    console.log("Failure!!", err);
-    return Promise.resolve(-2);
-  });
-```
-
-</CodeTab>
-
-**Note**: we might offer a dedicated syntax for JS promises (async/await) in the future. Stay tuned!
diff --git a/pages/docs/manual/v8.0.0/record.mdx b/pages/docs/manual/v8.0.0/record.mdx
deleted file mode 100644
index d860476de..000000000
--- a/pages/docs/manual/v8.0.0/record.mdx
+++ /dev/null
@@ -1,246 +0,0 @@
----
-title: "Record"
-description: "Record types in ReScript"
-canonical: "/docs/manual/latest/record"
----
-
-# Record
-
-Records are like JavaScript objects but:
-
-- are immutable by default
-- have fixed fields (not extensible)
-
-## Type Declaration
-
-A record needs a mandatory type declaration:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type person = {
-  age: int,
-  name: string
-};
-```
-```ml
-type person = {
-  age: int;
-  name: string;
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Creation
-
-To create a `person` record (declared above):
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let me = {
-  age: 5,
-  name: "Big ReScript"
-};
-```
-```ml
-let me = {
-  age = 5;
-  name = "Big ReScript";
-}
-```
-```js
-var me = {
-  age: 5,
-  name: "Big ReScript"
-};
-```
-
-</CodeTab>
-
-When you create a new record value, ReScript tries to find a record type declaration that conforms to the shape of the value. So the `me` value here is inferred as of type `person`.
-
-The type is found by looking above the `me` value. **Note**: if the type instead resides in another file or module, you need to explicitly indicate which file or module it is:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-// School.re
-type person = {age: int, name: string};
-```
-```ml
-(* School.ml *)
-type person = {age: int; name: string}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-// Example.re
-
-let me: School.person = {age: 20, name: "Big ReScript"};
-/* or */
-let me2 = {School.age: 20, name: "Big ReScript"};
-```
-```ml
-(* Example.re *)
-
-let me: School.person = {age = 20; name = "Big ReScript"}
-(* or *)
-let me2 = {School.age = 20; name = "Big ReScript"}
-```
-```js
-var me = {
-  age: 20,
-  name: "Big ReScript"
-};
-var me2 = {
-  age: 20,
-  name: "Big ReScript"
-};
-```
-
-</CodeTab>
-
-Either of the above 3 says "this record's definition is found in the School file". The first one, the regular type annotation, is preferred.
-
-## Access
-
-Use the familiar dot notation:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let name = me.name;
-```
-```ml
-let name = me.name
-```
-```js
-var name = "Big ReScript";
-```
-
-</CodeTab>
-
-## Immutable Update
-
-New records can be created from old records with the `...` spread operator. The original record isn't mutated.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let meNextYear = {...me, age: me.age + 1};
-```
-```ml
-let meNextYear = {me with age = me.age + 1}
-```
-```js
-var meNextYear = {
-  age: 21,
-  name: "Big ReScript"
-};
-```
-
-</CodeTab>
-
-**Note**: spread cannot add new fields to the record value, as a record's shape is fixed by its type.
-
-## Mutable Update
-
-Record fields can optionally be mutable. This allows you to efficiently update those fields in-place with the `=` operator.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type person = {
-  name: string,
-  mutable age: int
-};
-
-let baby = {name: "Baby ReScript", age: 5};
-baby.age = baby.age + 1; // `baby.age` is now 6. Happy birthday!
-```
-```ml
-type person = {
-  name: string;
-  mutable age: int;
-}
-
-let baby = {name = "Baby ReScript"; age = 5}
-let () = baby.age <- baby.age + 1 (* `baby.age` is now 6. Happy birthday! *)
-```
-```js
-var baby = {
-  name: "Baby ReScript",
-  age: 5
-};
-
-baby.age = baby.age + 1 | 0;
-```
-
-</CodeTab>
-
-## Tips & Tricks
-
-**Record Types Are Found By Field Name**. With records, you **cannot** say "I'd like this function to take any record type, as long as they have the field `age`". The following **won't work as intended**:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type person = {age: int, name: string};
-type monster = {age: int, hasTentacles: bool};
-
-let getAge = (entity) => entity.age;
-```
-```ml
-type person = {age: int; name: string}
-type monster = {age: int; hasTentacles: bool}
-
-let getAge entity = entity.age
-```
-```js
-function getAge(entity) {
-  return entity.age;
-}
-```
-
-</CodeTab>
-
-Instead, `getAge` will infer that the parameter `entity` must be of type `monster`, the closest record type with the field `age`. The following code's last line fails:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```re
-let kraken = {age: 9999, hasTentacles: true};
-let me = {age: 5, name: "Baby ReScript"};
-
-getAge(kraken);
-getAge(me); // type error!
-```
-```ml
-let kraken = {age = 9999; hasTentacles = true}
-let me = {age = 5; name = "Baby ReScript"}
-
-let () = getAge kraken
-let () = getAge me (* type error! *)
-```
-
-</CodeTab>
-
-The type system will complain that `me` is a `person`, and that `getAge` only works on `monster`. If you need such capability, use ReScript objects, described [here](object.md).
-
-## Design Decisions
-
-After reading the constraints in the previous sections, and if you're coming from a dynamic language background, you might be wondering why one would bother with record in the first place instead of straight using object, since the former needs explicit typing and doesn't allow different records with the same field name to be passed to the same function, etc.
-
-1. The truth is that most of the times in your app, your data's shape is actually fixed, and if it's not, it can potentially be better represented as a combination of variant (introduced next) + record instead.
-2. Since a record type is resolved through finding that single explicit type declaration (we call this "nominal typing"), the type error messages end up better than the counterpart ("structural typing", like for tuples). This makes refactoring easier; changing a record type's fields naturally allows the compiler to know that it's still the same record, just misused in some places. Otherwise, under structural typing, it might get hard to tell whether the definition site or the usage site is wrong.
diff --git a/pages/docs/manual/v8.0.0/reserved-keywords.mdx b/pages/docs/manual/v8.0.0/reserved-keywords.mdx
deleted file mode 100644
index e90946ff2..000000000
--- a/pages/docs/manual/v8.0.0/reserved-keywords.mdx
+++ /dev/null
@@ -1,76 +0,0 @@
----
-title: "Reserved Keyword"
-description: "All reserved keywords in ReScript"
-canonical: "/docs/manual/latest/reserved-keywords"
----
-
-# Reserved Keywords
-
-> **Note**: Some of these words are reserved purely for backward compatibility.
-
-- `and`
-- `as`
-- `assert`
-
-- `begin`
-
-- `class`
-- `constraint`
-
-- `do`
-- `done`
-- `downto` (also see `to`)
-
-- `else` (used with `if`)
-- `end`
-- `esfun`
-- `exception`
-- `external`
-
-- `false` (a `bool`, along with `true`)
-- `for`
-- `fun`
-- `function`
-- `functor`
-
-- `if`
-- `in`
-- `include`
-- `inherit`
-- `initializer`
-
-- `lazy`
-- `let`
-
-- `module`
-- `mutable`
-
-- `new`
-- `nonrec`
-
-- `object`
-- `of`
-- `open`
-- `or`
-
-- `pri`
-- `pub`
-
-- `rec`
-
-- `sig`
-- `struct`
-- `switch`
-
-- `then`
-- `to`
-- `true`
-- `try`
-- `type`
-
-- `val`
-- `virtual`
-
-- `when`
-- `while`
-- `with`
diff --git a/pages/docs/manual/v8.0.0/shared-data-types.mdx b/pages/docs/manual/v8.0.0/shared-data-types.mdx
deleted file mode 100644
index 851af21db..000000000
--- a/pages/docs/manual/v8.0.0/shared-data-types.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: "Shared Data Types"
-description: "Data types that share runtime presentation between JS and ReScript"
-canonical: "/docs/manual/latest/shared-data-types"
----
-
-# Shared Data Types
-
-ReScript's built-in values of type `string`, `float`, `array` and a few others have a rather interesting property: they compile to the exact same value in JavaScript!
-
-This means that if you're passing e.g. a ReScript string to the JavaScript side, the JS side can directly use it as a native JS string. It also means that you can import a JS string and pretend it's a native ReScript string.
-
-Unlike most compiled-to-js languages, in ReScript, **you don't need to write data converters back and forth for most of our values**!
-
-**Shared, bidirectionally usable types**:
-- String. Backtick strings like `` `hello $(personName)` `` (in old ML syntax: `{j|hello $(personName)|j}`) support interpolation. Normal `"hello"` strings don't.
-- Float. ReScript floats are JS numbers, vice-versa.
-- Array. In addition to the [JS Array API](api/js/array), we provide our own [Belt.Array](api/belt/array#set) API too.
-- Tuple. Compiles to a JS array. You can treat a fixed-sized, heterogenous JS array as ReScript tuple too.
-- Boolean.
-- Record. Record compiles to JS object. Therefore you can also treat JS objects as records. If they're too dynamic, consider modeling them on the ReScript side as a hashmap/dictionary [`Js.Dict`](api/js/dict) or a ReScript object.
-- Object. ReScript objects are JavaScript objects, vice-versa.
-- Function. They compile to clean JS functions.
-- Module. ReScript files are considered top-level modules, and are compiled to JS files 1 to 1. Nested modules are compiled to JavaScript objects.
-- Unit. The `unit` type, which has a single value `()`, compiles to `undefined` too. Likewise, you can treat an incoming JS `undefined` as `()`.
-
-<!-- TODO: talk about poly variant -->
-
-**Types that are slightly different than JS, but that you can still use from JS**:
-- Int. **Ints are 32-bits**! Be careful, you can potentially treat them as JS numbers and vice-versa, but if the number's large, then you better treat JS numbers as floats. For example, we bind to [`Js.Date`](api/js/date) using `float`s.
-- Option. The `option` type's `None` value compiles into JS `undefined`. The `Some` value, e.g. `Some(5)`, compiles to `5`. Likewise, you can treat an incoming JS `undefined` as `None`. **JS `null` isn't handled here**. If your JS value can be `null`, use [Js.Nullable](api/js/nullable) helpers.
-- Exception.
-
-**Non-shared types (aka internal types)**:
-
-- Variant. They don't exist in JS.
-- List, which is just a regular variant.
-- Character.
-- Int64.
-- Lazy values.
-- Everything else.
-
-The non-shared types need your manual conversions if you want to export them for JS consumption. For a seamless JS / TypeScript / Flow integration experience, you might want to use [genType](https://github.com/cristianoc/gentype) instead of doing conversions by hand.
diff --git a/pages/docs/manual/v8.0.0/try.mdx b/pages/docs/manual/v8.0.0/try.mdx
deleted file mode 100644
index 36dc995de..000000000
--- a/pages/docs/manual/v8.0.0/try.mdx
+++ /dev/null
@@ -1,61 +0,0 @@
----
-title: "Try"
-description: "Try ReScript via CLI"
-canonical: "/docs/manual/latest/try"
----
-
-# Try via CLI
-
-You can compile a file directly via `bsc MyFile.re` (or `bsc MyFile.ml`):
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```re
-// MyFile.re
-let rec fib = n => {
-  switch (n) {
-  | 0 | 1 => n
-  | n => fib(n - 1) + fib(n - 2)
-  }
-};
-Js.log(fib(0));
-```
-```ml
-// MyFile.ml
-let rec fib n =
-  match n with
-  | 0 | 1 -> n
-  | n -> (fib (n - 1)) + (fib (n - 2))
-let _ = Js.log (fib 0)
-```
-
-</CodeTab>
-
-```sh
-❯ bsc MyFile.re
-// Generated by BUCKLESCRIPT, PLEASE EDIT WITH CARE
-'use strict';
-function fib(n) {
-  if (n === 0 || n === 1) {
-    return 1;
-  } else {
-    return fib(n - 1 | 0) + fib(n - 2 | 0) | 0;
-  }
-}
-console.log(fib(0));
-exports.fib = fib;
-/*  Not a pure module */
-```
-
-You can also get the inferred signature directly via `bsc -i MyFile.re`
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```rei
-let fib: int => int;
-```
-```mli
-val fib: int => int
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v8.0.0/tuple.mdx b/pages/docs/manual/v8.0.0/tuple.mdx
deleted file mode 100644
index 4102f4de9..000000000
--- a/pages/docs/manual/v8.0.0/tuple.mdx
+++ /dev/null
@@ -1,128 +0,0 @@
----
-title: "Tuple"
-description: "Tuple types and values in ReScript"
-canonical: "/docs/manual/latest/tuple"
----
-
-# Tuple
-
-Tuples are a ReScript-specific data structure that don't exist in JavaScript. They are:
-
-- immutable
-- ordered
-- fix-sized at creation time
-- heterogeneous (can contain different types of values)
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let ageAndName = (24, "Lil' ReScript");
-let my3dCoordinates = (20.0, 30.5, 100.0);
-```
-```ml
-let ageAndName = (24, "Lil' ReScript")
-let my3dCoordinates = (20.0, 30.5, 100.0)
-```
-```js
-var ageAndName = [24, "Lil' ReScript"];
-var my3dCoordinates = [20.0, 30.5, 100.0];
-```
-
-</CodeTab>
-
-Tuples' types can be used in type annotations as well. Tuple types visually resemble tuples values.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let ageAndName: (int, string) = (24, "Lil' ReScript");
-// a tuple type alias
-type coord3d = (float, float, float);
-let my3dCoordinates: coord3d = (20.0, 30.5, 100.0);
-```
-```ml
-let ageAndName: (int * string) = (24, "Lil' ReScript")
-(* a tuple type alias *)
-type coord3d = (float * float * float)
-let my3dCoordinates: coord3d = (20.0, 30.5, 100.0)
-```
-```js
-var ageAndName = [24, "Lil' ReScript"];
-var my3dCoordinates = [20.0, 30.5, 100.0];
-```
-</CodeTab>
-
-**Note**: there's no tuple of size 1. You'd just use the value itself.
-
-## Usage
-
-To get a specific member of a tuple, destructure it:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let (_, y, _) = my3dCoordinates; // now you've retrieved y
-```
-```ml
-let (_, y, _) = my3dCoordinates; (* now you've retrieved y *)
-```
-```js
-var y = 30.5;
-```
-
-</CodeTab>
-
-The `_` means you're ignoring the indicated members of the tuple.
-
-Tuples aren't meant to be updated mutatively. You'd create new ones by destructuring the old ones:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let coordinates1 = (10, 20, 30);
-let (c1x, _, _) = coordinates1;
-let coordinates2 = (c1x + 50, 20, 30);
-```
-```ml
-let coordinates1 = (10, 20, 30)
-let (c1x, _, _) = coordinates1
-let coordinates2 = (c1x + 50, 20, 30)
-```
-```js
-var coordinates1 = [10, 20, 30];
-var c1x = 10;
-var coordinates2 = [60, 20, 30];
-```
-
-</CodeTab>
-
-## Tips & Tricks
-
-You'd use tuples in handy situations that pass around multiple values without too much ceremony. For example, to return many values:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let getCenterCoordinates = () => {
-  let x = doSomeOperationsHere();
-  let y = doSomeMoreOperationsHere();
-  (x, y)
-};
-```
-```ml
-let getCenterCoordinates () =
-  let x = doSomeOperationsHere () in
-  let y = doSomeMoreOperationsHere () in
-  (x, y)
-```
-```js
-function getCenterCoordinates(param) {
-  var x = doSomeOperationsHere(undefined);
-  var y = doSomeMoreOperationsHere(undefined);
-  return [x, y];
-}
-```
-
-</CodeTab>
-
-Try to keep the usage of tuple **local**. For data structures that are long-living and passed around often, prefer a **record**, which has named fields.
diff --git a/pages/docs/manual/v8.0.0/type.mdx b/pages/docs/manual/v8.0.0/type.mdx
deleted file mode 100644
index c51d0a4ca..000000000
--- a/pages/docs/manual/v8.0.0/type.mdx
+++ /dev/null
@@ -1,353 +0,0 @@
----
-title: "Type"
-description: "Types and type definitions in ReScript"
-canonical: "/docs/manual/latest/type"
----
-
-# Type
-
-Types are the highlight of ReScript! They are:
-- **Strong**. A type can't change into another type. In JavaScript, your variable's type might change when the code runs (aka at runtime). E.g. a `number` variable might change into a `string` sometimes. This is an anti-feature; it makes the code much harder to understand when reading or debugging.
-- **Static**. ReScript types are erased after compilation and don't exist at runtime. Never worry about your types dragging down performance. You don't need type info during runtime; we report all the information (especially all the type errors) during compile time. Catch the bugs earlier!
-- **Sound**. This is our biggest differentiator versus many other typed languages that compile to JavaScript. Our type system is guaranteed to **never** be wrong. Most type systems make a guess at the type of a value and show you a type in your editor that's sometime incorrect. We don't do that. We believe that a type system that is sometime incorrect can end up being dangerous due to expectation mismatches.
-- **Fast**. Many developers underestimate how much of their project's build time goes into type checking. Our type checker is one of the fastest around.
-- **Inferred**. You don't have to write down the types! ReScript can deduce them from their values. Yes, it might seem magical that we can deduce all of your program's types, without incorrectness, without your manual annotation, and do so quickly. Welcome to ReScript =).
-
-The following sections explore more of our type system.
-
-## Inference
-
-This let-binding doesn't contain any written type:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let score = 10;
-let add = (a, b) => a + b;
-```
-```ml
-let score = 10
-let add a b = a + b
-```
-```js
-var score = 10;
-function add(a, b) {
-  return a + b | 0;
-}
-```
-
-</CodeTab>
-
-ReScript knows that `score` is an `int`, judging by the value `10`. This is called **inference**. Likewise, it also knows that the `add` function takes 2 `int`s and returns an `int`, judging from the `+` operator, which works on ints.
-
-## Type Annotation
-
-But you can also optionally write down the type, aka annotate your value:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let score: int = 10;
-```
-```ml
-let score: int = 10
-```
-```js
-var score = 10;
-```
-
-</CodeTab>
-
-If the type annotation for `score` doesn't correspond to our inferred type for it, we'll show you an error during compilation time. We **won't** silently assume your type annotation is correct, unlike many other languages.
-
-You can also wrap any expression in parentheses and annotate it:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let myInt = 5;
-let myInt: int = 5;
-let myInt = (5: int) + (4: int);
-let add = (x: int, y: int) : int => x + y;
-let drawCircle = (~radius as r: int): circleType => /* code here */;
-```
-```ml
-let myInt = 5
-let myInt: int = 5
-let myInt = (5 : int) + (4 : int)
-let add (x : int) (y : int) = (x + y : int)
-let drawCircle ~radius:(r : int) : circleType = (* code here *)
-```
-```js
-var myInt = 9;
-function add(x, y) {
-  return x + y | 0;
-}
-function drawCircle(r) {
-  /* code here */
-}
-```
-
-</CodeTab>
-
-Note: in the last line, `(~radius as r: int)` is a labeled argument. More on this in the [function](function.md) page.
-
-## Type Alias
-
-You can refer to a type by a different name. They'll be equivalent:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type scoreType = int;
-let x: scoreType = 10;
-```
-```ml
-type scoreType = int
-let x: scoreType = 10
-```
-```js
-var x = 10;
-```
-
-</CodeTab>
-
-## Type Parameter (Aka Generic)
-
-Types can accept parameters, akin to generics in other languages. The parameters' names **need** to start with `'`.
-
-The use-case of a parameterized type is to kill duplications. Before:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-// this is a tuple of 3 items, explained next
-type intCoordinates = (int, int, int);
-type floatCoordinates = (float, float, float);
-
-let a: intCoordinates = (10, 20, 20);
-let b: floatCoordinates = (10.5, 20.5, 20.5);
-```
-```ml
-(* this is a tuple of 3 items, explained next *)
-type intCoordinates = (int, int, int)
-type floatCoordinates = (float, float, float)
-
-let a: intCoordinates = (10, 20, 20)
-let b: floatCoordinates = (10.5, 20.5, 20.5)
-```
-```js
-var a = [10, 20, 20];
-var b = [10.5, 20.5, 20.5];
-```
-
-</CodeTab>
-
-After:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type coordinates('a) = ('a, 'a, 'a);
-
-let a: coordinates(int) = (10, 20, 20);
-let b: coordinates(float) = (10.5, 20.5, 20.5);
-```
-```ml
-type 'a coordinates = ('a * 'a * 'a)
-
-let a: int coordinates = (10, 20, 20)
-let b: float coordinates = (10.5, 20.5, 20.5)
-```
-```js
-var a = [10, 20, 20];
-var b = [10.5, 20.5, 20.5];
-```
-
-</CodeTab>
-
-Note that the above codes are just contrived examples for illustration purposes. Since the types are inferred, you could have just written:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let buddy = (10, 20, 20);
-```
-```ml
-let buddy = (10, 20, 20)
-```
-```js
-var buddy = [10, 20, 20];
-```
-
-</CodeTab>
-
-The type system infers that it's a `(int, int, int)`. Nothing else needed to be written down.
-
-Type arguments appear in many places. Our `array('a)` type is such a type that requires a type parameter
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-// inferred as `array(string)`
-let greetings = [|"hello", "world", "how are you"|];
-```
-```ml
-(* inferred as `string array` *)
-let greetings = [|"hello"; "world"; "how are you"|]
-```
-```js
-var greetings = ["hello", "world", "how are you"];
-```
-
-</CodeTab>
-
-If types didn't accept parameters, the standard library would need to define the types `arrayOfString`, `arrayOfInt`, `arrayOfTuplesOfInt`, etc. That'd be tedious.
-
-Types can receive many arguments, and be composable.
-
-<!-- TODO: too early for this example -->
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type result('a, 'b) =
-  | Ok('a)
-  | Error('b);
-
-type myPayload = {data: string};
-
-type myPayloadResults('errorType) = array(result(myPayload, 'errorType));
-
-let payloadResults: myPayloadResults(string) = [|
-  Ok({data: "hi"}),
-  Ok({data: "bye"}),
-  Error("Something wrong happened!")
-|];
-```
-```ml
-type ('a, 'b) result =
-  | Ok of 'a
-  | Error of 'b
-
-type myPayload = {
-  data: string;
-}
-
-type 'errorType myPayloadResults = (myPayload, 'errorType) result array
-
-let payloadResults: string myPayloadResults = [|
-  Ok({data = "hi"});
-  Ok({data = "bye"});
-  Error("Something wrong happaned!");
-|]
-```
-```js
-var payloadResults = [
-  {
-    TAG: /* Ok */0,
-    _0: {data: "hi"}
-  },
-  {
-    TAG: /* Ok */0,
-    _0: {data: "bye"}
-  },
-  {
-    TAG: /* Error */1,
-    _0: "Something wrong happened!"
-  }
-];
-```
-
-</CodeTab>
-
-## Recursive Types
-
-Just like a functions, a type can reference itself within itself:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type person = {
-  name: string,
-  friends: array(person)
-}
-```
-```ml
-type person = {
-  name: string;
-  friends: person array;
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-To opt out of resursive type, use `type nonrec person = ...`.
-
-## Mutually Recursive Types
-
-Types can also be _mutually_ recursive through `and`:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type student = {taughtBy: teacher}
-and teacher = {students: array(student)};
-```
-```ml
-type student = {taughtBy: teacher}
-and teacher = {students: student array}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Type Escape Hatch
-
-ReScript's type system is robust and does not allow dangerous, unsafe stuff like implicit type casting, randomly guessing a value's type, etc. However, out of pragmatism, we expose a single escape hatch for you to "lie" to the type system:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-external myShadyConversion: myType1 => myType2 = "%identity";
-```
-```ml
-external myShadyConversion: myType1 -> myType2 = "%identity"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-This declaration converts a `myType1` of your choice to `myType2` of your choice. You can use it like so:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-external convertToFloat : int => float = "%identity";
-let age = 10;
-let gpa = 2.1 +. convertToFloat(age);
-```
-```ml
-external convertToFloat : int -> float = "%identity"
-let age = 10
-let gpa = 2.1 +. (convertToFloat age)
-```
-```js
-var age = 10;
-var gpa = 2.1 + 10;
-```
-
-</CodeTab>
-
-Obviously, do **not** abuse this feature. Use it tastefully when you're working with existing, overly dynamic JS code, for example.
-
-More on externals [here](external.md).
-
-**Note**: this particular `external` is the only one that isn't preceded by a `@bs` annotation.
diff --git a/pages/docs/manual/v8.0.0/use-illegal-identifier-names.mdx b/pages/docs/manual/v8.0.0/use-illegal-identifier-names.mdx
deleted file mode 100644
index e9af30ebb..000000000
--- a/pages/docs/manual/v8.0.0/use-illegal-identifier-names.mdx
+++ /dev/null
@@ -1,151 +0,0 @@
----
-title: "Use Illegal Identifier Names"
-description: "Handling (JS) naming collisions in ReScript"
-canonical: "/docs/manual/latest/use-illegal-identifier-names"
----
-
-# Use Illegal Identifier Names
-
-<Warn>
-
-This page is solely dedicated to Reason v3.6 related naming collisions and also highlights some name mangling rules the ReScript compiler implemented just for Reason purposes.
-
-</Warn>
-
-JavaScript has different naming conventions and has only very few limitations when it comes to naming variables, classes, functions, JS object attributes etc.
-
-Reason on the contrary has more restrictive naming rules which need to be considered whenever you define  a type, function, value, module, record attribute or similar. Here are a few typical naming restrictions which cause trouble with JS:
-- Every name needs to start with a lowercase letter (uppercase is reserved for module names)
-- For the same reason, names can't be all caps  (very common for JS constants: `const MY_CONSTANT = "my_constant"`)
-- It's not possible to use [reserved keywords](/docs/manual/latest/reserved-keywords) for names
-- Labeled arguments (for defining JSX attributes) can't be named after keywords and can't start with an uppercase letter
-- etc.
-
-Of course, when doing interop, we still want to be able to map to the JS equivalent (preferably without any runtime overhead). In this section we describe some common scenarios on how to gracefully handle naming collisions.
-
-## Using reserved keywords as JSX props
-
-Many React components have a prop named `type` in JavaScript:
-
-```js
-/* this won't work in Reason since `type` is a reserved keyword! */
-<Component type="title" />
-```
-
-If you're using a React component with a reserved keyword as a prop name, then simply prepend a underscore (so that it's a valid Reason name):
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)"]}>
-
-```re
-/* This works because `_type` is not a reserved keyword */
-<Component _type="title" />
-```
-```ml
-(* Doesn't exist in old ML syntax *)
-```
-
-</CodeTab>
-
-The Reason compiler will remove the leading underscore when outputting JavaScript (so the JavaScript will have `<Component type="POST" />`).
-
-The removal of the `_` is called "Name mangling". The ruleset for this behavior is discussed [further down below](#special-name-mangling-rules-for-js-object-attribute-names).
-
-## Accessing JavaScript object attributes that start with a capital letter
-
-Capital letters in Reason are used exclusively for module names, like `String` and `Belt`, and they cannot be used as record field names like in JavaScript.
-
-```js
-const payload = {
-  PostTitle: "Welcome to Reason",
-};
-
-/* this won't work in Reason since `PostTitle` is capitalized, so `paylod.PostTitle` would break */
-const title = payload.PostTitle;
-```
-
-In this case, when writing bindings to the JavaScript object, you can use the `[@bs.as "whatever-name-you-want-in-javascript"]` to tell the compiler exactly what the JavaScript attribute name should be in the compiled output:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type payload = {
-  [@bs.as "PostTitle"] postTitle: string
-};
-
-let payload = {
-  postTitle: "Welcome to Reason"
-};
-
-/* ReScript is happy since we're using the valid `postTitle` field name */
-let title = payload.postTitle;
-```
-```ml
-type payload = {
-  postTitle: string [@bs.as "PostTitle"]
-}
-
-let payload = {
-  postTitle = "Welcome to Reason"
-}
-
-(* ReScript is happy since we're using the valid `postTitle` field name *)
-let title = payload.postTitle
-```
-```js
-/* The correct capitalized field name is output in the JavaScript! */
-var title = payload.PostTitle;
-```
-
-</CodeTab>
-
-## Accessing reserved keywords as JavaScript object attribute names
-
-Just like accessing attributes that start with a capital letter, we can use `[@bs.as "the-reserved-keyword-that-javascript-wants"]`. It's customary to append an underscore (unlike the JSX case, where we *prepend* the underscore) to the reserved keyword name:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type payload = {
-  [@bs.as "type"] type_: string
-}
-
-let payload = {
-  type_: "Documentation"
-}
-
-/* ReScript is happy since we're using the valid `type_` field name */
-let payloadType = payload.type_;
-```
-```ml
-type payload = {
-  type_: string [@bs.as "type"]
-}
-
-let payload = {
-  type_ = "Documentation"
-}
-
-(* ReScript is happy since we're using the valid `type_` field name *)
-let payloadType = payload.type_
-```
-```js
-/* The reason compiler has correctly ouput `payload.type` even though *we* called the field `type_` */
-var payloadType = payload.type;
-```
-
-</CodeTab>
-
-## Special name mangling rules for JS object attribute names
-
-> **Note:** This is special behavior partly implemented in the Reason syntax, partly in the ReScript compiler. This section is mostly useful for understanding how JS object attributes and labeled arguments of ReasonReact components are compiled.
-
-> **Another Note:** A JS object type is a structurally typed entity with special compilation behavior, so they act differently than records or plain Reason objects. They are encoded as `Js.t({...})` types, more details about that feature can be found [here](http://localhost:3000/docs/reason-compiler/latest/object-2#actual-solution).
->
-> Labeled arguments used in `[@react.component]` functions (like `let make = (~name: string, ~age: int) => React.element`) are transformed into the `Js.t` representation (e.g. `let make = Js.t({."name": string, "age": int}) => React.element`), so they follow the same ruleset.
-
-When accessing a JavaScript object field in a structural way (e.g. `myJsObject##some`), the following rules apply:
-
-1. A single _leading_ underscore will be *dropped* from the output: `myJsObject##_type` => `myJsObject.type`
-1. Two (or more) _leading_ underscores will be *kept* in the output: `myJsObject##__type` => `myJsObject.__type`
-1. There is _no way_ to access e.g. `myJsObject##_type` structurally - use records and `[@bs.as "_type"]` instead
-1. The _final trailing_ double underscores (and anything following them) will be dropped from the output: `myJsObject##this_is_kept__this_is_omitted` => `myJsObject.this_is_kept`
diff --git a/pages/docs/manual/v8.0.0/variant.mdx b/pages/docs/manual/v8.0.0/variant.mdx
deleted file mode 100644
index 2905f1d94..000000000
--- a/pages/docs/manual/v8.0.0/variant.mdx
+++ /dev/null
@@ -1,342 +0,0 @@
----
-title: "Variant"
-description: "Variant data structures in ReScript"
-canonical: "/docs/manual/latest/variant"
----
-
-# Variant
-
-So far, most of ReScript's data structures might look familiar to you. This section introduces an extremely important, and perhaps unfamiliar, data structure: variant.
-
-Most data structures in most languages are about "this **and** that". A variant allows us to express "this **or** that".
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type myResponse =
-  | Yes
-  | No
-  | PrettyMuch;
-
-let areYouCrushingIt = Yes;
-```
-```ml
-type myResponse =
-  | Yes
-  | No
-  | PrettyMuch
-
-let areYouCrushingIt = Yes
-```
-```js
-var areYouCrushingIt = /* Yes */0;
-```
-
-</CodeTab>
-
-`myResponse` is a variant type with the cases `Yes`, `No` and `PrettyMuch`, which are called "variant constructors" (or "variant tag"). The `|` bar separates each constructor.
-
-**Note**: a variant's constructors need to be capitalized.
-
-## Variant Needs an Explicit Definition
-
-If the variant you're using is in a different file, bring it into scope like you'd do [for a record](record.md#record-needs-an-explicit-definition):
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-// Zoo.re
-type animal = Dog | Cat | Bird;
-```
-```ml
-(* Zoo.re *)
-type animal = Dog | Cat | Bird
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-// Example.re
-let pet: Zoo.animal = Dog; // preferred
-// or
-let pet2 = Zoo.Dog;
-```
-```ml
-(* Example.re *)
-let pet: Zoo.animal = Dog (* preferred *)
-(* or *)
-let pet2 = Zoo.Dog
-```
-```js
-var pet = /* Dog */0;
-var pet2 = /* Dog */0;
-```
-
-</CodeTab>
-
-## Constructor Arguments
-
-A variant's constructors can hold extra data separated by comma.
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type account =
-  | None
-  | Instagram(string)
-  | Facebook(string, int);
-```
-```ml
-type account =
-  | None
-  | Instagram of string
-  | Facebook of string * int
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Here, `Instagram` holds a `string`, and `Facebook` holds a `string` and an `int`. Usage:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-let myAccount = Facebook("Josh", 26);
-let friendAccount = Instagram("Jenny");
-```
-```ml
-let myAccount =
-  Facebook ("Josh", 26)
-let friendAccount =
-  Instagram "Jenny"
-```
-```js
-var myAccount = {
-  TAG: /* Facebook */1,
-  _0: "Josh",
-  _1: 26
-};
-var friendAccount = {
-  TAG: /* Instagram */0,
-  _0: "Jenny"
-};
-```
-
-</CodeTab>
-
-### Records in Variants
-
-You can use a record type in a variant:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type idType = {name: string, password: string};
-
-type user =
-  | Number(int)
-  | Id(idType);
-```
-```ml
-type idType = {name: string; password: string}
-
-type user =
-  | Number of int
-  | Id of idType
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-If the record type is used only in the variant definition, you may put it in line:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type user =
-  | Number(int)
-  | Id({name: string, password: string});
-```
-```ml
-type user =
-  | Number of int
-  | Id of {name: string; password: string}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-### Pattern Matching On Variant
-
-See the [Pattern Matching/Destructuring](pattern-matching-destructuring.md) section later.
-
-## Tips & Tricks
-
-**Be careful** not to confuse a constructor carrying 2 arguments with a constructor carrying a single tuple argument:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type account =
-  | Facebook(string, int); // 2 arguments
-type account2 =
-  | Instagram((string, int)); // 1 argument - happens to be a 2-tuple
-```
-```ml
-type account =
-  | Facebook of string * int (* 2 arguments *)
-type account2 =
-  | Instagram of (string * int) (* 1 argument - happens to be a 2-tuple *)
-```
-```js
-// Empty output
-```
-
-### Variants Must Have Constructors
-
-</CodeTab>
-
-If you come from an untyped language, you might be tempted to try `type myType = int | string`. This isn't possible in ReScript; you'd have to give each branch a constructor: `type myType = Int(int) | String(string)`. The former looks nice, but causes lots of trouble down the line.
-
-### Interop with JavaScript
-
-_This section assumes knowledge about our JavaScript interop. Skip this if you haven't felt the itch to use variants for wrapping JS functions yet_.
-
-Quite a few JS libraries use functions that can accept many types of arguments. In these cases, it's very tempting to model them as variants. For example, suppose there's a `myLibrary.draw` JS function that takes in either a `number` or a `string`. You might be tempted to bind it like so:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-// reserved for internal usage
-[@bs.module "myLibrary"] external draw: 'a => unit = "draw";
-
-type animal =
-  | MyFloat(float)
-  | MyString(string);
-
-let betterDraw = (animal) =>
-  switch (animal) {
-  | MyFloat(f) => draw(f)
-  | MyString(s) => draw(s)
-  };
-
-betterDraw(MyFloat(1.5));
-```
-```ml
-(* reserved for internal usage *)
-external draw: 'a => unit = "draw" [@@bs.module "myLibrary"]
-
-type animal =
-  | MyFloat of float
-  | MyString of string
-
-let betterDraw animal =
-  match animal with
-  | MyFloat f -> draw f
-  | MyString s -> draw s
-
-let () = betterDraw (MyFloat 1.5)
-```
-```js
-var MyLibrary = require("myLibrary");
-
-function betterDraw(animal) {
-  MyLibrary.draw(animal._0);
-}
-
-betterDraw({
-  TAG: /* MyFloat */0,
-  _0: 1.5
-});
-```
-
-</CodeTab>
-
-You could definitely do that, but there are better ways! For example, define two `external`s that both compile to the same JS call:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-[@bs.module "myLibrary"] external drawFloat: float => unit = "draw";
-[@bs.module "myLibrary"] external drawString: string => unit = "draw";
-```
-```ml
-external drawFloat: float -> unit = "draw" [@@bs.module "myLibrary"]
-external drawString: string -> unit = "draw" [@@bs.module "myLibrary"]
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-ReScript also provides [a few other ways](bind-to-js-function.md#modeling-polymorphic-function) to do this.
-
-### Variant Types Are Found By Field Name
-
-Please refer to this [record section](record#record-types-are-found-by-field-name). Variants are the same: a function can't accept an arbitrary constructor shared by two different variants. Again, such feature exists; it's called a polymorphic variant. We'll talk about this in the future =).
-
-## Design Decisions
-
-Variants, in their many forms (polymorphic variant, open variant, GADT, etc.), are likely _the_ feature of a type system such as ReScript's. The aforementioned `option` variant, for example, obliterates the need for nullable types, a major source of bugs in other languages. Philosophically speaking, a problem is composed of many possible branches/conditions. Mishandling these conditions is the majority of what we call bugs. **A type system doesn't magically eliminate bugs; it points out the unhandled conditions and asks you to cover them**\*. The ability to model "this or that" correctly is crucial.
-
-For example, some folks wonder how the type system can safely eliminate badly formatted JSON data from propagating into their program. They don't, not by themselves! But if the parser returns the `option` type `None | Some(actualData)`, then you'd have to handle the `None` case explicitly in later call sites. That's all there is.
-
-Performance-wise, a variant can potentially tremendously speed up your program's logic. Here's a piece of JavaScript:
-
-```js
-let data = 'dog'
-if (data === 'dog') {
-  ...
-} else if (data === 'cat') {
-  ...
-} else if (data === 'bird') {
-  ...
-}
-```
-
-There's a linear amount of branch checking here (`O(n)`). Compare this to using a ReScript variant:
-
-<CodeTab labels={["Reason (Old Syntax)", "ML (Older Syntax)", "JS Output"]}>
-
-```re
-type animal = Dog | Cat | Bird;
-let data = Dog
-switch (data) {
-| Dog => Js.log("Wof")
-| Cat => Js.log("Meow")
-| Bird => Js.log("Kashiiin")
-}
-```
-```ml
-type animal = Dog | Cat | Bird
-let data = Dog
-let () =
-  match data with
-  | Dog -> Js.log "Wof"
-  | Cat -> Js.log "Meow"
-  | Bird -> Js.log "Kashiiin"
-```
-```js
-console.log("Wof");
-
-var data = /* Dog */0;
-```
-
-</CodeTab>
-
-The compiler sees the variant, then
-
-1. conceptually turns them into `type animal = 0 | 1 | 2`
-2. compiles `switch` to a constant-time jump table (`O(1)`).
diff --git a/pages/docs/manual/v9.0.0/api.mdx b/pages/docs/manual/v9.0.0/api.mdx
deleted file mode 100644
index ce832115e..000000000
--- a/pages/docs/manual/v9.0.0/api.mdx
+++ /dev/null
@@ -1,15 +0,0 @@
-# Introduction
-
-ReScript ships 3 modules in its standard library.
-
-- [Js](api/js): bindings for all your familiar JavaScript APIs.
-- [Belt](api/belt): extra collections and helpers not available in JavaScript.
-- [Dom](api/dom): Dom related types and modules.
-
-Usage heuristics:
-
-- Default to using the `Js` module. Most of the APIs in it are runtime-free and compile down to clean, readable JavaScript, which is our priority.
-- For other APIs that aren't available in regular JavaScript (and thus don't exist in our `Js` bindings), use Belt. For example, prefer `Js.Array2` over `Belt.Array`.
-- The `Dom` module contains our standardized types used by various userland DOM bindings. Due to the complexity of DOM, we don't mind that you ignore this module and build your application-specific DOM bindings.
-
-**Note**: we do not recommend other userland standard library alternatives (unless it's DOM bindings). These cause confusion and split points for the community.
diff --git a/pages/docs/manual/v9.0.0/api/belt.mdx b/pages/docs/manual/v9.0.0/api/belt.mdx
deleted file mode 100644
index 1c5b8039a..000000000
--- a/pages/docs/manual/v9.0.0/api/belt.mdx
+++ /dev/null
@@ -1,179 +0,0 @@
-# Belt
-
-The ReScript standard library.
-
-Belt is currently mostly covering collection types. It has no string or date functions yet, although Belt.String is in the works. In the meantime, use [Js.String](js/string) for string functions and [Js.Date](js/date) for date functions.
-
-## Motivation
-
-Belt provides:
-
-- The **highest quality** immutable data structures in JavaScript.
-- Safety by default: A Belt function will never throw exceptions, unless it is
-  indicated explicitly in the function name (suffix "Exn").
-- Better performance and smaller code size running on the JS platform.
-- Ready for [Tree Shaking](https://webpack.js.org/guides/tree-shaking/).
-
-## Usage
-
-To use modules from Belt, either refer to them by their fully qualified name (`Belt.List`, `Belt.Array` etc.) or open the `Belt` module by putting
-
-```res
-open Belt
-```
-
-at the top of your source files. After opening Belt this way, `Array` will refer to `Belt.Array`, `List` will refer to `Belt.List` etc. in the subsequent code.
-
-If you want to open Belt globally for all files in your project instead, you can put
-
-```json
-  "bsc-flags": ["-open Belt"],
-```
-
-into your `bsconfig.json`.
-
-**Note**: this is the **only** `open` we encourage.
-
-Example usage:
-
-```res
-let someNumbers = [1, 1, 4, 2, 3, 6, 3, 4, 2]
-
-let greaterThan2UniqueAndSorted =
-  someNumbers
-  ->Belt.Array.keep(x => x > 2)
-  // convert to and from set to make values unique
-  ->Belt.Set.Int.fromArray
-  ->Belt.Set.Int.toArray // output is already sorted
-
-Js.log2("result", greaterThan2UniqueAndSorted)
-```
-
-## Curried vs. Uncurried Callbacks
-
-For functions taking a callback parameter, there are usually two versions
-available:
-
-- curried (no suffix)
-- uncurried (suffixed with `U`)
-
-E.g.:
-
-```res
-let forEach: (t<'a>, 'a => unit) => unit
-
-let forEachU: (t<'a>, (. 'a) => unit) => unit
-```
-
-The uncurried version will be faster in some cases, but for simplicity we recommend to stick with the curried version unless you need the extra performance.
-
-The two versions can be invoked as follows:
-
-```
-["a", "b", "c"]->Belt.Array.forEach(x => Js.log(x))
-
-["a", "b", "c"]->Belt.Array.forEachU((. x) => Js.log(x))
-```
-
-## Specialized Collections
-
-For collections types like set or map, Belt provides both a generic module as well as specialized, more efficient implementations for string and int keys.
-
-For example, Belt has the following set modules:
-
-- [Belt.Set](belt/set)
-- [Belt.Set.Int](belt/set-int)
-- [Belt.Set.String](belt/set-string)
-
-## Implementation Details
-
-### Array access runtime safety
-
-One common confusion comes from the way Belt handles array access. It differs from than the default standard library's.
-
-```res
-let letters = ["a", "b", "c"]
-let a = letters[0] // a == "a"
-let capitalA = Js.String.toUpperCase(a)
-let k = letters[10] // Raises an exception! The 10th index doesn't exist.
-```
-
-Because Belt avoids exceptions and returns `options` instead, this code behaves differently:
-
-```res
-open Belt
-let letters = ["a", "b", "c"]
-let a = letters[0] // a == Some("a")
-let captialA = Js.String.toUpperCase(a) // Type error! This code will not compile.
-let k = letters[10] // k == None
-```
-
-Although we've fixed the problem where `k` raises an exception, we now have a type error when trying to capitalize `a`. There are a few things going on here:
-
-- Reason transforms array index access to the function `Array.get`. So `letters[0]` is the same as `Array.get(letters, 0)`.
-- The compiler uses whichever `Array` module is in scope. If you `open Belt`, then it uses `Belt.Array`.
-- `Belt.Array.get` returns values wrapped in options, so `letters[0] == Some("a")`.
-
-Fortunately, this is easy to fix:
-
-```res example
-open Belt
-let letters = ["a", "b", "c"]
-let a = letters[0]
-
-// Use a switch statement:
-let capitalA =
-  switch a {
-  | Some(a) => Some(Js.String.toUpperCase(a))
-  | None => None
-  }
-
-let k = letters[10] // k == None
-```
-
-With that little bit of tweaking, our code now compiles successfully and is 100% free of runtime errors!
-
-### A Special Encoding for Collection Safety
-
-When we create a collection library for a custom data type we need a way to provide a comparator function. Take Set for example, suppose its element type is a pair of ints, it needs a custom compare function that takes two tuples and returns their order. The Set could not just be typed as Set.t (int \* int) , its customized compare function needs to manifest itself in the signature, otherwise, if the user creates another customized compare function, the two collection could mix which would result in runtime error.
-
-We use a phantom type to solve the problem:
-
-```res
-module Comparable1 =
-  Belt.Id.MakeComparable(
-    {
-      type t = (int, int)
-      let cmp = ((a0, a1), (b0, b1)) =>
-        switch Pervasives.compare(a0, b0) {
-        | 0 => Pervasives.compare(a1, b1)
-        | c => c
-        }
-    }
-  )
-
-let mySet1 = Belt.Set.make(~id=module(Comparable1))
-
-module Comparable2 =
-  Belt.Id.MakeComparable(
-    {
-      type t = (int, int)
-      let cmp = ((a0, a1), (b0, b1)) =>
-        switch Pervasives.compare(a0, b0) {
-        | 0 => Pervasives.compare(a1, b1)
-        | c => c
-        }
-    }
-  )
-
-let mySet2 = Belt.Set.make(~id=module(Comparable2))
-```
-
-Here, the compiler would infer `mySet1` and `mySet2` having different type, so e.g. a `merge` operation that tries to merge these two sets will correctly fail.
-
-```res
-let mySet1: t<(int, int), Comparable1.identity>
-let mySet2: t<(int, int), Comparable2.identity>
-```
-
-`Comparable1.identity` and `Comparable2.identity` are not the same using our encoding scheme.
diff --git a/pages/docs/manual/v9.0.0/api/belt/array.mdx b/pages/docs/manual/v9.0.0/api/belt/array.mdx
deleted file mode 100644
index 457aa9afe..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/array.mdx
+++ /dev/null
@@ -1,936 +0,0 @@
-# Array
-
-<Intro>
-
-Utililites for `Array` functions.
-
-</Intro>
-
-### Note about index syntax
-
-Code like `arr[0]` does *not* compile to JavaScript `arr[0]`. ReScript transforms the `[]` index syntax into a function: `Array.get(arr, 0)`. By default, this uses the default standard library's `Array.get` function, which may raise an exception if the index isn't found. If you `open Belt`, it will use the `Belt.Array.get` function which returns options instead of raising exceptions. [See this for more information](../belt.mdx#array-access-runtime-safety).
-
-## length
-
-```res sig
-let length: array<'a> => int
-```
-
-return the size of the array
-
-```res example
-// Returns 1
-Belt.Array.length(["test"])
-```
-
-## size
-
-```res sig
-let size: array<'a> => int
-```
-
-See Belt_Array.length
-
-## get
-
-```res sig
-let get: (array<'a>, int) => option<'a>
-```
-
-If `i <= 0 <= length(arr)` returns `Some(value)` where `value` is the item at index `i`.
-If `i` is out of range returns `None`
-
-## getExn
-
-```res sig
-let getExn: (array<'a>, int) => 'a
-```
-
-Raise an exception if `i` is out of range.
-Otherwise return the value at index `i` in `arr`.
-
-## getUnsafe
-
-```res sig
-let getUnsafe: (array<'a>, int) => 'a
-```
-
-Unsafe
-
-no bounds checking; this would cause type error if `i` does not stay within range
-
-## getUndefined
-
-```res sig
-let getUndefined: (array<'a>, int) => Js.undefined<'a>
-```
-
-It does the samething in the runtime as `Belt_Array.getUnsafe` it is type safe since the return type still track whether it is in range or not
-
-## set
-
-```res sig
-let set: (array<'a>, int, 'a) => bool
-```
-
-`set(arr, n, x)` modifies `arr` in place; it replaces the nth element of `arr` with `x`.
-
-Returns false means not updated due to out of range.
-
-## setExn
-
-```res sig
-let setExn: (array<'a>, int, 'a) => unit
-```
-
-`setExn(arr, i, x)` raise an exception if `i` is out of range.
-
-## setUnsafe
-
-```res sig
-let setUnsafe: (array<'a>, int, 'a) => unit
-```
-
-## shuffleInPlace
-
-```res sig
-let shuffleInPlace: array<'a> => unit
-```
-
-`shuffleInPlace(arr)` randomly re-orders the items in `arr`
-
-## shuffle
-
-```res sig
-let shuffle: array<'a> => array<'a>
-```
-
-Returns a fresh array with items in original array randomly shuffled.
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: array<'a> => unit
-```
-
-`reverseInPlace(arr)` reverses items in `arr` in place.
-
-```res example
-let arr = [10, 11, 12, 13, 14]
-
-let () = Belt.Array.reverseInPlace(arr)
-
-arr == [14, 13, 12, 11, 10]
-```
-
-## reverse
-
-```res sig
-let reverse: array<'a> => array<'a>
-```
-
-`reverse(arr)` returns a fresh array with items in arr in reverse order.
-
-```res example
-Belt.Array.reverse([10, 11, 12, 13, 14]) == [14, 13, 12, 11, 10]
-```
-
-## makeUninitialized
-
-```res sig
-let makeUninitialized: int => array<Js.undefined<'a>>
-```
-
-`makeUninitialized(n)` creates an array of length `n` filled with the undefined value. You must specify the type of data that will eventually fill the array.
-
-```res example
-let arr: array<Js.undefined<string>> = Belt.Array.makeUninitialized(5)
-
-Belt.Array.getExn(arr, 0) == Js.undefined
-```
-
-## makeUninitializedUnsafe
-
-```res sig
-let makeUninitializedUnsafe: int => array<'a>
-```
-
-Unsafe
-
-```res example
-let arr = Belt.Array.makeUninitializedUnsafe(5)
-
-Js.log(Belt.Array.getExn(arr, 0)) // undefined
-
-Belt.Array.setExn(arr, 0, "example")
-
-Js.log(Belt.Array.getExn(arr, 0) == "example")
-```
-
-## make
-
-```res sig
-let make: (int, 'a) => array<'a>
-```
-
-`make(n, e)` return an array of size `n` filled with value `e`.
-Returns an empty array when `n` is negative.
-
-## range
-
-```res sig
-let range: (int, int) => array<int>
-```
-
-`range(start, finish)` create an inclusive array.
-
-```res example
-Belt.Array.range(0, 3) == [0, 1, 2, 3]
-
-Belt.Array.range(3, 0) == []
-
-Belt.Array.range(3, 3) == [3]
-```
-
-## rangeBy
-
-```res sig
-let rangeBy: (int, int, ~step: int) => array<int>
-```
-
-`rangeBy(start, finish, ~step)`
-
-Returns empty array when step is 0 or negative. It also return an empty array when `start > finish`.
-
-```res example
-Belt.Array.rangeBy(0, 10, ~step=3) == [0, 3, 6, 9]
-
-Belt.Array.rangeBy(0, 12, ~step=3) == [0, 3, 6, 9, 12]
-
-Belt.Array.rangeBy(33, 0, ~step=1) == []
-
-Belt.Array.rangeBy(33, 0, ~step=-1) == []
-
-Belt.Array.rangeBy(3, 12, ~step=-1) == []
-
-Belt.Array.rangeBy(3, 3, ~step=0) == []
-
-Belt.Array.rangeBy(3, 3, ~step=1) == [3]
-```
-
-## makeByU
-
-```res sig
-let makeByU: (int, (. int) => 'a) => array<'a>
-```
-
-## makeBy
-
-```res sig
-let makeBy: (int, int => 'a) => array<'a>
-```
-
-`makeBy(n, f)`
-
-Return an empty array when n is negative return an array of size n populated by `f(i)` start from `0` to `n - 1`.
-
-```res example
-Belt.Array.makeBy(5, (i) => i) == [0, 1, 2, 3, 4]
-
-Belt.Array.makeBy(5, (i) => i * i) == [0, 1, 4, 9, 16]
-```
-
-## makeByAndShuffleU
-
-```res sig
-let makeByAndShuffleU: (int, (. int) => 'a) => array<'a>
-```
-
-## makeByAndShuffle
-
-```res sig
-let makeByAndShuffle: (int, int => 'a) => array<'a>
-```
-
-`makeByAndShuffle(n, f)`
-
-Equivalent to `shuffle(makeBy(n, f))`
-
-## zip
-
-```res sig
-let zip: (array<'a>, array<'b>) => array<('a, 'b)>
-```
-
-`zip(a, b)`
-
-Create an array of pairs from corresponding elements of a and b. Stop with the shorter array.
-
-```res example
-Belt.Array.zip([1, 2], [3, 4, 5]) == [(1, 3), (2, 4)]
-```
-
-## zipByU
-
-```res sig
-let zipByU: (array<'a>, array<'b>, (. 'a, 'b) => 'c) => array<'c>
-```
-
-## zipBy
-
-```res sig
-let zipBy: (array<'a>, array<'b>, ('a, 'b) => 'c) => array<'c>
-```
-
-`zipBy(xs, ys, f)`
-
-Create an array by applying `f` to corresponding elements of `xs` and `ys`. Stops with shorter array.
-
-Equivalent to `map(zip(xs, ys), ((a, b)) => f(a, b))`
-
-```res example
-Belt.Array.zipBy([1, 2, 3], [4, 5], (a, b) => 2 * a + b) == [6, 9]
-```
-
-## unzip
-
-```res sig
-let unzip: array<('a, 'b)> => (array<'a>, array<'b>)
-```
-
-`unzip(a)` takes an array of pairs and creates a pair of arrays. The first array contains all the first items of the pairs; the second array contains all the second items.
-
-```res example
-Belt.Array.unzip([(1, 2), (3, 4)]) == ([1, 3], [2, 4])
-
-Belt.Array.unzip([(1, 2), (3, 4), (5, 6), (7, 8)]) == ([1, 3, 5, 7], [2, 4, 6, 8])
-```
-
-## concat
-
-```res sig
-let concat: (array<'a>, array<'a>) => array<'a>
-```
-
-`concat(xs, ys)`
-
-Returns a fresh array containing the concatenation of the arrays `v1` and `v2`;so even if `v1` or `v2` is empty; it can not be shared
-
-```res example
-Belt.Array.concat([1, 2, 3], [4, 5]) == [1, 2, 3, 4, 5]
-
-Belt.Array.concat([], ["a", "b", "c"]) == ["a", "b", "c"]
-```
-
-## concatMany
-
-```res sig
-let concatMany: array<array<'a>> => array<'a>
-```
-
-`concatMany(xss)`
-
-Returns a fresh array as the concatenation of `xss` (an array of arrays)
-
-```res example
-Belt.Array.concatMany([[1, 2, 3], [4, 5, 6], [7, 8]]) == [1, 2, 3, 4, 5, 6, 7, 8]
-```
-
-## slice
-
-```res sig
-let slice: (array<'a>, ~offset: int, ~len: int) => array<'a>
-```
-
-`slice(xs, offset, len)` creates a new array with the len elements of `xs`
-starting at `offset` for `offset` can be negative;and is evaluated as
-`length(xs) - offset(slice, xs) - 1(1)` means get the last element as a
-singleton array `slice(xs, ~-len, len)` will return a copy of the array if the
-array does not have enough data; `slice` extracts through the end of sequence.
-
-if `len` is negative; returns the empty array.
-
-```res example
-Belt.Array.slice([10, 11, 12, 13, 14, 15, 16], ~offset=2, ~len=3) == [12, 13, 14]
-
-Belt.Array.slice([10, 11, 12, 13, 14, 15, 16], ~offset=-4, ~len=3) == [13, 14, 15]
-
-Belt.Array.slice([10, 11, 12, 13, 14, 15, 16], ~offset=4, ~len=9) == [14, 15, 16]
-```
-
-## sliceToEnd
-
-```res sig
-let sliceToEnd: (array<'a>, int) => array<'a>
-```
-
-`sliceToEnd(xs, offset)` creates a new array with the elements of `xs` starting at `offset`
-
-`offset` can be negative; and is evaluated as `length(xs) - offset(sliceToEnd, xs) - 1` means get the last element as a singleton array
-
-`sliceToEnd(xs, 0)` will return a copy of the array
-
-```res example
-Belt.Array.sliceToEnd([10, 11, 12, 13, 14, 15, 16], 2) == [12, 13, 14, 15, 16]
-
-Belt.Array.sliceToEnd([10, 11, 12, 13, 14, 15, 16], -4) == [13, 14, 15, 16]
-```
-
-## copy
-
-```res sig
-let copy: array<'a> => array<'a>
-```
-
-`copy(a)`
-
-Returns a copy of a; that is; a fresh array containing the same elements as a.
-
-## fill
-
-```res sig
-let fill: (array<'a>, ~offset: int, ~len: int, 'a) => unit
-```
-
-`fill(arr, ~offset, ~len, x)`
-
-Modifies `arr` in place, storing `x` in elements number `offset` to `offset + len - 1`.
-`offset` can be negative; and is evaluated as `length(arr - offset)`
-
-`fill(arr, ~offset=-1, ~len=1)` means fill the last element, if the array does not have enough data; `fill` will ignore it
-
-```res example
-let arr = Belt.Array.makeBy(5, (i) => i)
-
-Belt.Array.fill(arr, ~offset=2, ~len=2, 9)
-
-arr == [0, 1, 9, 9, 4]
-
-Belt.Array.fill(arr, ~offset=7, ~len=2, 8)
-
-arr == [0, 1, 9, 9, 4]
-```
-
-## blit
-
-```res sig
-let blit:
-  (
-    ~src: array<'a>,
-    ~srcOffset: int,
-    ~dst: array<'a>,
-    ~dstOffset: int,
-    ~len: int
-  ) =>
-  unit
-```
-
-`blit(~src=v1, ~srcOffset=o1, ~dst=v2, ~dstOffset=o2, ~len)`
-
-copies `len` elements from array `v1`;starting at element number `o1`;to array `v2`, starting at element number `o2`.
-
-It works correctly even if `v1` and `v2` are the same array;and the source and destination chunks overlap.
-
-`offset` can be negative; `-1` means `len - 1`; if `len + offset` is still negative;it will be set as 0
-
-For each of the examples;presume that `v1 == [10, 11, 12, 13, 14, 15, 16, 17]` and `v2 == [20, 21, 22, 23, 24, 25, 26, 27]`. The result shown is the content of the destination array.
-
-```res example
-let v1 = [10, 11, 12, 13, 14, 15, 16, 17]
-let v2 = [20, 21, 22, 23, 24, 25, 26, 27]
-
-Belt.Array.blit(~src=v1, ~srcOffset=4, ~dst=v2, ~dstOffset=2, ~len=3)
-v2 == [20, 21, 14, 15, 16, 25, 26, 27]
-
-Belt.Array.blit(~src=v1, ~srcOffset=4, ~dst=v1, ~dstOffset=2, ~len=3)
-v1 == [10, 11, 14, 15, 16, 15, 16, 17]
-```
-
-## blitUnsafe
-
-```res sig
-let blitUnsafe: (~src: array<'a>, ~srcOffset: int, ~dst: array<'a>, ~dstOffset: int, ~len: int) => unit
-```
-
-Unsafe blit without bounds checking.
-
-## forEachU
-
-```res sig
-let forEachU: (array<'a>, (. 'a) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (array<'a>, 'a => unit) => unit
-```
-
-`forEach(xs, f)`
-
-Call `f` on each element of `xs` from the beginning to end. `f` returns `unit`;so no new array is created. Use `forEach` when you are primarily concerned with repetitively creating side effects.
-
-```res example
-Belt.Array.forEach(["a", "b", "c"], x => Js.log("Item: " ++ x))
-
-/*
-  prints:
-  Item: a
-  Item: b
-  Item: c
-*/
-let total = ref(0)
-
-Belt.Array.forEach([1, 2, 3, 4], x => total := total.contents + x)
-
-total.contents == 1 + 2 + 3 + 4
-```
-
-## mapU
-
-```res sig
-let mapU: (array<'a>, (. 'a) => 'b) => array<'b>
-```
-
-## map
-
-```res sig
-let map: (array<'a>, 'a => 'b) => array<'b>
-```
-
-`map(xs, f)`
-
-Returns a new array by calling `f` for each element of `xs` from the beginning to end.
-
-```res example
-Belt.Array.map([1, 2], (x) => x + 1) == [3, 4]
-```
-
-## getByU
-
-```res sig
-let getByU: (array<'a>, (. 'a) => bool) => option<'a>
-```
-
-## getBy
-
-```res sig
-let getBy: (array<'a>, 'a => bool) => option<'a>
-```
-
-`getBy(xs, p)`
-
-Returns `Some(value)` for the first value in `xs` that satisifies the predicate function `p`; returns `None` if no element satisifies the function.
-
-```res example
-Belt.Array.getBy([1, 4, 3, 2], (x) => mod(x, 2) == 0) == Some(4)
-Belt.Array.getBy([15, 13, 11], (x) => mod(x, 2) == 0) == None
-```
-
-## getIndexByU
-
-```res sig
-let getIndexByU: (array<'a>, (. 'a) => bool) => option<int>
-```
-
-## getIndexBy
-
-```res sig
-let getIndexBy: (array<'a>, 'a => bool) => option<int>
-```
-
-`getIndexBy(xs, p)`
-
-returns `Some(index)` for the first value in `xs` that satisifies the predicate function `p`;
-returns `None` if no element satisifies the function.
-
-```res example
-Belt.Array.getIndexBy([1, 4, 3, 2], (x) => mod(x, 2) == 0) == Some(1)
-Belt.Array.getIndexBy([15, 13, 11], (x) => mod(x, 2) == 0) == None
-```
-
-## keepU
-
-```res sig
-let keepU: (array<'a>, (. 'a) => bool) => array<'a>
-```
-
-## keep
-
-```res sig
-let keep: (array<'a>, 'a => bool) => array<'a>
-```
-
-`keep(xs, p)`
-
-Returns a new array that keep all elements satisfy `p`.
-
-```res example
-Belt.Array.keep([1, 2, 3], (x) => mod(x, 2) == 0) == [2]
-```
-
-## keepWithIndexU
-
-```res sig
-let keepWithIndexU: (array<'a>, (. 'a, int) => bool) => array<'a>
-```
-
-## keepWithIndex
-
-```res sig
-let keepWithIndex: (array<'a>, ('a, int) => bool) => array<'a>
-```
-
-`keepWithIndex(xs, p)`
-
-Returns a new array that keep all elements satisfy `p`.
-
-```res example
-Belt.Array.keepWithIndex([1, 2, 3], (_x, i) => i == 1) == [2]
-```
-
-## keepMapU
-
-```res sig
-let keepMapU: (array<'a>, (. 'a) => option<'b>) => array<'b>
-```
-
-## keepMap
-
-```res sig
-let keepMap: (array<'a>, 'a => option<'b>) => array<'b>
-```
-
-`keepMap(xs, p)`
-
-Returns a new array that keep all elements that return a non-None applied `p`.
-
-```res example
-Belt.Array.keepMap([1, 2, 3], x =>
-  if mod(x, 2) == 0 {
-    Some(x)
-  } else {
-    None
-  }
-)
-== [2]
-```
-
-## forEachWithIndexU
-
-```res sig
-let forEachWithIndexU: (array<'a>, (. int, 'a) => unit) => unit
-```
-
-## forEachWithIndex
-
-```res sig
-let forEachWithIndex: (array<'a>, (int, 'a) => unit) => unit
-```
-
-`forEachWithIndex(xs, f)`
-
-The same as `Belt_Array.forEach`;
-except that `f` is supplied two arguments: the index starting from 0 and the element from `xs`.
-
-```res example
-Belt.Array.forEachWithIndex(["a", "b", "c"], (i, x) => Js.log("Item " ++ Belt.Int.toString(i) ++ " is " ++ x))
-
-/*
-  prints:
-  Item 0 is a
-  Item 1 is b
-  Item 2 is cc
-*/
-let total = ref(0)
-
-Belt.Array.forEachWithIndex([10, 11, 12, 13], (i, x) => total := total.contents + x + i)
-
-total.contents == 0 + 10 + 1 + 11 + 2 + 12 + 3 + 13
-```
-
-## mapWithIndexU
-
-```res sig
-let mapWithIndexU: (array<'a>, (. int, 'a) => 'b) => array<'b>
-```
-
-## mapWithIndex
-
-```res sig
-let mapWithIndex: (array<'a>, (int, 'a) => 'b) => array<'b>
-```
-
-`mapWithIndex(xs, f)`
-
-`mapWithIndex(xs, f)` applies `f` to each element of `xs`. Function `f` takes two arguments: the index starting from 0 and the element from `xs`.
-
-```res example
-Belt.Array.mapWithIndex([1, 2, 3], (i, x) => i + x) == [0 + 1, 1 + 2, 2 + 3]
-```
-
-## partitionU
-
-```res sig
-let partitionU: (array<'a>, (. 'a) => bool) => (array<'a>, array<'a>)
-```
-
-## partition
-
-```res sig
-let partition: (array<'a>, 'a => bool) => (array<'a>, array<'a>)
-```
-
-`partition(f, a)` split array into tuple of two arrays based on predicate `f`; first of tuple where predicate cause true, second where predicate cause false
-
-```res example
-Belt.Array.partition([1, 2, 3, 4, 5], (x) => mod(x, 2) == 0) == ([2, 4], [1, 3, 5])
-
-Belt.Array.partition([1, 2, 3, 4, 5], (x) => mod(x, 2) != 0) == ([1, 3, 5], [2, 4])
-```
-
-## reduceU
-
-```res sig
-let reduceU: (array<'b>, 'a, (. 'a, 'b) => 'a) => 'a
-```
-
-## reduce
-
-```res sig
-let reduce: (array<'b>, 'a, ('a, 'b) => 'a) => 'a
-```
-
-`reduce(xs, init, f)`
-
-Applies `f` to each element of `xs` from beginning to end. Function `f` has two parameters: the item from the list and an “accumulator”; which starts with a value of `init`. `reduce` returns the final value of the accumulator.
-
-```res example
-Belt.Array.reduce([2, 3, 4], 1, (a, b) => a + b) == 10
-
-Belt.Array.reduce(["a", "b", "c", "d"], "", (a, b) => a ++ b) == "abcd"
-```
-
-## reduceReverseU
-
-```res sig
-let reduceReverseU: (array<'b>, 'a, (. 'a, 'b) => 'a) => 'a
-```
-
-## reduceReverse
-
-```res sig
-let reduceReverse: (array<'b>, 'a, ('a, 'b) => 'a) => 'a
-```
-
-`reduceReverse(xs, init, f)`
-
-Works like `Belt_Array.reduce`; except that function `f` is applied to each item of `xs` from the last back to the first.
-
-```res example
-Belt.Array.reduceReverse(["a", "b", "c", "d"], "", (a, b) => a ++ b) == "dcba"
-```
-
-## reduceReverse2U
-
-```res sig
-let reduceReverse2U: (array<'a>, array<'b>, 'c, (. 'c, 'a, 'b) => 'c) => 'c
-```
-
-## reduceReverse2
-
-```res sig
-let reduceReverse2: (array<'a>, array<'b>, 'c, ('c, 'a, 'b) => 'c) => 'c
-```
-
-`reduceReverse2(xs, ys, init, f)`
-
-Reduces two arrays xs and ys;taking items starting at `min(length(xs), length(ys))` down to and including zero.
-
-```res example
-Belt.Array.reduceReverse2([1, 2, 3], [1, 2], 0, (acc, x, y) => acc + x + y) == 6
-```
-
-## reduceWithIndexU
-
-```res sig
-let reduceWithIndexU: (array<'a>, 'b, (. 'b, 'a, int) => 'b) => 'b
-```
-
-## reduceWithIndex
-
-```res sig
-let reduceWithIndex: (array<'a>, 'b, ('b, 'a, int) => 'b) => 'b
-```
-
-`reduceWithIndex(xs, f)`
-
-Applies `f` to each element of `xs` from beginning to end. Function `f` has three parameters: the item from the array and an “accumulator”, which starts with a value of `init` and the index of each element. `reduceWithIndex` returns the final value of the accumulator.
-
-```res example
-Belt.Array.reduceWithIndex([1, 2, 3, 4], 0, (acc, x, i) => acc + x + i) == 16
-```
-
-## someU
-
-```res sig
-let someU: (array<'a>, (. 'a) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (array<'a>, 'a => bool) => bool
-```
-
-`some(xs, p)`
-
-Returns true if at least one of the elements in `xs` satifies `p`; where `p` is a predicate: a function taking an element and returning a `bool`.
-
-```res example
-Belt.Array.some([2, 3, 4], (x) => mod(x, 2) == 1) == true
-
-Belt.Array.some([(-1), (-3), (-5)], (x) => x > 0) == false
-```
-
-## everyU
-
-```res sig
-let everyU: (array<'a>, (. 'a) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (array<'a>, 'a => bool) => bool
-```
-
-`every(xs, p)`
-
-Returns `true` if all elements satisfy `p`; where `p` is a predicate: a function taking an element and returning a `bool`.
-
-```res example
-Belt.Array.every([1, 3, 5], (x) => mod(x, 2) == 1) == true
-
-Belt.Array.every([1, (-3), 5], (x) => x > 0) == false
-```
-
-## every2U
-
-```res sig
-let every2U: (array<'a>, array<'b>, (. 'a, 'b) => bool) => bool
-```
-
-## every2
-
-```res sig
-let every2: (array<'a>, array<'b>, ('a, 'b) => bool) => bool
-```
-
-`every2(xs, ys, p)`
-
-returns true if `p(xi, yi)` is true for all pairs of elements up to the shorter length (i.e. `min(length(xs), length(ys))`)
-
-```res example
-Belt.Array.every2([1, 2, 3], [0, 1], (a, b) => a > b) == true
-
-Belt.Array.every2([], [1], (x, y) => x > y) == true
-
-Belt.Array.every2([2, 3], [1], (x, y) => x > y) == true
-
-Belt.Array.every2([0, 1], [5, 0], (x, y) => x > y) == false
-```
-
-## some2U
-
-```res sig
-let some2U: (array<'a>, array<'b>, (. 'a, 'b) => bool) => bool
-```
-
-## some2
-
-```res sig
-let some2: (array<'a>, array<'b>, ('a, 'b) => bool) => bool
-```
-
-`some2(xs, ys, p)`
-
-returns true if `p(xi, yi)` is true for any pair of elements up to the shorter length (i.e. `min(length(xs), length(ys))`)
-
-```res example
-Belt.Array.some2([0, 2], [1, 0, 3], (a, b) => a > b) == true
-
-Belt.Array.some2([], [1], (x, y) => x > y) == false
-
-Belt.Array.some2([2, 3], [1, 4], (x, y) => x > y) == true
-```
-
-## cmpU
-
-```res sig
-let cmpU: (array<'a>, array<'a>, (. 'a, 'a) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (array<'a>, array<'a>, ('a, 'a) => int) => int
-```
-
-`cmp(xs, ys, f)`
-
-Compared by length if `length(xs) != length(ys)`; returning -1 if `length(xs) < length(ys)` or 1 if `length(xs) > length(ys)`
-Otherwise compare one by one `f(x, y)`. `f` returns
-a negative number if `x` is “less than” `y`
-zero if `x` is “equal to” `y`
-a positive number if `x` is “greater than” `y`
-The comparison returns the first non-zero result of `f`;or zero if `f` returns zero for all `x` and `y`.
-
-```res example
-Belt.Array.cmp([1, 3, 5], [1, 4, 2], (a, b) => compare(a, b)) == -1
-
-Belt.Array.cmp([1, 3, 5], [1, 2, 3], (a, b) => compare(a, b)) == 1
-
-Belt.Array.cmp([1, 3, 5], [1, 3, 5], (a, b) => compare(a, b)) == 0
-```
-
-## eqU
-
-```res sig
-let eqU: (array<'a>, array<'a>, (. 'a, 'a) => bool) => bool
-```
-
-## eq
-
-```res sig
-let eq: (array<'a>, array<'a>, ('a, 'a) => bool) => bool
-```
-
-`eq(xs, ys)`
-
-return false if length is not the same
-otherwise compare items one by one using `f(xi, yi)`; and return true if all results are truefalse otherwise
-
-```res example
-Belt.Array.eq([1, 2, 3], [(-1), (-2), (-3)], (a, b) => abs(a) == abs(b)) == true
-```
-
-## truncateToLengthUnsafe
-
-```res sig
-let truncateToLengthUnsafe: (array<'a>, int) => unit
-```
-
-Unsafe `truncateToLengthUnsafe(xs, n)` sets length of array `xs` to `n`.
-
-If `n` is greater than the length of `xs`; the extra elements are set to `Js.Null_undefined.null`.
-
-If `n` is less than zero; raises a `RangeError`.
-
-```res example
-let arr = ["ant", "bee", "cat", "dog", "elk"]
-
-Belt.Array.truncateToLengthUnsafe(arr, 3)
-
-arr == ["ant", "bee", "cat"]
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/debug.mdx b/pages/docs/manual/v9.0.0/api/belt/debug.mdx
deleted file mode 100644
index 9fe40751f..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/debug.mdx
+++ /dev/null
@@ -1,7 +0,0 @@
-# Debug
-
-## setupChromeDebugger
-
-```res sig
-let setupChromeDebugger: unit => unit
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/float.mdx b/pages/docs/manual/v9.0.0/api/belt/float.mdx
deleted file mode 100644
index 9e316e24a..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/float.mdx
+++ /dev/null
@@ -1,107 +0,0 @@
-# Float
-
-This module includes convenience methods for handling `float` types.
-
-## toInt
-
-```res sig
-let toInt: float => int
-```
-
-Converts a given `float` to an `int`.
-
-```res example
-Js.log(Belt.Float.toInt(1.0) === 1) /* true */
-```
-
-## fromInt
-
-```res sig
-let fromInt: int => float
-```
-
-Converts a given `int` to a `float`.
-
-```res example
-Js.log(Belt.Float.fromInt(1) === 1.0) /* true */
-```
-
-## fromString
-
-```res sig
-let fromString: string => option<float>
-```
-
-Converts a given `string` to a `float`. Returns `Some(float)` when the input is a number, `None` otherwise.
-
-```res example
-Js.log(Belt.Float.fromString("1.0") === Some(1.0)) /* true */
-```
-
-## toString
-
-```res sig
-let toString: float => string
-```
-
-Converts a given `float` to a `string`. Uses the JavaScript `String` constructor under the hood.
-
-```res example
-Js.log(Belt.Float.toString(1.0) === "1.0") /* true */
-```
-
-## +
-
-```re sig
-let (+): (float, float) => float
-```
-
-Addition of two `float` values.
-Can be opened in a module to avoid dot-notation (`+.`), however this yields a shadow warning (Warning number 44) in the default configuration.
-
-```res example
-open Belt.Float
-Js.log(2.0 + 2.0 === 4.0) /* true */
-```
-
-## -
-
-```re sig
-let (-): (float, float) => float
-```
-
-Subtraction of two `float` values.
-Can be opened in a module to avoid dot-notation (`-.`), however this yields a shadow warning (Warning number 44) in the default configuration.
-
-```res example
-open Belt.Float
-Js.log(2.0 - 1.0 === 1.0) /* true */
-```
-
-## \*
-
-```re sig
-let (*): (float, float) => float
-```
-
-Multiplication of two `float` values.
-Can be opened in a module to avoid dot-notation (`*.`), however this yields a shadow warning (Warning number 44) in the default configuration.
-
-```res example
-open Belt.Float
-Js.log(2.0 * 2.0 === 4.0) /* true */
-```
-
-## /
-
-```re sig
-let (/): (float, float) => float
-```
-
-Division of two `float` values.
-Can be opened in a module to avoid dot-notation (`/.`), however this yields a shadow warning (Warning number 44) in the default configuration.
-
-```res example
-open Belt.Float
-Js.log(4.0 / 2.0 === 2.0) /* true */
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/hash-map-int.mdx b/pages/docs/manual/v9.0.0/api/belt/hash-map-int.mdx
deleted file mode 100644
index c1376a511..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/hash-map-int.mdx
+++ /dev/null
@@ -1,325 +0,0 @@
-# HashMapInt
-
-<Intro>
-
-Specalized when key type is `int`, more efficient than the generic type
-
-</Intro>
-
-## key
-
-```res prelude
-type key = int
-```
-
-Type of the `Belt.HashMap.Int` key.
-
-## t
-
-```res prelude
-type t<'b>
-```
-
-Type of the `Belt.HashMap.Int`
-
-## make
-
-```res sig
-let make: (~hintSize: int) => t<'b>
-```
-
-`make(~hintSize=10)` creates a new hash map by taking the `hintSize`.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-
-Belt.HashMap.Int.set(hMap, 1, "a")
-```
-
-## clear
-
-```res sig
-let clear: t<'b> => unit
-```
-
-Clears a hash table.
-
-```res example
-let hMap = Belt.HashMap.Int.fromArray([(1, "1")])
-Belt.HashMap.Int.clear(hMap)
-Belt.HashMap.Int.isEmpty(hMap) == true
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a> => bool
-```
-
-`isEmpty(m)` checks whether a hash map is empty.
-
-```res example
-let hMap = Belt.HashMap.Int.fromArray([(1, "1")])
-Belt.HashMap.Int.isEmpty(hMap) == false
-```
-
-## set
-
-```res sig
-let set: (t<'a>, key, 'a) => unit
-```
-
-`set(tbl, k, v)` if `k` does not exist, add the binding `k,v`, otherwise, update the old value with the new `v`.
-
-```res example
-let hMap = Belt.HashMap.Int.fromArray([(2, "2")])
-
-Belt.HashMap.Int.set(hMap, 1, "1")
-
-Belt.HashMap.Int.valuesToArray(hMap) == ["1", "2"]
-```
-
-## copy
-
-```res sig
-let copy: t<'a> => t<'a>
-```
-
-Creates copy of a hash map.
-
-```res example
-let hMap1 = Belt.HashMap.Int.fromArray([(1, "1"), (2, "2")])
-let hMap2 = Belt.HashMap.Int.copy(hMap1)
-
-Belt.HashMap.Int.set(hMap2, 2, "3")
-
-Belt.HashMap.Int.get(hMap1, 2) != Belt.HashMap.Int.get(hMap2, 2)
-```
-
-## get
-
-```res sig
-let get: (t<'a>, key) => option<'a>
-```
-
-## has
-
-```res sig
-let has: (t<'b>, key) => bool
-```
-
-Returns value bound under specific key. If values not exist returns `None`.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-
-Belt.HashMap.Int.get(hMap, 1) == Some("value1")
-Belt.HashMap.Int.get(hMap, 2) == None
-```
-
-## remove
-
-```res sig
-let remove: (t<'a>, key) => unit
-```
-
-If bound exists, removes it from the hash map.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-Belt.HashMap.Int.remove(hMap, 1)
-Belt.HashMap.Int.has(hMap, 1) == false
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'b>, (. key, 'b) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t<'b>, (key, 'b) => unit) => unit
-```
-
-`forEach(tbl, f)` applies `f` to all bindings in table `tbl`. `f` receives the key as first argument, and the associated value as second argument. Each binding is presented exactly once to `f`.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-Belt.HashMap.Int.forEach(hMap, (key, value) => Js.log2(key, value))
-// prints ("1", "value1")
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t<'b>, 'c, (. 'c, key, 'b) => 'c) => 'c
-```
-
-Same as [reduce](##reduce) but takes uncurried functon.
-
-## reduce
-
-```res sig
-let reduce: (t<'b>, 'c, ('c, key, 'b) => 'c) => 'c
-```
-
-`reduce(tbl, init, f)` computes `(f(kN, dN) ... (f(k1, d1, init))...)`, where `k1 ... kN` are the keys of all bindings in `tbl`, and `d1 ... dN` are the associated values. Each binding is presented exactly once to `f`.
-
-The order in which the bindings are passed to `f` is unspecified. However, if the table contains several bindings for the same key, they are passed to `f` in reverse order of introduction, that is, the most recent binding is passed first.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-Belt.HashMap.Int.set(hMap, 2, "value2")
-
-Belt.HashMap.Int.reduce(hMap, "", (acc, key, value) => acc ++ (", " ++ value)) == "value1, value2"
-```
-
-## keepMapInPlaceU
-
-```res sig
-let keepMapInPlaceU: (t<'a>, (. key, 'a) => option<'a>) => unit
-```
-
-Same as [keepMapInPlace](##keepMapInPlace) but takes uncurried functon.
-
-## keepMapInPlace
-
-```res sig
-let keepMapInPlace: (t<'a>, (key, 'a) => option<'a>) => unit
-```
-
-Filters out values for which function `f` returned `None`.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-Belt.HashMap.Int.set(hMap, 2, "value2")
-
-Belt.HashMap.Int.keepMapInPlace(hMap, (key, value) => mod(key, 1) == 0 ? None : Some(value))
-```
-
-## size
-
-```res sig
-let size: t<'a> => int
-```
-
-`size(tbl)` returns the number of bindings in `tbl`. It takes constant time.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-Belt.HashMap.Int.set(hMap, 2, "value2")
-
-Belt.HashMap.Int.size(hMap) == 2
-```
-
-## toArray
-
-```res sig
-let toArray: t<'a> => array<(key, 'a)>
-```
-
-Returns array of key value pairs.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-Belt.HashMap.Int.set(hMap, 2, "value2")
-
-Belt.HashMap.Int.toArray(hMap) == [(1, "value1"), (2, "value2")]
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'a> => array<key>
-```
-
-Returns array of keys.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-Belt.HashMap.Int.set(hMap, 2, "value2")
-
-Belt.HashMap.Int.keysToArray(hMap) == [1, 2]
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'a> => array<'a>
-```
-
-Returns array of values.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "value1")
-Belt.HashMap.Int.set(hMap, 2, "value2")
-
-Belt.HashMap.Int.valuesToArray(hMap) == ["value1", "value2"]
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<(key, 'a)> => t<'a>
-```
-
-Creates new hash map from array of pairs.
-
-Returns array of values.
-
-```res example
-let hMap = Belt.HashMap.Int.fromArray([(1, "value1"), (1, "value2")])
-Belt.HashMap.Int.toArray(hMap) == [(1, "value1"), (2, "value2")]
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'a>, array<(key, 'a)>) => unit
-```
-
-Merges many key value pairs into hash map.
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.mergeMany(hMap, [(1, "value1"), (2, "value2")])
-```
-
-## getBucketHistogram
-
-```res sig
-let getBucketHistogram: t<'a> => array<int>
-```
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "1")
-
-Belt.HashMap.Int.getBucketHistogram(hMap)
-```
-
-## logStats
-
-```res sig
-let logStats: t<'a> => unit
-```
-
-```res example
-let hMap = Belt.HashMap.Int.make(~hintSize=10)
-Belt.HashMap.Int.set(hMap, 1, "1")
-
-Belt.HashMap.Int.logStats(hMap)
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/hash-map-string.mdx b/pages/docs/manual/v9.0.0/api/belt/hash-map-string.mdx
deleted file mode 100644
index 68e3809ec..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/hash-map-string.mdx
+++ /dev/null
@@ -1,337 +0,0 @@
-# HashMapString
-
-<Intro>
-
-Specalized when key type is `string`, more efficient than the generic type
-
-</Intro>
-
-## key
-
-```res prelude
-type key = string
-```
-
-Type of the `Belt.HashMap.String` key.
-
-## t
-
-```res prelude
-type t<'b>
-```
-
-Type of the `Belt.HashMap.String`.
-
-## make
-
-```res sig
-let make: (~hintSize: int) => t<'b>
-```
-
-`make(~hintSize=10)` creates a new hash map by taking the `hintSize`.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-
-Belt.HashMap.String.set(hMap, "key1", "a")
-```
-
-## clear
-
-```res sig
-let clear: t<'b> => unit
-```
-
-Clears a hash table.
-
-```res example
-let hMap = Belt.HashMap.String.fromArray([("1", "1")])
-Belt.HashMap.String.clear(hMap)
-Belt.HashMap.String.isEmpty(hMap) == true
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a> => bool
-```
-
-`isEmpty(m)` checks whether a hash map is empty.
-
-```res example
-let hMap = Belt.HashMap.String.fromArray([("1", "1")])
-Belt.HashMap.String.isEmpty(hMap) == false
-```
-
-## set
-
-```res sig
-let set: (t<'a>, key, 'a) => unit
-```
-
-`set(tbl, k, v)` if `k` does not exist, add the binding `k,v`, otherwise, update the old value with the new `v`.
-
-```res example
-let hMap = Belt.HashMap.String.fromArray([("2", "2")])
-
-Belt.HashMap.String.set(hMap, "1", "1")
-
-Belt.HashMap.String.valuesToArray(hMap) == ["1", "2"]
-```
-
-## copy
-
-```res sig
-let copy: t<'a> => t<'a>
-```
-
-Creates copy of a hash map.
-
-```res example
-let hMap1 = Belt.HashMap.String.fromArray([("1", "1"), ("2", "2")])
-let hMap2 = Belt.HashMap.String.copy(hMap1)
-
-Belt.HashMap.String.set(hMap2, "2", "3")
-
-Belt.HashMap.String.get(hMap1, "2") != Belt.HashMap.String.get(hMap2, "2")
-```
-
-## get
-
-```res sig
-let get: (t<'a>, key) => option<'a>
-```
-
-Returns value bound under specific key. If values not exist returns `None`.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-
-Belt.HashMap.String.get(hMap, "1") == Some("value1")
-Belt.HashMap.String.get(hMap, "2") == None
-```
-
-## has
-
-```res sig
-let has: (t<'b>, key) => bool
-```
-
-Checks if `x` is bound in `tbl`.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-
-Belt.HashMap.String.has(hMap, "1") == true
-Belt.HashMap.String.has(hMap, "2") == false
-```
-
-## remove
-
-```res sig
-let remove: (t<'a>, key) => unit
-```
-
-If bound exists, removes it from the hash map.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-Belt.HashMap.String.remove(hMap, "1")
-Belt.HashMap.String.has(hMap, "1") == false
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'b>, (. key, 'b) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t<'b>, (key, 'b) => unit) => unit
-```
-
-`forEach(tbl, f)` applies `f` to all bindings in table `tbl`. `f` receives the key as first argument, and the associated value as second argument. Each binding is presented exactly once to `f`.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-Belt.HashMap.String.forEach(hMap, (key, value) => Js.log2(key, value))
-// prints ("1", "value1")
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t<'b>, 'c, (. 'c, key, 'b) => 'c) => 'c
-```
-
-Same as [reduce](##reduce) but takes uncurried functon.
-
-## reduce
-
-```res sig
-let reduce: (t<'b>, 'c, ('c, key, 'b) => 'c) => 'c
-```
-
-`reduce(tbl, init, f)` computes `(f(kN, dN) ... (f(k1, d1, init))...)`, where `k1 ... kN` are the keys of all bindings in `tbl`, and `d1 ... dN` are the associated values. Each binding is presented exactly once to `f`.
-
-The order in which the bindings are passed to `f` is unspecified. However, if the table contains several bindings for the same key, they are passed to `f` in reverse order of introduction, that is, the most recent binding is passed first.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-Belt.HashMap.String.set(hMap, "2", "value2")
-
-Belt.HashMap.String.reduce(hMap, "", (acc, key, value) =>
-  acc ++ (", " ++ value)
-) == "value1, value2"
-```
-
-## keepMapInPlaceU
-
-```res sig
-let keepMapInPlaceU: (t<'a>, (. key, 'a) => option<'a>) => unit
-```
-
-Same as [keepMapInPlace](##keepMapInPlace) but takes uncurried functon.
-
-## keepMapInPlace
-
-```res sig
-let keepMapInPlace: (t<'a>, (key, 'a) => option<'a>) => unit
-```
-
-Filters out values for which function `f` returned `None`.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-Belt.HashMap.String.set(hMap, "2", "value2")
-
-Belt.HashMap.String.keepMapInPlace(hMap, (key, value) => key == "1" ? None : Some(value))
-```
-
-## size
-
-```res sig
-let size: t<'a> => int
-```
-
-`size(tbl)` returns the number of bindings in `tbl`. It takes constant time.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-Belt.HashMap.String.set(hMap, "2", "value2")
-
-Belt.HashMap.String.size(hMap) == 2
-```
-
-## toArray
-
-```res sig
-let toArray: t<'a> => array<(key, 'a)>
-```
-
-Returns array of key value pairs.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-Belt.HashMap.String.set(hMap, "2", "value2")
-
-Belt.HashMap.String.toArray(hMap) == [("1", "value1"), ("2", "value2")]
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'a> => array<key>
-```
-
-Returns array of keys.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-Belt.HashMap.String.set(hMap, "2", "value2")
-
-Belt.HashMap.String.keysToArray(hMap) == ["1", "2"]
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'a> => array<'a>
-```
-
-Returns array of values.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "value1")
-Belt.HashMap.String.set(hMap, "2", "value2")
-
-Belt.HashMap.String.valuesToArray(hMap) == ["value1", "value2"]
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<(key, 'a)> => t<'a>
-```
-
-Creates new hash map from array of pairs.
-
-Returns array of values.
-
-```res example
-let hMap = Belt.HashMap.String.fromArray([("1", "value1"), ("2", "value2")])
-Belt.HashMap.String.toArray(hMap) == [("1", "value1"), ("2", "value2")]
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'a>, array<(key, 'a)>) => unit
-```
-
-Merges many key value pairs into hash map.
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.mergeMany(hMap, [("1", "value1"), ("2", "value2")])
-```
-
-## getBucketHistogram
-
-```res sig
-let getBucketHistogram: t<'a> => array<int>
-```
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "1")
-
-Belt.HashMap.String.getBucketHistogram(hMap)
-```
-
-## logStats
-
-```res sig
-let logStats: t<'a> => unit
-```
-
-```res example
-let hMap = Belt.HashMap.String.make(~hintSize=10)
-Belt.HashMap.String.set(hMap, "1", "1")
-
-Belt.HashMap.String.logStats(hMap)
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/hash-map.mdx b/pages/docs/manual/v9.0.0/api/belt/hash-map.mdx
deleted file mode 100644
index 36a8de539..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/hash-map.mdx
+++ /dev/null
@@ -1,444 +0,0 @@
-# HashMap
-
-<Intro>
-
-The top level provides generic mutable hash map operations.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'key, 'value, 'id>
-```
-
-The type of hash tables from type `'key` to type `'value`.
-
-## id
-
-```res prelude
-type id<'a, 'id> = Belt.Id.hashable<'a, 'id>
-```
-
-The identity needed for making an empty hash map.
-
-## make
-
-```res sig
-let make: (~hintSize: int, ~id: id<'key, 'id>) => t<'key, 'value, 'id>
-```
-
-`make(~hintSize=10, ~id)` creates a new map by taking in the comparator and `hintSize`.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let hMap = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-
-Belt.HashMap.set(hMap, 0, "a")
-```
-
-## clear
-
-```res sig
-let clear: t<'key, 'value, 'id> => unit
-```
-
-Clears a hash table.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let hMap = Belt.HashMap.fromArray([(1, "1")], ~id=module(IntHash))
-Belt.HashMap.clear(hMap)
-Belt.HashMap.isEmpty(hMap) == true
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a, 'b, 'c> => bool
-```
-
-`isEmpty(m)` checks whether a hash map is empty.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-Belt.HashMap.isEmpty(Belt.HashMap.fromArray([(1, "1")], ~id=module(IntHash))) == false
-```
-
-## set
-
-```res sig
-let set: (t<'key, 'value, 'id>, 'key, 'value) => unit
-```
-
-`set(hMap, k, v)` if `k` does not exist, add the binding `k,v`, otherwise, update the old value with the new `v`.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntHash))
-
-Belt.HashMap.set(s0, 2, "3")
-
-Belt.HashMap.valuesToArray(s0) == ["1", "3", "3"]
-```
-
-## copy
-
-```res sig
-let copy: t<'key, 'value, 'id> => t<'key, 'value, 'id>
-```
-
-Creates copy of a hash map.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntHash))
-let s1 = Belt.HashMap.copy(s0)
-
-Belt.HashMap.set(s0, 2, "3")
-
-Belt.HashMap.get(s0, 2) != Belt.HashMap.get(s1, 2)
-```
-
-## get
-
-```res sig
-let get: (t<'key, 'value, 'id>, 'key) => option<'value>
-```
-
-Returns value bound under specific key. If values not exist returns `None`.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-
-Belt.HashMap.get(s0, 1) == Some("value1")
-Belt.HashMap.get(s0, 2) == None
-```
-
-## has
-
-```res sig
-let has: (t<'key, 'value, 'id>, 'key) => bool
-```
-
-Checks if `x` is bound in `tbl`.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-
-Belt.HashMap.has(s0, 1) == true
-Belt.HashMap.has(s0, 2) == false
-```
-
-## remove
-
-```res sig
-let remove: (t<'key, 'value, 'id>, 'key) => unit
-```
-
-If bound exists, removes it from the hash map.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-Belt.HashMap.remove(s0, 1)
-Belt.HashMap.has(s0, 1) == false
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'key, 'value, 'id>, (. 'key, 'value) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t<'key, 'value, 'id>, ('key, 'value) => unit) => unit
-```
-
-`forEach(tbl, f)` applies `f` to all bindings in table `tbl`. `f` receives the key as first argument, and the associated value as second argument. Each binding is presented exactly once to `f`.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-Belt.HashMap.forEach(s0, (key, value) => Js.log2(key, value))
-// prints (1, "value1")
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t<'key, 'value, 'id>, 'c, (. 'c, 'key, 'value) => 'c) => 'c
-```
-
-Same as [reduce](##reduce) but takes uncurried functon.
-
-## reduce
-
-```res sig
-let reduce: (t<'key, 'value, 'id>, 'c, ('c, 'key, 'value) => 'c) => 'c
-```
-
-`reduce(tbl, init, f)` computes `(f(kN, dN) ... (f(k1, d1, init))...)`, where `k1 ... kN` are the keys of all bindings in `tbl`, and `d1 ... dN` are the associated values. Each binding is presented exactly once to `f`.
-
-The order in which the bindings are passed to `f` is unspecified. However, if the table contains several bindings for the same key, they are passed to `f` in reverse order of introduction, that is, the most recent binding is passed first.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-Belt.HashMap.set(s0, 2, "value2")
-
-Belt.HashMap.reduce(s0, "", (acc, key, value) => acc ++ (", " ++ value)) == "value1, value2"
-```
-
-## keepMapInPlaceU
-
-```res sig
-let keepMapInPlaceU: (t<'key, 'value, 'id>, (. 'key, 'value) => option<'value>) => unit
-```
-
-Same as [keepMapInPlace](##keepMapInPlace) but takes uncurried functon.
-
-## keepMapInPlace
-
-```res sig
-let keepMapInPlace: (t<'key, 'value, 'id>, ('key, 'value) => option<'value>) => unit
-```
-
-Filters out values for which function `f` returned `None`.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-Belt.HashMap.set(s0, 2, "value2")
-
-Belt.HashMap.keepMapInPlace(s0, (key, value) => key == 1 ? None : Some(value))
-```
-
-## size
-
-```res sig
-let size: t<'a, 'b, 'c> => int
-```
-
-`size(tbl)` returns the number of bindings in `tbl`. It takes constant time.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-Belt.HashMap.set(s0, 2, "value2")
-
-Belt.HashMap.size(s0) == 2
-```
-
-## toArray
-
-```res sig
-let toArray: t<'key, 'value, 'id> => array<('key, 'value)>
-```
-
-Returns array of key value pairs.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-Belt.HashMap.set(s0, 2, "value2")
-
-Belt.HashMap.toArray(s0) == [(1, "value1"), (2, "value2")]
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'key, 'a, 'b> => array<'key>
-```
-
-Returns array of keys.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-Belt.HashMap.set(s0, 2, "value2")
-
-Belt.HashMap.keysToArray(s0) == [1, 2]
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'a, 'value, 'b> => array<'value>
-```
-
-Returns array of values.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(s0, 1, "value1")
-Belt.HashMap.set(s0, 2, "value2")
-
-Belt.HashMap.valuesToArray(s0) == ["value1", "value2"]
-```
-
-## fromArray
-
-```res sig
-let fromArray: (array<('key, 'value)>, ~id: id<'key, 'id>) => t<'key, 'value, 'id>
-```
-
-Creates new hash map from array of pairs.
-
-Returns array of values.
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let s0 = Belt.HashMap.fromArray([(1, "value1"), (2, "value2")], ~id=module(IntHash))
-Belt.HashMap.toArray(s0) == [(1, "value1"), (2, "value2")]
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'key, 'value, 'id>, array<('key, 'value)>) => unit
-```
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-
-let hMap = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.mergeMany(hMap, [(1, "1"), (2, "2")])
-```
-
-## getBucketHistogram
-
-```res sig
-let getBucketHistogram: t<'a, 'b, 'c> => array<int>
-```
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-let hMap = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(hMap, 1, "1")
-
-Belt.HashMap.getBucketHistogram(hMap)
-```
-
-## logStats
-
-```res sig
-let logStats: t<'a, 'b, 'c> => unit
-```
-
-```res example
-module IntHash = Belt.Id.MakeHashable({
-  type t = int
-  let hash = a => a
-  let eq = (a, b) => a == b
-})
-let hMap = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
-Belt.HashMap.set(hMap, 1, "1")
-
-Belt.HashMap.logStats(hMap)
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/hash-set-int.mdx b/pages/docs/manual/v9.0.0/api/belt/hash-set-int.mdx
deleted file mode 100644
index d73d3f856..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/hash-set-int.mdx
+++ /dev/null
@@ -1,123 +0,0 @@
-# HashSetInt
-
-<Intro>
-
-This module is `Belt.HashSet` specialized with key type to be a primitive type.
-
-It is more efficient in general, the API is the same with `Belt.HashSet` except its key type is fixed, and identity is not needed(using the built-in one).
-
-</Intro>
-
-## key
-
-```res prelude
-type key = int
-```
-
-## t
-
-```res prelude
-type t
-```
-
-## make
-
-```res sig
-let make: (~hintSize: int) => t
-```
-
-## clear
-
-```res sig
-let clear: t => unit
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t => bool
-```
-
-## add
-
-```res sig
-let add: (t, key) => unit
-```
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## has
-
-```res sig
-let has: (t, key) => bool
-```
-
-## remove
-
-```res sig
-let remove: (t, key) => unit
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t, (. key) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t, key => unit) => unit
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t, 'c, (. 'c, key) => 'c) => 'c
-```
-
-## reduce
-
-```res sig
-let reduce: (t, 'c, ('c, key) => 'c) => 'c
-```
-
-## size
-
-```res sig
-let size: t => int
-```
-
-## logStats
-
-```res sig
-let logStats: t => unit
-```
-
-## toArray
-
-```res sig
-let toArray: t => array<key>
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<key> => t
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t, array<key>) => unit
-```
-
-## getBucketHistogram
-
-```res sig
-let getBucketHistogram: t => array<int>
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/hash-set-string.mdx b/pages/docs/manual/v9.0.0/api/belt/hash-set-string.mdx
deleted file mode 100644
index 277d95228..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/hash-set-string.mdx
+++ /dev/null
@@ -1,123 +0,0 @@
-# HashSetString
-
-<Intro>
-
-This module is `Belt.HashSet` specialized with key type to be a primitive type.
-
-It is more efficient in general, the API is the same with `Belt.HashSet` except its key type is fixed, and identity is not needed(using the built-in one).
-
-</Intro>
-
-## key
-
-```res prelude
-type key = string
-```
-
-## t
-
-```res prelude
-type t
-```
-
-## make
-
-```res sig
-let make: (~hintSize: int) => t
-```
-
-## clear
-
-```res sig
-let clear: t => unit
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t => bool
-```
-
-## add
-
-```res sig
-let add: (t, key) => unit
-```
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## has
-
-```res sig
-let has: (t, key) => bool
-```
-
-## remove
-
-```res sig
-let remove: (t, key) => unit
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t, (. key) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t, key => unit) => unit
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t, 'c, (. 'c, key) => 'c) => 'c
-```
-
-## reduce
-
-```res sig
-let reduce: (t, 'c, ('c, key) => 'c) => 'c
-```
-
-## size
-
-```res sig
-let size: t => int
-```
-
-## logStats
-
-```res sig
-let logStats: t => unit
-```
-
-## toArray
-
-```res sig
-let toArray: t => array<key>
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<key> => t
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t, array<key>) => unit
-```
-
-## getBucketHistogram
-
-```res sig
-let getBucketHistogram: t => array<int>
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/hash-set.mdx b/pages/docs/manual/v9.0.0/api/belt/hash-set.mdx
deleted file mode 100644
index d10a07ef2..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/hash-set.mdx
+++ /dev/null
@@ -1,160 +0,0 @@
-# HashSet
-
-<Intro>
-
-A mutable Hash set which allows customized `hash` behavior.
-All data are parameterized by not its only type but also a unique identity in the time of initialization, so that two HashSets of ints initialized with different hash functions will have different type.
-
-</Intro>
-
-```res prelude
-module I0 = unpack(
-  Belt.Id.hashableU(
-    ~hash=(. a: int) => land(a, 65535),
-    ~eq=(. a, b) => a == b,
-  )
-)
-
-let s0 = Belt.HashSet.make(~id=module(I0), ~hintSize=40)
-
-module I1 = unpack(
-  Belt.Id.hashableU(
-    ~hash=(. a: int) => land(a, 255),
-    ~eq=(. a, b) => a == b,
-  )
-)
-
-let s1 = Belt.HashSet.make(~id=module(I1), ~hintSize=40)
-
-Belt.HashSet.add(s1, 0)
-Belt.HashSet.add(s1, 1)
-```
-
-The invariant must be held: for two elements who are equal, their hashed value should be the same.
-
-Here the compiler would infer `s0` and `s1` having different type so that it would not mix.
-
-```res sig
-let s0: Belt.HashSet.t<int, I0.identity>
-let s1: Belt.HashSet.t<int, I1.identity>
-```
-
-We can add elements to the collection (see last two lines in the example above). Since this is an mutable data structure, `s1` will contain two pairs.
-
-## t
-
-```res prelude
-type t<'a, 'id>
-```
-
-## id
-
-```res prelude
-type id<'a, 'id> = Belt.Id.hashable<'a, 'id>
-```
-
-## make
-
-```res sig
-let make: (~hintSize: int, ~id: id<'a, 'id>) => t<'a, 'id>
-```
-
-## clear
-
-```res sig
-let clear: t<'a, 'id> => unit
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a, 'b> => bool
-```
-
-## add
-
-```res sig
-let add: (t<'a, 'id>, 'a) => unit
-```
-
-## copy
-
-```res sig
-let copy: t<'a, 'id> => t<'a, 'id>
-```
-
-## has
-
-```res sig
-let has: (t<'a, 'id>, 'a) => bool
-```
-
-## remove
-
-```res sig
-let remove: (t<'a, 'id>, 'a) => unit
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'a, 'id>, (. 'a) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'a, 'id>, 'a => unit) => unit
-```
-
-Order unspecified.
-
-## reduceU
-
-```res sig
-let reduceU: (t<'a, 'id>, 'c, (. 'c, 'a) => 'c) => 'c
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'a, 'id>, 'c, ('c, 'a) => 'c) => 'c
-```
-
-Order unspecified.
-
-## size
-
-```res sig
-let size: t<'a, 'id> => int
-```
-
-## logStats
-
-```res sig
-let logStats: t<'a, 'b> => unit
-```
-
-## toArray
-
-```res sig
-let toArray: t<'a, 'id> => array<'a>
-```
-
-## fromArray
-
-```res sig
-let fromArray: (array<'a>, ~id: id<'a, 'id>) => t<'a, 'id>
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'a, 'id>, array<'a>) => unit
-```
-
-## getBucketHistogram
-
-```res sig
-let getBucketHistogram: t<'a, 'b> => array<int>
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/id.mdx b/pages/docs/manual/v9.0.0/api/belt/id.mdx
deleted file mode 100644
index b8646dffe..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/id.mdx
+++ /dev/null
@@ -1,157 +0,0 @@
-# Id
-
-<Intro>
-
-Provide utilities to create identified comparators or hashes for data
-structures used below.
-
-It creates a unique identifier per module of functions so that different data
-structures with slightly different comparison functions won't mix.
-
-</Intro>
-
-## hash
-
-```res sig
-type hash<'a, 'id>
-```
-
-Its runtime represenation is a hash function, but signed with a type parameter, so that different hash functions type mismatch.
-
-## eq
-
-```res sig
-type eq<'a, 'id>
-```
-
-Its runtime represenation is an eq function, but signed with a type parameter, so that different hash functions type mismatch.
-
-## cmp
-
-```res sig
-type cmp<'a, 'id>
-```
-
-Its runtime representation is a cmp function, but signed with a type parameter, so that different hash functions type mismatch.
-
-## Comparable
-
-```res prelude
-module type Comparable = {
-  type identity
-
-  type t
-
-  let cmp: Belt.Id.cmp<t, identity>
-}
-```
-
-## comparable
-
-```res sig
-type comparable<'key,'id> =
-  module(Belt.Id.Comparable with type identity = 'id and type t = 'key)
-```
-
-is a module of functions, here it only includes cmp.
-
-Unlike normal functions, when created, it comes with a unique identity (guaranteed by the type system).
-
-It can be created using function `Belt_Id.comparableU` or `Belt_Id.comparable`.
-
-The idea of a unique identity when created is that it makes sure two sets would type mismatch if they use different comparison function
-
-## MakeComparableU
-
-```res sig
-module MakeComparableU: (M: {
-  type t
-  let cmp: (. t, t) => int
-}) => Comparable with type t = M.t
-```
-
-## MakeComparable
-
-```res sig
-module MakeComparable: (M: {
-  type t
-  let cmp: (t, t) => int
-}) => Comparable with type t = M.t
-```
-
-## comparableU
-
-```res sig
-let comparableU: (~cmp: (. 'a, 'a) => int) =>
-  module(Belt.Id.Comparable with type t = 'a)
-```
-
-## comparable
-
-```res sig
-type comparable<'key, 'id> =
-  module(Belt.Id.Comparable with type identity = 'id and type t = 'key)
-```
-
-## Hashable
-
-```res prelude
-module type Hashable = {
-  type identity
-
-  type t
-
-  let hash: Belt.Id.hash<t, identity>
-
-  let eq: Belt.Id.eq<t, identity>
-}
-```
-
-## hashable
-
-```res sig
-type hashable<'key, 'id> =
-  module(Belt.Id.Hashable with type identity = 'id and type t = 'key)
-```
-
-is a module of functions, here it only includes hash, eq.
-
-Unlike normal functions, when created, it comes with a unique identity (guaranteed by the type system).
-
-It can be created using function `Belt_Id.hashableU` or `Belt_Id.hashable`.
-
-The idea of a unique identity when created is that it makes sure two hash sets would type mismatch if they use different comparison function.
-
-## MakeHashableU
-
-```res sig
-module MakeHashableU: (M: {
-  type t
-  let hash: (. t) => int
-  let eq: (. t, t) => bool
-}) => Hashable with type t = M.t
-```
-
-## MakeHashable
-
-```res sig
-module MakeHashable: (M: {
-  type t
-  let hash: t => int
-  let eq: (t, t) => bool
-}) => Hashable with type t = M.t
-```
-
-## hashableU
-
-```res sig
-let hashableU: (~hash: (. 'a) => int, ~eq: (. 'a, 'a) => bool) =>
-  module(Belt.Id.Hashable with type t = 'a)
-```
-
-## hashable
-
-```res sig
-let hashable: (~hash: 'a => int, ~eq: ('a, 'a) => bool) =>
-  module(Belt.Id.Hashable with type t = 'a)
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/int.mdx b/pages/docs/manual/v9.0.0/api/belt/int.mdx
deleted file mode 100644
index 76fa52fbb..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/int.mdx
+++ /dev/null
@@ -1,104 +0,0 @@
-# Int
-
-This module includes convenience methods for handling `int` types.
-
-## toFloat
-
-```res sig
-let toFloat: int => float
-```
-
-Converts a given `int` to a `float`.
-
-```res example
-Js.log(Belt.Int.toFloat(1) === 1.0) /* true */
-```
-
-## fromFloat
-
-```res sig
-let fromFloat: float => int
-```
-
-Converts a given `float` to an `int`.
-
-```res example
-Js.log(Belt.Int.fromFloat(1.0) === 1) /* true */
-```
-
-## fromString
-
-```res sig
-let fromString: string => option<int>
-```
-
-Converts a given `string` to an `int`. Returns `Some(int)` when the input is a number, `None` otherwise.
-
-```res example
-Js.log(Belt.Int.fromString("1") === Some(1)) /* true */
-```
-
-
-## toString
-
-```res sig
-let toString: int => string
-```
-
-Converts a given `int` to a `string`. Uses the JavaScript `String` constructor under the hood.
-
-```res example
-Js.log(Belt.Int.toString(1) === "1") /* true */
-```
-
-## +
-
-```re sig
-let (+): (int, int) => int
-```
-
-Addition of two `int` values. Same as the addition from `Pervasives`.
-
-```res example
-open Belt.Int
-Js.log(2 + 2 === 4) /* true */
-```
-
-## -
-
-```re sig
-let (-): (int, int) => int
-```
-
-Subtraction of two `int` values. Same as the subtraction from `Pervasives`.
-
-```res example
-open Belt.Int
-Js.log(2 - 1 === 1) /* true */
-```
-
-## \*
-
-```re sig
-let (*): (int, int) => int
-```
-
-Multiplication of two `int` values. Same as the multiplication from `Pervasives`.
-
-```res example
-open Belt.Int
-Js.log(2 * 2 === 4) /* true */
-```
-
-## /
-
-```re sig
-let (/): (int, int) => int
-```
-
-Division of two `int` values. Same as the division from `Pervasives`.
-
-```res example
-open Belt.Int
-Js.log(4 / 2 === 2); /* true */
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/list.mdx b/pages/docs/manual/v9.0.0/api/belt/list.mdx
deleted file mode 100644
index b077fa75f..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/list.mdx
+++ /dev/null
@@ -1,1123 +0,0 @@
-# List
-
-<Intro>
-
-Collection functions for manipulating the `list` data structures, a singly-linked list.
-
-**Prefer Array** if you need any of the following:
-
-- Random access of element
-- Better interop with JavaScript
-- Better memory usage & performance.
-
-</Intro>
-
-## t\<'a>
-
-```res prelude
-type t<'a> = list<'a>
-```
-
-## length
-
-```res sig
-let length: t<'a> => int
-```
-
-Returns the length of a list.
-
-```res example
-Belt.List.length(list{1, 2, 3}) // 3
-```
-
-## size
-
-```res sig
-let size: t<'a> => int
-```
-
-**See:** list\{length}(#length)
-
-## head
-
-```res sig
-let head: t<'a> => option<'a>
-```
-
-Returns `Some(value)` where `value` is the first element in the list, or `None` if `someList` is an empty list.
-
-```res example
-Belt.List.head(list{}) // None
-Belt.List.head(list{1, 2, 3}) // Some(1)
-```
-
-## headExn
-
-```res sig
-let headExn: t<'a> => 'a
-```
-
-Same as [head](#head), but raises an exception if `someList` is empty. Use with care.
-
-```res example
-Belt.List.headExn(list{1, 2, 3}) // 1
-
-Belt.List.headExn(list{}) // Raises an Error
-```
-
-## tail
-
-```res sig
-let tail: t<'a> => option<t<'a>>
-```
-
-Returns `None` if `someList` is empty, otherwise it returns `Some(tail)` where `tail` is everything except the first element of `someList`.
-
-```res example
-Belt.List.tail(list{1, 2, 3}) // Some(list{2, 3})
-
-Belt.List.tail(list{}) // None
-```
-
-## tailExn
-
-```res sig
-let tailExn: t<'a> => t<'a>
-```
-
-Same as [tail](#tail), but raises an exception if `someList` is empty. Use with care.
-
-```res example
-Belt.List.tailExn(list{1, 2, 3}) // list{2, 3}
-
-Belt.List.tailExn(list{}) // Raises an Error
-```
-
-## add
-
-```res sig
-let add: (t<'a>, 'a) => t<'a>
-```
-
-Adds `value` to the beginning of `someList`.
-
-```res example
-Belt.List.add(list{2, 3}, 1) // list{1, 2, 3}
-
-Belt.List.add(list{"World", "!"}, "Hello") // list{"Hello", "World", "!"}
-```
-
-## get
-
-```res sig
-let get: (t<'a>, int) => option<'a>
-```
-
-Return the nth element in `someList`, or `None` if `index` is larger than the length.
-
-```res example
-let abc = list{"A", "B", "C"}
-
-abc->Belt.List.get(1) // Some("B")
-
-abc->Belt.List.get(4) // None
-```
-
-## getExn
-
-```res sig
-let getExn: (t<'a>, int) => 'a
-```
-
-Same as [get](#get), but raises an exception if `index` is larger than the length. Use with care.
-
-```res example
-let abc = list{"A", "B", "C"}
-
-abc->Belt.List.getExn(1) // "B"
-
-abc->Belt.List.getExn(4) // Raises an Error
-```
-
-## make
-
-```
-let make: (int, 'a) => t<'a>
-```
-
-Returns a list of length `numItems` with each element filled with value `v`. Returns an empty list if `numItems` is negative.
-
-```res example
-Belt.List.make(3, 1) // list{1, 1, 1}
-```
-
-## makeBy
-
-```res sig
-let makeBy: (int, int => 'a) => t<'a>
-```
-
-Return a list of length `numItems` with element `i` initialized with `f(i)`.
-Returns an empty list if `numItems` is negative.
-
-```res example
-Belt.List.makeBy(5, i => i) // list{0, 1, 2, 3, 4}
-
-Belt.List.makeBy(5, i => i * i) // list{0, 1, 4, 9, 16}
-```
-
-## makeByU
-
-```res sig
-let makeByU: (int, (. int) => 'a) => t<'a>
-```
-
-Uncurried version of [makeBy](#makeBy)
-
-## shuffle
-
-```res sig
-let shuffle: t<'a> => t<'a>
-```
-
-Returns a new list in random order.
-
-```res example
-Belt.List.shuffle(list{1, 2, 3}) // list{2, 1, 3}
-```
-
-## drop
-
-```res sig
-let drop: (t<'a>, int) => option<t<'a>>
-```
-
-Return a new list, dropping the first `n` elements. Returns `None` if `someList` has fewer than `n` elements.
-
-```res example
-list{1, 2, 3}->Belt.List.drop(2) // Some(list{3})
-
-list{1, 2, 3}->Belt.List.drop(3) // Some(list{})
-
-list{1, 2, 3}->Belt.List.drop(4) // None
-```
-
-## take
-
-```res sig
-let take: (t<'a>, int) => option<t<'a>>
-```
-
-Returns a list with the first `n` elements from `someList`, or `None` if `someList` has fewer than `n` elements.
-
-```res example
-list{1, 2, 3}->Belt.List.take(1) // Some(list{1})
-
-list{1, 2, 3}->Belt.List.take(2) // Some(list{1, 2})
-
-list{1, 2, 3}->Belt.List.take(4) // None
-```
-
-## splitAt
-
-```res sig
-let splitAt: (t<'a>, int) => option<(list<'a>, list<'a>)>
-```
-
-Split the list `someList` at `index`. Returns `None` when the length of `someList` is less than `index`.
-
-```res example
-list{"Hello", "World"}->Belt.List.splitAt(1) // Some((list{"Hello"}, list{"World"}))
-
-list{0, 1, 2, 3, 4}->Belt.List.splitAt(2) // Some((list{0, 1}, list{2, 3, 4}))
-```
-
-## concat
-
-```res sig
-let concat: (t<'a>, t<'a>) => t<'a>
-```
-
-Returns the list obtained by adding `secondList` after `firstList`.
-
-```res example
-Belt.List.concat(list{1, 2, 3}, list{4, 5}) // list{1, 2, 3, 4, 5}
-```
-
-## concatMany
-
-```res sig
-let concatMany: array<t<'a>> => t<'a>
-```
-
-Returns the list obtained by concatenating all the lists in array `a`, in order.
-
-```res example
-Belt.List.concatMany([list{1, 2, 3}, list{}, list{3}]) // list{1, 2, 3, 3}
-```
-
-## reverseConcat
-
-```res sig
-let reverseConcat: (t<'a>, t<'a>) => t<'a>
-```
-
-Equivalent to writing: `concat(reverse(firstList, secondList)`
-
-```res example
-Belt.List.reverseConcat(list{1, 2}, list{3, 4}) // list{2, 1, 3, 4}
-```
-
-## flatten
-
-```res sig
-let flatten: t<t<'a>> => t<'a>
-```
-
-Return the list obtained by concatenating all the lists in list `ls`, in order.
-
-```res example
-Belt.List.flatten(list{list{1, 2, 3}, list{}, list{3}}) // list{1, 2, 3, 3}
-```
-
-## map
-
-```res sig
-let map: (t<'a>, 'a => 'b) => t<'b>
-```
-
-Returns a new list with `f` applied to each element of `someList`.
-
-```res example
-list{1, 2}->Belt.List.map(x => x + 1) // list{3, 4}
-```
-
-## mapU
-
-```res sig
-let mapU: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-Uncurried version of [map](#map).
-
-## zip
-
-```res sig
-let zip: (t<'a>, t<'b>) => t<('a, 'b)>
-```
-
-Returns a list of pairs from the two lists with the length of the shorter list.
-
-```res example
-Belt.List.zip(list{1, 2}, list{3, 4, 5}) // list{(1, 3), (2, 4)}
-```
-
-## zipBy
-
-```res sig
-let zipBy: (t<'a>, t<'b>, ('a, 'b) => 'c) => t<'c>
-```
-
-**See:** [zip](#zip)
-
-```res example
-Belt.List.zipBy(list{1, 2, 3}, list{4, 5}, (a, b) => 2 * a + b) // list{6, 9}
-```
-
-## zipByU
-
-```res sig
-let zipByU: (t<'a>, t<'b>, (. 'a, 'b) => 'c) => t<'c>
-```
-
-Uncurried version of [zipBy](#zipBy).
-
-## mapWithIndex
-
-```res sig
-let mapWithIndex: (t<'a>, (int, 'a) => 'b) => t<'b>
-```
-
-Applies `f` to each element of `someList`.
-Function `f` takes two arguments: the index starting from 0 and the element from `someList`, in that order.
-
-```res example
-list{1, 2, 3}->Belt.List.mapWithIndex((index, x) => index + x) // list{1, 3, 5}
-```
-
-## mapWithIndexU
-
-```res sig
-let mapWithIndexU: (t<'a>, (. int, 'a) => 'b) => t<'b>
-```
-
-Uncurried version of [mapWithIndex](#mapWithIndex).
-
-## fromArray
-
-```res sig
-let fromArray: array<'a> => t<'a>
-```
-
-Converts the given array to a list.
-
-```res example
-Belt.List.fromArray([1, 2, 3]) // [1, 2, 3]
-```
-
-## toArray
-
-```res sig
-let toArray: t<'a> => array<'a>
-```
-
-Converts the given list to an array.
-
-```res example
-Belt.List.toArray(list{1, 2, 3}) // [1, 2, 3]
-```
-
-## reverse
-
-```res sig
-let reverse: t<'a> => t<'a>
-```
-
-Returns a new list whose elements are those of `someList` in reversed order.
-
-```res example
-Belt.List.reverse(list{1, 2, 3}) /* list{3, 2, 1} */
-```
-
-## mapReverse
-
-```res sig
-let mapReverse: (t<'a>, 'a => 'b) => t<'b>
-```
-
-Equivalent to:
-
-```res
-map(someList, f)->reverse
-```
-
-```res example
-list{3, 4, 5}->Belt.List.mapReverse(x => x * x) /* list{25, 16, 9} */
-```
-
-## mapReverseU
-
-```res sig
-let mapReverseU: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-Uncurried version of [mapReverse](#mapReverse).
-
-## forEach
-
-```res sig
-let forEach: (t<'a>, 'a => 'b) => unit
-```
-
-Call `f` on each element of `someList` from the beginning to end.
-`f` returns `unit`, so no new array is created. Use `forEach` when you are primarily concerned with repetitively creating side effects.
-
-```res example
-Belt.List.forEach(list{"a", "b", "c"}, x => Js.log("Item: " ++ x))
-/*
-  prints:
-  Item: a
-  Item: b
-  Item: c
-*/
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'a>, (. 'a) => 'b) => unit
-```
-
-Uncurried version of [forEach](#forEach).
-
-## forEachWithIndex
-
-```res sig
-let forEachWithIndex: (t<'a>, (int, 'a) => 'b) => unit
-```
-
-Call `f` on each element of `someList` from beginning to end.
-Function `f` takes two arguments: the index starting from 0 and the element from `someList`. `f` returns `unit`.
-
-```res example
-Belt.List.forEachWithIndex(list{"a", "b", "c"}, (index, x) => {
-  Js.log("Item " ++ Belt.Int.toString(index) ++ " is " ++ x)
-})
-/*
-  prints:
-  Item 0 is a
-  Item 1 is b
-  Item 2 is cc
-*/
-```
-
-## forEachWithIndexU
-
-```res sig
-let forEachWithIndexU: (t<'a>, (. int, 'a) => 'b) => unit
-```
-
-Uncurried version of [forEachWithIndex](#forEachWithIndex).
-
-## reduce
-
-```res sig
-let reduce: (t<'a>, 'b, ('b, 'a) => 'b) => 'b
-```
-
-Applies `f` to each element of `someList` from beginning to end. Function `f` has two parameters: the item from the list and an “accumulator”, which starts with a value of `initialValue`. reduce returns the final value of the accumulator.
-
-```res example
-list{1, 2, 3, 4}->Belt.List.reduce(0, (a, b) => a + b) /* 10 */
-
-/* same as */
-
-list{1, 2, 3, 4}->Belt.List.reduce(0, (acc, item) => acc + item) /* 10 */
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t<'a>, 'b, (. 'b, 'a) => 'b) => 'b
-```
-
-Uncurried version of [reduce](#reduce).
-
-## reduceWithIndex
-
-```res sig
-let reduceWithIndex: (t<'a>, 'b, ('b, 'a, int) => 'b) => 'b
-```
-
-Applies `f` to each element of `someList` from beginning to end. Function `f` has three parameters: the item from the list and an “accumulator”, which starts with a value of `initialValue` and the index of each element. `reduceWithIndex` returns the final value of the accumulator.
-
-```res example
-list{1, 2, 3, 4}->Belt.List.reduceWithIndex(0, (acc, item, index) => acc + item + index) /* 16 */
-```
-
-## reduceWithIndexU
-
-```res sig
-let reduceWithIndexU: (t<'a>, 'b, (. 'b, 'a, int) => 'b) => 'b
-```
-
-Uncurried version of [reduceWithIndex](#reduceWithIndex).
-
-## reduceReverse
-
-```res sig
-let reduceReverse: (t<'a>, 'b, ('b, 'a) => 'b) => 'b
-```
-
-Works like [reduce](#reduce), except that function `f` is applied to each item of `someList` from the last back to the first.
-
-```res example
-list{1, 2, 3, 4}->Belt.List.reduceReverse(0, (a, b) => a + b) /* 10 */
-
-list{1, 2, 3, 4}->Belt.List.reduceReverse(10, (a, b) => a - b) /* 0 */
-
-list{1, 2, 3, 4}->Belt.List.reduceReverse(list{}, Belt.List.add) // list{1, 2, 3, 4}
-```
-
-## reduceReverseU
-
-```res sig
-let reduceReverseU: (t<'a>, 'b, ('b, 'a) => 'b) => 'b
-```
-
-Uncurried version of [reduceReverse](#reduceReverse).
-
-## mapReverse2
-
-```res sig
-let mapReverse2: (t<'a>, t<'b>, ('a, 'b) => 'c) => t<'c>
-```
-
-Equivalent to: `zipBy(xs, ys, f)->reverse`
-
-```res example
-
-Belt.List.mapReverse2(list{1, 2, 3}, list{1, 2}, (a, b) => a + b) // list{4, 2}
-```
-## mapReverse2U
-
-```res sig
-let mapReverse2U: (t<'a>, t<'b>, ('a, 'b) => 'c) => t<'c>
-```
-
-Uncurried version of [mapReverse2](#mapReverse2).
-
-## forEach2
-
-```res sig
-let forEach2: (t<'a>, t<'b>, ('a, 'b) => 'c) => unit
-```
-
-Stops at the length of the shorter list.
-
-```res example
-Belt.List.forEach2(list{"Z", "Y"}, list{"A", "B", "C"}, (x, y) => Js.log2(x, y))
-
-/*
-  prints:
-  "Z" "A"
-  "Y" "B"
-*/
-```
-
-## forEach2U
-
-```res sig
-let forEach2U: (t<'a>, t<'b>, (.'a, 'b) => 'c) => unit
-```
-
-Uncurried version of [forEach2](#forEach2).
-
-## reduce2
-
-```res sig
-let reduce2: (t<'b>, t<'c>, 'a, ('a, 'b, 'c) => 'a) => 'a
-```
-
-Applies `f` to each element of `firstList` and `secondList` from beginning to end. Stops with the shorter list. Function `f` has three parameters: an “accumulator” which starts with a value of `initialValue`, an item from `firstList`, and an item from `secondList`. `reduce2` returns the final value of the accumulator.
-
-```res example
-Belt.List.reduce2(list{1, 2, 3}, list{4, 5}, 0, (acc, x, y) => acc + x * x + y) /* 0 + (1 * 1 + 4) + (2 * 2 + 5) */
-```
-
-## reduce2U
-
-```res sig
-let reduce2U: (t<'b>, t<'c>, 'a, (.'a, 'b, 'c) => 'a) => 'a
-```
-
-Uncurried version of [reduce2](#reduce2).
-
-## reduceReverse2
-
-```res sig
-let reduceReverse2: (t<'a>, t<'b>, 'c, ('c, 'a, 'b) => 'c) => 'c
-```
-
-Applies `f` to each element of `firstList` and `secondList` from end to beginning. Stops with the shorter list. Function `f` has three parameters: an “accumulator” which starts with a value of init, an item from `firstList`, and an item from `secondList`. `reduce2` returns the final value of the accumulator.
-
-```res example
-Belt.List.reduceReverse2(list{1, 2, 3}, list{4, 5}, 0, (acc, x, y) => acc + x * x + y) /*  + (1 * 1 + 4) + (2 * 2 + 5) */
-```
-
-## reduceReverse2U
-
-```res sig
-let reduceReverse2U: (t<'a>, t<'b>, 'c, (.'c, 'a, 'b) => 'c) => 'c
-```
-
-Uncurried version of [reduceReverse2](#reduceReverse2).
-
-## every
-
-```res sig
-let every: (t<'a>, 'a => bool) => bool
-```
-
-Returns `true` if all elements satisfy `pred`, where `pred` is a predicate: a function taking an element and returning a bool.
-
-```res example
-let isBelow10 = value => value < 10
-
-list{1, 9, 8, 2}->Belt.List.every(isBelow10) /* true */
-
-list{1, 99, 8, 2}->Belt.List.every(isBelow10) /* false */
-```
-
-## everyU
-
-```res sig
-let everyU: (t<'a>, (.'a) => bool) => bool
-```
-
-Uncurried version of [every](#every).
-
-## some
-
-```res sig
-let some: (t<'a>, 'a => bool) => bool
-```
-
-Returns `true` if at least _one_ of the elements in `someList` satisfies `pred`, where `pred` is a predicate: a function taking an element and returning a bool.
-
-```res example
-let isAbove100 = value => value > 100
-
-list{101, 1, 2, 3}->Belt.List.some(isAbove100) /* true */
-
-list{1, 2, 3, 4}->Belt.List.some(isAbove100) /* false */
-```
-
-## someU
-
-```res sig
-let someU: (t<'a>, (. 'a) => bool) => bool
-```
-
-Uncurried version of [some](#some).
-
-## every2
-
-```res sig
-let every2: (t<'a>, t<'b>, ('a, 'b) => bool) => bool
-```
-
-Returns `true` if predicate `pred(a, b)` is `true` for all pairs of elements up to the shorter length (i.e. `min(length(firstList), length(secondList))`)
-
-```res example
-Belt.List.every2(list{1, 2, 3}, list{0, 1}, (a, b) => a > b) /* true */
-
-Belt.List.every2(list{}, list{1}, (a, b) => a > b) /* true */
-
-Belt.List.every2(list{2, 3}, list{1}, (a, b) => a > b) /* true */
-
-Belt.List.every2(list{0, 1}, list{5, 0}, (a, b) => a > b) /* false */
-```
-
-## every2U
-
-```res sig
-let every2U: (t<'a>, t<'b>, (. 'a, 'b) => bool) => bool
-```
-
-Uncurried version of [every2](#every2).
-
-## some2
-
-```res sig
-let some2: (t<'a>, t<'b>, ('a, 'b) => bool) => bool
-```
-
-Returns `true` if predicate `pred(a, b)` is true for any pair of elements up to the shorter length (i.e. `min(length(firstList), length(secondList))`)
-
-```res example
-Belt.List.some2(list{1, 2, 3}, list{0, 1}, (a, b) => a > b) /* true */
-
-Belt.List.some2(list{}, list{1}, (a, b) => a > b) /* false */
-
-Belt.List.some2(list{2, 3}, list{1}, (a, b) => a > b) /* true */
-
-Belt.List.some2(list{0, 1}, list{5, 0}, (a, b) => a > b) /* true */
-```
-
-## some2U
-
-```res sig
-let some2U: (t<'a>, t<'b>, (. 'a, 'b) => bool) => bool
-```
-
-Uncurried version of [some2](#some2).
-
-## cmpByLength
-
-```res sig
-let cmpByLength: (t<'a>, t<'a>) => int
-```
-
-```res
-cmpByLength(firstList, secondList)
-```
-
-Compare two lists solely by length. Returns `-1` if `length(firstList)` is less than `length(secondList)`, `0` if `length(firstList)` equals `length(secondList)`, and `1` if `length(firstList)` is greater than `length(secondList)`.
-
-```res example
-Belt.List.cmpByLength(list{1, 2}, list{3, 4, 5, 6}) /* -1 */
-
-Belt.List.cmpByLength(list{1, 2, 3}, list{4, 5, 6}) /* = 0 */
-
-Belt.List.cmpByLength(list{1, 2, 3, 4}, list{5, 6}) /* = 1 */
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'a>, t<'a>, ('a, 'a) => int) => int
-```
-
-Compare elements one by one `compareFn(a, b)`. `compareFn` returns a negative number if `a` is "less than" `b`, zero if `a` is "equal to" `b`, a positive number if `a` is "greater than" `b`.
-
-The comparison returns the first non-zero result of `compareFn`, or zero if `compareFn` returns zero for all `a` and `b`.
-
-If all items have compared equal, but `firstList` is exhausted first, return `-1`. (`firstList` is shorter).
-If all items have compared equal, but `secondList` is exhausted first, return `1` (`firstList` is longer).
-
-```res example
-Belt.List.cmp(list{3}, list{3, 7}, (a, b) => compare(a, b)) /* (-1) */
-
-Belt.List.cmp(list{5, 3}, list{5}, (a, b) => compare(a, b)) /* 1 */
-
-Belt.List.cmp(list{1, 3, 5}, list{1, 4, 2}, (a, b) => compare(a, b)) /* (-1) */
-
-Belt.List.cmp(list{1, 3, 5}, list{1, 2, 3}, (a, b) => compare(a, b)) /* 1 */
-
-Belt.List.cmp(list{1, 3, 5}, list{1, 3, 5}, (a, b) => compare(a, b)) /* 0 */
-```
-
-**Please note:** The total ordering of List is different from Array,
-for Array, we compare the length first and, only if the lengths are equal, elements one by one.
-For lists, we just compare elements one by one.
-
-## cmpU
-
-```res sig
-let cmpU: (t<'a>, t<'a>, (. 'a, 'a) => int) => int
-```
-
-Uncurried version of [cmp](#cmp).
-
-## eq
-
-```res sig
-let eq: (t<'a>, t<'a>, ('a, 'a) => bool) => bool
-```
-
-Check equality of `firstList` and `secondList` using `eqElem` for equality on elements, where `eqElem` is a function that returns `true` if items `x` and `y` meet some criterion for equality, `false` otherwise. eq `false` if length of `firstList` and `secondList` are not the same.
-
-```res example
-Belt.List.eq(list{1, 2, 3}, list{1, 2}, (a, b) => a == b) /* false */
-
-Belt.List.eq(list{1, 2}, list{1, 2}, (a, b) => a == b) /* true */
-
-Belt.List.eq(list{1, 2, 3}, list{(-1), (-2), (-3)}, (a, b) => abs(a) == abs(b)) /* true */
-```
-
-## eqU
-
-```res sig
-let eqU: (t<'a>, t<'a>, (. 'a, 'a) => bool) => bool
-```
-
-Uncurried version of [eqU](#eqU).
-
-## has
-
-```res sig
-let has: (t<'a>, 'b, ('a, 'b) => bool) => bool
-```
-
-Returns `true` if the list contains at least one element for which `eqFunction(x)` returns true.
-
-```res example
-list{1, 2, 3}->Belt.List.has(2, (a, b) => a == b) /* true */
-
-list{1, 2, 3}->Belt.List.has(4, (a, b) => a == b) /* false */
-
-list{(-1), (-2), (-3)}->Belt.List.has(2, (a, b) => abs(a) == abs(b)) /* true */
-```
-
-## hasU
-
-```res sig
-let hasU: (t<'a>, 'b, (. 'a, 'b) => bool) => bool
-```
-
-Uncurried version of [has](#has).
-
-## getBy
-
-```res sig
-let getBy: (t<'a>, 'a => bool) => option<'a>
-```
-
-Returns `Some(value)` for the first value in `someList` that satisfies the predicate function `pred`. Returns `None` if no element satisfies the function.
-
-```res example
-Belt.List.getBy(list{1, 4, 3, 2}, x => x > 3) /* Some(4) */
-
-Belt.List.getBy(list{1, 4, 3, 2}, x => x > 4) /* None */
-```
-
-## getByU
-
-```res sig
-let getByU: (t<'a>, (. 'a) => bool) => option<'a>
-```
-
-Uncurried version of [getBy](#getBy).
-
-## keep
-
-```res sig
-let keep: (t<'a>, 'a => bool) => t<'a>
-```
-
-Returns a list of all elements in `someList` which satisfy the predicate function `pred`.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-Belt.List.keep(list{1, 2, 3, 4}, isEven) /* list{2, 4} */
-
-Belt.List.keep(list{None, Some(2), Some(3), None}, Belt.Option.isSome) /* list{Some(2), Some(3)} */
-```
-
-## keepU
-
-```res sig
-let keepU: (t<'a>, (. 'a) => bool) => t<'a>
-```
-
-Uncurried version of [keep](#keep).
-
-## filter
-
-```res sig
-let filter: (t<'a>, 'a => bool) => t<'a>
-```
-
-Returns a list of all elements in `someList` which satisfy the predicate function `pred`.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-Belt.List.filter(list{1, 2, 3, 4}, isEven) /* list{2, 4} */
-
-Belt.List.filter(list{None, Some(2), Some(3), None}, Belt.Option.isSome) /* list{Some(2), Some(3)} */
-```
-
-## keepWithIndex
-
-```res sig
-let keepWithIndex: (t<'a>, ('a, int) => bool) => t<'a>
-```
-
-Returns a list of all elements in `someList` which satisfy the predicate function `pred`.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-Belt.List.keepWithIndex(list{1, 2, 3, 4}, (_x, index) => isEven(index)) /* list{1, 3} */
-```
-
-## keepWithIndexU
-
-```res sig
-let keepWithIndexU: (t<'a>, (. 'a, int) => bool) => t<'a>
-```
-
-Uncurried version of [keepWithIndex](#keepWithIndex).
-
-## filterWithIndex
-
-```res sig
-let filterWithIndex: (t<'a>, ('a, int) => bool) => t<'a>
-```
-
-Returns a list of all elements in `someList` which satisfy the predicate function `pred`.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-Belt.List.filterWithIndex(list{1, 2, 3, 4}, (_x, index) => isEven(index)) /* list{1, 3} */
-```
-
-## keepMap
-
-```res sig
-let keepMap: (t<'a>, 'a => option<'b>) => t<'b>
-```
-
-Applies `f` to each element of `someList`. If `f(x)` returns `Some(value)`, then `value` is _kept_ in the resulting list.
-If `f(x)` returns `None`, the element is _not_ retained in the result.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-list{1, 2, 3, 4}
-->Belt.List.keepMap(x =>
-    if (isEven(x)) {
-      Some(x)
-    } else {
-      None
-    }
-  ) /* list{2, 4} */
-
-list{Some(1), Some(2), None}->Belt.List.keepMap(x => x) /* list{1, 2} */
-```
-
-## keepMapU
-
-```res sig
-let keepMapU: (t<'a>, (. 'a) => option<'b>) => t<'b>
-```
-
-Uncurried version of [keepMap](#keepMap).
-
-## partition
-
-```res sig
-let partition: (t<'a>, 'a => bool) => (t<'a>, t<'a>)
-```
-
-Creates a pair of lists; the first list consists of all elements of `someList` that satisfy the predicate function `pred`; the second list consists of all elements of `someList` that _do not_ satisfy `pred.
-
-In other words:
-
-```res
-(elementsThatSatisfies, elementsThatDoesNotSatisfy)
-```
-
-```res example
-Belt.List.partition(list{1, 2, 3, 4}, x => x > 2) /* (list{3, 4}, list{1, 2}) */
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t<'a>, (. 'a) => bool) => (t<'a>, t<'a>)
-```
-
-Uncurried version of [partition](#partition).
-
-## unzip
-
-```res sig
-let unzip: t<('a, 'b)> => (t<'a>, t<'b>)
-```
-
-Takes a list of pairs and creates a pair of lists. The first list contains all the first items of the pairs; the second list contains all the second items.
-
-```res example
-Belt.List.unzip(list{(1, 2), (3, 4)}) /* (list{1, 3}, list{2, 4}) */
-
-Belt.List.unzip(list{("H", "W"), ("e", "o"), ("l", "r"), ("l", "l"), ("o", "d"), (" ", "!")})
-/* (list{"H", "e", "l", "l", "o", " "}, list{"W", "o", "r", "l", "d", "!"}) */
-```
-
-## getAssoc
-
-```res sig
-let getAssoc: (t<('a, 'c)>, 'b, ('a, 'b) => bool) => option<'c>
-```
-
-Return the second element of a pair in `someList` where the first element equals `k` as per the predicate function `eqFunction`, or `None` if not found.
-
-```res example
-list{(1, "a"), (2, "b"), (3, "c")}->Belt.List.getAssoc(3, (a, b) => a == b) /* Some("c") */
-
-list{(9, "morning"), (15, "afternoon"), (22, "night")}
-->Belt.List.getAssoc(15, (k, item) => k /* 15 */ == item /* 9, 5, 22 */)
-/* Some("afternoon") */
-```
-
-## getAssocU
-
-```res sig
-let getAssocU: (t<('a, 'c)>, 'b, (. 'a, 'b) => bool) => option<'c>
-```
-
-Uncurried version of [getAssoc](#getAssoc).
-
-## hasAssoc
-
-```res sig
-let hasAssoc: (t<('a, 'c)>, 'b, ('a, 'b) => bool) => bool
-```
-
-Returns `true` if there is a pair in `someList` where the first element equals `k` as per the predicate function `eqFunction`.
-
-```res example
-list{(1, "a"), (2, "b"), (3, "c")}->Belt.List.hasAssoc(1, (a, b) => a == b) /* true */
-
-list{(9, "morning"), (15, "afternoon"), (22, "night")}
-->Belt.List.hasAssoc(25, (k, item) => k /* 25 */ == item /* 9, 5, 22 */) /* false */
-```
-
-## hasAssocU
-
-```res sig
-let hasAssocU: (t<('a, 'c)>, 'b, (. 'a, 'b) => bool) => bool
-```
-
-Uncurried version of [hasAssoc](#hasAssoc).
-
-## removeAssoc
-
-```res sig
-let removeAssoc: (t<('a, 'c)>, 'b, ('a, 'b) => bool) => t<('a, 'c)>
-```
-
-Return a list after removing the first pair whose first value is `k` per the equality predicate `eqFunction`; if not found, return a new list identical to `someList`.
-
-```res example
-list{(1, "a"), (2, "b"), (3, "c")}->Belt.List.removeAssoc(1, (a, b) => a == b) /* list{(2, "b"), (3, "c")} */
-
-list{(9, "morning"), (15, "afternoon"), (22, "night")}
-->Belt.List.removeAssoc(9, (k, item) => k /* 9 */ == item /* 9, 5, 22 */)
-/* list{(15, "afternoon"), (22, "night")} */
-```
-
-## removeAssocU
-
-```res sig
-let removeAssocU: (t<('a, 'c)>, 'b, (. 'a, 'b) => bool) => t<('a, 'c)>
-```
-
-Uncurried version of [removeAssoc](#removeAssoc).
-
-## setAssoc
-
-```res sig
-let setAssoc: (t<('a, 'c)>, 'a, 'c, ('a, 'a) => bool) => t<('a, 'c)>
-```
-
-If `k` exists in `someList` by satisfying the `eqFunction` predicate, return a new list with the key and value replaced by the new `k` and `v`; otherwise, return a new list with the pair `k`, `v` added to the head of `someList`.
-
-```res example
-list{(1, "a"), (2, "b"), (3, "c")}->Belt.List.setAssoc(2, "x", (a, b) => a == b) /* list{(1, "a"), (2, "x"), (3, "c")} */
-
-list{(1, "a"), (3, "c")}->Belt.List.setAssoc(2, "b", (a, b) => a == b) /* list{(2, "b"), (1, "a"), (3, "c")} */
-
-list{(9, "morning"), (3, "morning?!"), (22, "night")}
-->Belt.List.setAssoc(15, "afternoon", (a, b) => mod(a, 12) == mod(b, 12))
-/* list{(9, "morning"), (15, "afternoon"), (22, "night")} */
-```
-
-**Please note**
-
-In the last example, since: `15 mod 12` equals `3 mod 12`
-
-Both the key _and_ the value are replaced in the list.
-
-## setAssocU
-
-```res sig
-let setAssocU: (t<('a, 'c)>, 'a, 'c, (. 'a, 'a) => bool) => t<('a, 'c)>
-```
-
-Uncurried version of [setAssoc](#setAssoc).
-
-## sort
-
-```res sig
-let sort: (t<'a>, ('a, 'a) => int) => t<'a>
-```
-
-Returns a sorted list.
-
-```res example
-Belt.List.sort(list{5, 4, 9, 3, 7}, (a, b) => a - b) // list{3, 4, 5, 7, 9}
-```
-
-## sortU
-
-```res sig
-let sortU: (t<'a>, (. 'a, 'a) => int) => t<'a>
-```
-
-Uncurried version of [sort](#sort).
diff --git a/pages/docs/manual/v9.0.0/api/belt/map-dict.mdx b/pages/docs/manual/v9.0.0/api/belt/map-dict.mdx
deleted file mode 100644
index 4a9828f50..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/map-dict.mdx
+++ /dev/null
@@ -1,397 +0,0 @@
-# MapDict
-
-<Intro>
-
-This module separates identity from data, it is a bit more verbose but slightly more efficient due to the fact that there is no need to pack identity and data back after each operation
-
-**_Advanced usage only_**
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'key, 'value, 'id>
-```
-
-## cmp
-
-```res prelude
-type cmp<'key, 'id> = Belt_Id.cmp<'key, 'id>
-```
-
-## empty
-
-```res sig
-let empty: t<'k, 'v, 'id>
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'k, 'v, 'id> => bool
-```
-
-## has
-
-```res sig
-let has: (t<'k, 'a, 'id>, 'k, ~cmp: cmp<'k, 'id>) => bool
-```
-
-## cmpU
-
-```res sig
-let cmpU: (t<'k, 'v, 'id>, t<'k, 'v, 'id>, ~kcmp: cmp<'k, 'id>, ~vcmp: (. 'v, 'v) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'k, 'v, 'id>, t<'k, 'v, 'id>, ~kcmp: cmp<'k, 'id>, ~vcmp: ('v, 'v) => int) => int
-```
-
-## eqU
-
-```res sig
-let eqU: (t<'k, 'a, 'id>, t<'k, 'a, 'id>, ~kcmp: cmp<'k, 'id>, ~veq: (. 'a, 'a) => bool) => bool
-```
-
-## eq
-
-```res sig
-let eq: (t<'k, 'a, 'id>, t<'k, 'a, 'id>, ~kcmp: cmp<'k, 'id>, ~veq: ('a, 'a) => bool) => bool
-```
-
-`eq(m1, m2, cmp)` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data. `cmp` is the equality predicate used to compare the data associated with the keys.
-
-## findFirstByU
-
-```res sig
-let findFirstByU: (t<'k, 'v, 'id>, (. 'k, 'v) => bool) => option<('k, 'v)>
-```
-
-## findFirstBy
-
-```res sig
-let findFirstBy: (t<'k, 'v, 'id>, ('k, 'v) => bool) => option<('k, 'v)>
-```
-
-`findFirstBy(m, p)` uses function `f` to find the first key value pair to match predicate `p`.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Map.Dict.fromArray([(4, "4"), (1, "1"), (2, "2"), (3, "3")], ~cmp=IntCmp.cmp)
-
-Belt.Map.Dict.findFirstBy(s0, (k, _) => k == 4) == Some((4, "4"))
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'k, 'a, 'id>, (. 'k, 'a) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'k, 'a, 'id>, ('k, 'a) => unit) => unit
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the key as first argument, and the associated value as second argument. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## reduceU
-
-```res sig
-let reduceU: (t<'k, 'a, 'id>, 'b, (. 'b, 'k, 'a) => 'b) => 'b
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'k, 'a, 'id>, 'b, ('b, 'k, 'a) => 'b) => 'b
-```
-
-`reduce(m, a, f)` computes `f(kN, dN ... f(k1, d1, a)...)`, where `k1 ... kN` are the keys of all bindings in `m` (in increasing order), and `d1 ... dN` are the associated data.
-
-## everyU
-
-```res sig
-let everyU: (t<'k, 'a, 'id>, (. 'k, 'a) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'k, 'a, 'id>, ('k, 'a) => bool) => bool
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. Order unspecified
-
-## someU
-
-```res sig
-let someU: (t<'k, 'a, 'id>, (. 'k, 'a) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'k, 'a, 'id>, ('k, 'a) => bool) => bool
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. Order unspecified
-
-## size
-
-```res sig
-let size: t<'k, 'a, 'id> => int
-```
-
-## toList
-
-```res sig
-let toList: t<'k, 'a, 'id> => list<('k, 'a)>
-```
-
-In increasing order.
-
-## toArray
-
-```res sig
-let toArray: t<'k, 'a, 'id> => array<('k, 'a)>
-```
-
-## fromArray
-
-```res sig
-let fromArray: (array<('k, 'a)>, ~cmp: cmp<'k, 'id>) => t<'k, 'a, 'id>
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'k, 'a, 'id> => array<'k>
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'k, 'a, 'id> => array<'a>
-```
-
-## minKey
-
-```res sig
-let minKey: t<'k, 'a, 'b> => option<'k>
-```
-
-## minKeyUndefined
-
-```res sig
-let minKeyUndefined: t<'k, 'a, 'b> => Js.undefined<'k>
-```
-
-## maxKey
-
-```res sig
-let maxKey: t<'k, 'a, 'b> => option<'k>
-```
-
-## maxKeyUndefined
-
-```res sig
-let maxKeyUndefined: t<'k, 'a, 'b> => Js.undefined<'k>
-```
-
-## minimum
-
-```res sig
-let minimum: t<'k, 'a, 'b> => option<('k, 'a)>
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'k, 'a, 'b> => Js.undefined<('k, 'a)>
-```
-
-## maximum
-
-```res sig
-let maximum: t<'k, 'a, 'b> => option<('k, 'a)>
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'k, 'a, 'b> => Js.undefined<('k, 'a)>
-```
-
-## get
-
-```res sig
-let get: (t<'k, 'a, 'id>, 'k, ~cmp: cmp<'k, 'id>) => option<'a>
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'k, 'a, 'id>, 'k, ~cmp: cmp<'k, 'id>) => Js.undefined<'a>
-```
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (t<'k, 'a, 'id>, 'k, 'a, ~cmp: cmp<'k, 'id>) => 'a
-```
-
-## getExn
-
-```res sig
-let getExn: (t<'k, 'a, 'id>, 'k, ~cmp: cmp<'k, 'id>) => 'a
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t<'a, 'b, 'c> => unit
-```
-
-## remove
-
-```res sig
-let remove: (t<'a, 'b, 'id>, 'a, ~cmp: cmp<'a, 'id>) => t<'a, 'b, 'id>
-```
-
-`remove(m, x)` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
-
-## removeMany
-
-```res sig
-let removeMany: (t<'a, 'b, 'id>, array<'a>, ~cmp: cmp<'a, 'id>) => t<'a, 'b, 'id>
-```
-
-## set
-
-```res sig
-let set: (t<'a, 'b, 'id>, 'a, 'b, ~cmp: cmp<'a, 'id>) => t<'a, 'b, 'id>
-```
-
-`set(m, x, y)` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`. If `x` was already bound in `m`, its previous binding disappears.
-
-## updateU
-
-```res sig
-let updateU: (
-  t<'a, 'b, 'id>,
-  'a,
-  (. option<'b>) => option<'b>,
-  ~cmp: cmp<'a, 'id>,
-) => t<'a, 'b, 'id>
-```
-
-## update
-
-```res sig
-let update: (t<'a, 'b, 'id>, 'a, option<'b> => option<'b>, ~cmp: cmp<'a, 'id>) => t<'a, 'b, 'id>
-```
-
-## mergeU
-
-```res sig
-let mergeU: (
-  t<'a, 'b, 'id>,
-  t<'a, 'c, 'id>,
-  (. 'a, option<'b>, option<'c>) => option<'d>,
-  ~cmp: cmp<'a, 'id>,
-) => t<'a, 'd, 'id>
-```
-
-## merge
-
-```res sig
-let merge: (
-  t<'a, 'b, 'id>,
-  t<'a, 'c, 'id>,
-  ('a, option<'b>, option<'c>) => option<'d>,
-  ~cmp: cmp<'a, 'id>,
-) => t<'a, 'd, 'id>
-```
-
-`merge(m1, m2, f)` computes a map whose keys is a subset of keys of `m1` and of `m2`. The presence of each such binding, and the corresponding value, is determined with the function `f`.
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'a, 'b, 'id>, array<('a, 'b)>, ~cmp: cmp<'a, 'id>) => t<'a, 'b, 'id>
-```
-
-## keepU
-
-```res sig
-let keepU: (t<'k, 'a, 'id>, (. 'k, 'a) => bool) => t<'k, 'a, 'id>
-```
-
-## keep
-
-```res sig
-let keep: (t<'k, 'a, 'id>, ('k, 'a) => bool) => t<'k, 'a, 'id>
-```
-
-`keep(m, p)` returns the map with all the bindings in `m` that satisfy predicate `p`.
-
-## partitionU
-
-```res sig
-let partitionU: (t<'k, 'a, 'id>, (. 'k, 'a) => bool) => (t<'k, 'a, 'id>, t<'k, 'a, 'id>)
-```
-
-## partition
-
-```res sig
-let partition: (t<'k, 'a, 'id>, ('k, 'a) => bool) => (t<'k, 'a, 'id>, t<'k, 'a, 'id>)
-```
-
-`partition(m, p)` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `s` that satisfy the predicate `p`, and `m2` is the map with all the bindings of `s` that do not satisfy `p`.
-
-## split
-
-```res sig
-let split: (
-  t<'a, 'b, 'id>,
-  'a,
-  ~cmp: cmp<'a, 'id>,
-) => ((t<'a, 'b, 'id>, t<'a, 'b, 'id>), option<'b>)
-```
-
-`split(x, m)` returns a triple `(l, data, r)`, where `l` is the map with all the bindings of `m` whose key is strictly less than `x`; `r` is the map with all the bindings of `m` whose key is strictly greater than `x`; `data` is `None` if `m` contains no binding for `x`, or `Some(v)` if `m` binds `v` to `x`.
-
-## mapU
-
-```res sig
-let mapU: (t<'k, 'a, 'id>, (. 'a) => 'b) => t<'k, 'b, 'id>
-```
-
-## map
-
-```res sig
-let map: (t<'k, 'a, 'id>, 'a => 'b) => t<'k, 'b, 'id>
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value `a` of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```res sig
-let mapWithKeyU: (t<'k, 'a, 'id>, (. 'k, 'a) => 'b) => t<'k, 'b, 'id>
-```
-
-## mapWithKey
-
-```res sig
-let mapWithKey: (t<'k, 'a, 'id>, ('k, 'a) => 'b) => t<'k, 'b, 'id>
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/map-int.mdx b/pages/docs/manual/v9.0.0/api/belt/map-int.mdx
deleted file mode 100644
index e7b4f3ff0..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/map-int.mdx
+++ /dev/null
@@ -1,373 +0,0 @@
-# MapInt
-
-<Intro>
-
-Specalized when key type is `int`, more efficient than the generic type, its compare behavior is fixed using the built-in comparison
-
-</Intro>
-
-## key
-
-```res prelude
-type key = int
-```
-
-## t
-
-```res prelude
-type t<'value>
-```
-
-The type of maps from type `key` to type `'value`.
-
-## empty
-
-```res sig
-let empty: t<'v>
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'v> => bool
-```
-
-## has
-
-```res sig
-let has: (t<'v>, key) => bool
-```
-
-## cmpU
-
-```res sig
-let cmpU: (t<'v>, t<'v>, (. 'v, 'v) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'v>, t<'v>, ('v, 'v) => int) => int
-```
-
-## eqU
-
-```res sig
-let eqU: (t<'v>, t<'v>, (. 'v, 'v) => bool) => bool
-```
-
-## eq
-
-```res sig
-let eq: (t<'v>, t<'v>, ('v, 'v) => bool) => bool
-```
-
-`eq(m1,m2)` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data.
-
-## findFirstByU
-
-```res sig
-let findFirstByU: (t<'v>, (. key, 'v) => bool) => option<(key, 'v)>
-```
-
-## findFirstBy
-
-```res sig
-let findFirstBy: (t<'v>, (key, 'v) => bool) => option<(key, 'v)>
-```
-
-`findFirstBy(m, p)` uses function `f` to find the first key value pair to match predicate `p`.
-
-```res example
-let s0 = Belt.Map.Int.fromArray([(4, "4"), (1, "1"), (2, "2"), (3, "3")])
-
-Belt.Map.Int.findFirstBy(s0, (k, v) => k == 4) == Some((4, "4"))
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'v>, (. key, 'v) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'v>, (key, 'v) => unit) => unit
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the key as first argument, and the associated value as second argument. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## reduceU
-
-```res sig
-let reduceU: (t<'v>, 'v2, (. 'v2, key, 'v) => 'v2) => 'v2
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'v>, 'v2, ('v2, key, 'v) => 'v2) => 'v2
-```
-
-`reduce(m, a, f)` computes `f(kN, dN, ... f(k1, d1, a)...)`, where `k1 ... kN` are the keys of all bindings in `m` (in increasing order), and `d1 ... dN` are the associated data.
-
-## everyU
-
-```res sig
-let everyU: (t<'v>, (. key, 'v) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'v>, (key, 'v) => bool) => bool
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. Order unspecified
-
-## someU
-
-```res sig
-let someU: (t<'v>, (. key, 'v) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'v>, (key, 'v) => bool) => bool
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. Order unspecified
-
-## size
-
-```res sig
-let size: t<'v> => int
-```
-
-## toList
-
-```res sig
-let toList: t<'v> => list<(key, 'v)>
-```
-
-In increasing order.
-
-## toArray
-
-```res sig
-let toArray: t<'v> => array<(key, 'v)>
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<(key, 'v)> => t<'v>
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'v> => array<key>
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'v> => array<'v>
-```
-
-## minKey
-
-```res sig
-let minKey: t<'a> => option<key>
-```
-
-## minKeyUndefined
-
-```res sig
-let minKeyUndefined: t<'a> => Js.undefined<key>
-```
-
-## maxKey
-
-```res sig
-let maxKey: t<'a> => option<key>
-```
-
-## maxKeyUndefined
-
-```res sig
-let maxKeyUndefined: t<'a> => Js.undefined<key>
-```
-
-## minimum
-
-```res sig
-let minimum: t<'v> => option<(key, 'v)>
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'v> => Js.undefined<(key, 'v)>
-```
-
-## maximum
-
-```res sig
-let maximum: t<'v> => option<(key, 'v)>
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'v> => Js.undefined<(key, 'v)>
-```
-
-## get
-
-```res sig
-let get: (t<'v>, key) => option<'v>
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'v>, key) => Js.undefined<'v>
-```
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (t<'v>, key, 'v) => 'v
-```
-
-## getExn
-
-```res sig
-let getExn: (t<'v>, key) => 'v
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t<'a> => unit
-```
-
-**raise** when invariant is not held
-
-## remove
-
-```res sig
-let remove: (t<'v>, key) => t<'v>
-```
-
-`remove(m, x)` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
-
-## removeMany
-
-```res sig
-let removeMany: (t<'v>, array<key>) => t<'v>
-```
-
-## set
-
-```res sig
-let set: (t<'v>, key, 'v) => t<'v>
-```
-
-`set(m, x, y)` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`. If `x` was already bound in `m`, its previous binding disappears.
-
-## updateU
-
-```res sig
-let updateU: (t<'v>, key, (. option<'v>) => option<'v>) => t<'v>
-```
-
-## update
-
-```res sig
-let update: (t<'v>, key, option<'v> => option<'v>) => t<'v>
-```
-
-## mergeU
-
-```res sig
-let mergeU: (t<'v>, t<'v2>, (. key, option<'v>, option<'v2>) => option<'c>) => t<'c>
-```
-
-## merge
-
-```res sig
-let merge: (t<'v>, t<'v2>, (key, option<'v>, option<'v2>) => option<'c>) => t<'c>
-```
-
-`merge(m1, m2, f)` computes a map whose keys is a subset of keys of `m1` and of `m2`. The presence of each such binding, and the corresponding value, is determined with the function `f`.
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'v>, array<(key, 'v)>) => t<'v>
-```
-
-## keepU
-
-```res sig
-let keepU: (t<'v>, (. key, 'v) => bool) => t<'v>
-```
-
-## keep
-
-```res sig
-let keep: (t<'v>, (key, 'v) => bool) => t<'v>
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t<'v>, (. key, 'v) => bool) => (t<'v>, t<'v>)
-```
-
-## partition
-
-```res sig
-let partition: (t<'v>, (key, 'v) => bool) => (t<'v>, t<'v>)
-```
-
-`partition(m, p)` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `s` that satisfy the predicate `p`, and `m2` is the map with all the bindings of `s` that do not satisfy `p`.
-
-## split
-
-```res sig
-let split: (key, t<'v>) => (t<'v>, option<'v>, t<'v>)
-```
-
-`split(x, m)` returns a triple `(l, data, r)`, where `l` is the map with all the bindings of `m` whose key is strictly less than `x`; `r` is the map with all the bindings of `m` whose key is strictly greater than `x`; `data` is `None` if m contains no binding for `x`, or `Some(v)` if `m` binds `v` to `x`.
-
-## mapU
-
-```res sig
-let mapU: (t<'v>, (. 'v) => 'v2) => t<'v2>
-```
-
-## map
-
-```res sig
-let map: (t<'v>, 'v => 'v2) => t<'v2>
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value `a` of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```res sig
-let mapWithKeyU: (t<'v>, (. key, 'v) => 'v2) => t<'v2>
-```
-
-## mapWithKey
-
-```res sig
-let mapWithKey: (t<'v>, (key, 'v) => 'v2) => t<'v2>
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/map-string.mdx b/pages/docs/manual/v9.0.0/api/belt/map-string.mdx
deleted file mode 100644
index 545a38920..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/map-string.mdx
+++ /dev/null
@@ -1,375 +0,0 @@
-# MapString
-
-<Intro>
-
-Specalized when key type is `string`, more efficient than the generic type, its compare behavior is fixed using the built-in comparison
-
-</Intro>
-
-## key
-
-```res prelude
-type key = string
-```
-
-## t
-
-```res prelude
-type t<'value>
-```
-
-The type of maps from type `key` to type `'value`.
-
-## empty
-
-```res sig
-let empty: t<'v>
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'v> => bool
-```
-
-## has
-
-```res sig
-let has: (t<'v>, key) => bool
-```
-
-## cmpU
-
-```res sig
-let cmpU: (t<'v>, t<'v>, (. 'v, 'v) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'v>, t<'v>, ('v, 'v) => int) => int
-```
-
-## eqU
-
-```res sig
-let eqU: (t<'v>, t<'v>, (. 'v, 'v) => bool) => bool
-```
-
-## eq
-
-```res sig
-let eq: (t<'v>, t<'v>, ('v, 'v) => bool) => bool
-```
-
-`eq(m1, m2)` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data.
-
-## findFirstByU
-
-```res sig
-let findFirstByU: (t<'v>, (. key, 'v) => bool) => option<(key, 'v)>
-```
-
-## findFirstBy
-
-```res sig
-let findFirstBy: (t<'v>, (key, 'v) => bool) => option<(key, 'v)>
-```
-
-`findFirstBy(m, p)` uses function `f` to find the first key value pair to match predicate `p`.
-
-```res example
-let s0 = Belt.Map.String.fromArray([("4", 4), ("1", 1), ("2", 2), ("3", 3)])
-
-Belt.Map.String.findFirstBy(s0, (k, _) => k == "4") == Some(("4", 4))
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'v>, (. key, 'v) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'v>, (key, 'v) => unit) => unit
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the key as first argument, and the associated value as second argument. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## reduceU
-
-```res sig
-let reduceU: (t<'v>, 'v2, (. 'v2, key, 'v) => 'v2) => 'v2
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'v>, 'v2, ('v2, key, 'v) => 'v2) => 'v2
-```
-
-`reduce(m, a, f)` computes `f(kN, dN ... f(k1, d1, a)...), where k1 ... kN)` are the keys of all bindings in `m` (in increasing order), and `d1 ... dN` are the associated data.
-
-## everyU
-
-```res sig
-let everyU: (t<'v>, (. key, 'v) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'v>, (key, 'v) => bool) => bool
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. Order unspecified
-
-## someU
-
-```res sig
-let someU: (t<'v>, (. key, 'v) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'v>, (key, 'v) => bool) => bool
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. Order unspecified
-
-## size
-
-```res sig
-let size: t<'v> => int
-```
-
-## toList
-
-```res sig
-let toList: t<'v> => list<(key, 'v)>
-```
-
-In increasing order.
-
-## toArray
-
-```res sig
-let toArray: t<'v> => array<(key, 'v)>
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<(key, 'v)> => t<'v>
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'v> => array<key>
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'v> => array<'v>
-```
-
-## minKey
-
-```res sig
-let minKey: t<'a> => option<key>
-```
-
-## minKeyUndefined
-
-```res sig
-let minKeyUndefined: t<'a> => Js.undefined<key>
-```
-
-## maxKey
-
-```res sig
-let maxKey: t<'a> => option<key>
-```
-
-## maxKeyUndefined
-
-```res sig
-let maxKeyUndefined: t<'a> => Js.undefined<key>
-```
-
-## minimum
-
-```res sig
-let minimum: t<'v> => option<(key, 'v)>
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'v> => Js.undefined<(key, 'v)>
-```
-
-## maximum
-
-```res sig
-let maximum: t<'v> => option<(key, 'v)>
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'v> => Js.undefined<(key, 'v)>
-```
-
-## get
-
-```res sig
-let get: (t<'v>, key) => option<'v>
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'v>, key) => Js.undefined<'v>
-```
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (t<'v>, key, 'v) => 'v
-```
-
-## getExn
-
-```res sig
-let getExn: (t<'v>, key) => 'v
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t<'a> => unit
-```
-
-**raise** when invariant is not held
-
-## remove
-
-```res sig
-let remove: (t<'v>, key) => t<'v>
-```
-
-`remove(m, x)` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.
-
-## removeMany
-
-```res sig
-let removeMany: (t<'v>, array<key>) => t<'v>
-```
-
-## set
-
-```res sig
-let set: (t<'v>, key, 'v) => t<'v>
-```
-
-`set(m, x, y)` returns a map containing the same bindings as `m`, plus a binding of `x` to `y`. If `x` was already bound in `m`, its previous binding disappears.
-
-## updateU
-
-```res sig
-let updateU: (t<'v>, key, (. option<'v>) => option<'v>) => t<'v>
-```
-
-## update
-
-```res sig
-let update: (t<'v>, key, option<'v> => option<'v>) => t<'v>
-```
-
-## mergeU
-
-```res sig
-let mergeU: (t<'v>, t<'v2>, (. key, option<'v>, option<'v2>) => option<'c>) => t<'c>
-```
-
-## merge
-
-```res sig
-let merge: (t<'v>, t<'v2>, (key, option<'v>, option<'v2>) => option<'c>) => t<'c>
-```
-
-`merge(m1, m2, f)` computes a map whose keys is a subset of keys of `m1` and of `m2`. The presence of each such binding, and the corresponding value, is determined with the function `f`.
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'v>, array<(key, 'v)>) => t<'v>
-```
-
-## keepU
-
-```res sig
-let keepU: (t<'v>, (. key, 'v) => bool) => t<'v>
-```
-
-## keep
-
-```res sig
-let keep: (t<'v>, (key, 'v) => bool) => t<'v>
-```
-
-`keep(m, p)` returns the map with all the bindings in `m` that satisfy predicate `p`.
-
-## partitionU
-
-```res sig
-let partitionU: (t<'v>, (. key, 'v) => bool) => (t<'v>, t<'v>)
-```
-
-## partition
-
-```res sig
-let partition: (t<'v>, (key, 'v) => bool) => (t<'v>, t<'v>)
-```
-
-`partition(m, p)` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `s` that satisfy the predicate `p`, and `m2` is the map with all the bindings of s that do not satisfy `p`.
-
-## split
-
-```res sig
-let split: (key, t<'v>) => (t<'v>, option<'v>, t<'v>)
-```
-
-`split(x, m)` returns a triple `(l, data, r)`, where `l` is the map with all the bindings of `m` whose key is strictly less than `x`; `r` is the map with all the bindings of m whose key is strictly greater than `x`; `data` is `None` if `m` contains no binding for `x`, or `Some(v)` if `m` binds `v` to `x`.
-
-## mapU
-
-```res sig
-let mapU: (t<'v>, (. 'v) => 'v2) => t<'v2>
-```
-
-## map
-
-```res sig
-let map: (t<'v>, 'v => 'v2) => t<'v2>
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value `a` of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```res sig
-let mapWithKeyU: (t<'v>, (. key, 'v) => 'v2) => t<'v2>
-```
-
-## mapWithKey
-
-```res sig
-let mapWithKey: (t<'v>, (key, 'v) => 'v2) => t<'v2>
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/map.mdx b/pages/docs/manual/v9.0.0/api/belt/map.mdx
deleted file mode 100644
index ba31ca263..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/map.mdx
+++ /dev/null
@@ -1,649 +0,0 @@
-# Map
-
-The top level provides generic immutable map operations.
-
-It also has three specialized inner modules `Belt.Map.Int`, `Belt.Map.String` and `Belt.Map.Dict`.
-
-## t
-
-```res prelude
-type t<'key, 'value, 'identity>
-```
-
-`'key` is the field type
-
-`'value` is the element type
-
-`'identity` the identity of the collection
-
-## id
-
-```res prelude
-type id<'key, 'id> = Belt_Id.comparable<'key, 'id>
-```
-
-The identity needed for making an empty map.
-
-## make
-
-```res sig
-let make: (~id: id<'k, 'id>) => t<'k, 'v, 'id>
-```
-
-`make(~id)` creates a new map by taking in the comparator.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-let m = Belt.Map.make(~id=module(IntCmp))
-
-Belt.Map.set(m, 0, "a")
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a, 'b, 'c> => bool
-```
-
-`isEmpty(m)` checks whether a map m is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-Belt.Map.isEmpty(Belt.Map.fromArray([(1, "1")], ~id=module(IntCmp))) == false
-```
-
-## has
-
-```res sig
-let has: (t<'k, 'v, 'id>, 'k) => bool
-```
-
-`has(m, k)` checks whether `m` has the key `k`.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-Belt.Map.has(Belt.Map.fromArray([(1, "1")], ~id=module(IntCmp)), 1) == true
-```
-
-## cmpU
-
-```res sig
-let cmpU: (t<'k, 'v, 'id>, t<'k, 'v, 'id>, (. 'v, 'v) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'k, 'v, 'id>, t<'k, 'v, 'id>, ('v, 'v) => int) => int
-```
-
-`cmp(m0, m1, vcmp);`
-
-Total ordering of map given total ordering of value function.
-
-It will compare size first and each element following the order one by one.
-
-## eq
-
-```res sig
-let eqU: (t<'k, 'v, 'id>, t<'k, 'v, 'id>, (. 'v, 'v) => bool) => bool
-```
-
-`eq(m1, m2, veq)` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data. `veq` is the equality predicate used to compare the data associated with the keys.
-
-## eq
-
-```res sig
-let eq: (t<'k, 'v, 'id>, t<'k, 'v, 'id>, ('v, 'v) => bool) => bool
-```
-
-## findFirstByU
-
-```res sig
-let findFirstByU: (t<'k, 'v, 'id>, (. 'k, 'v) => bool) => option<('k, 'v)>
-```
-
-## findFirstBy
-
-```res sig
-let findFirstBy: (t<'k, 'v, 'id>, ('k, 'v) => bool) => option<('k, 'v)>
-```
-
-`findFirstBy(m, p)` uses function `f` to find the first key value pair to match predicate `p`.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-let s0 = Belt.Map.fromArray(~id=module(IntCmp), [(4, "4"), (1, "1"), (2, "2"), (3, "")])
-
-Belt.Map.findFirstBy(s0, (k, v) => k == 4) /* (4, "4") */
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'k, 'v, 'id>, (. 'k, 'v) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'k, 'v, 'id>, ('k, 'v) => unit) => unit
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the `'k` as first argument, and the associated value as second argument. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-let s0 = Belt.Map.fromArray(~id=module(IntCmp), [(4, "4"), (1, "1"), (2, "2"), (3, "")])
-
-let acc = ref(list{})
-
-Belt.Map.forEach(s0, (k, v) => acc := list{(k, v), ...acc.contents})
-
-acc.contents == list{(4, "4"), (3, "3"), (2, "2"), (1, "1")}
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t<'k, 'v, 'id>, 'acc, (. 'acc, 'k, 'v) => 'acc) => 'acc
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'k, 'v, 'id>, 'acc, ('acc, 'k, 'v) => 'acc) => 'acc
-```
-
-`reduce(m, a, f)` computes `(f(kN, dN) ... (f(k1, d1, a))...)`, where `k1 ... kN` are the keys of all bindings in m (in increasing order), and `d1 ... dN` are the associated data.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-let s0 = Belt.Map.fromArray(~id=module(IntCmp), [(4, "4"), (1, "1"), (2, "2"), (3, "3")])
-
-Belt.Map.reduce(s0, list{}, (acc, k, v) => list{
-  (k, v),
-  ...acc,
-}) /* [(4, "4"), (3, "3"), (2, "2"), (1, "1"), 0] */
-```
-
-## everyU
-
-```res sig
-let everyU: (t<'k, 'v, 'id>, (. 'k, 'v) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'k, 'v, 'id>, ('k, 'v) => bool) => bool
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. Order unspecified
-
-## someU
-
-```res sig
-let someU: (t<'k, 'v, 'id>, (. 'k, 'v) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'k, 'v, 'id>, ('k, 'v) => bool) => bool
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. Order unspecified
-
-## size
-
-```res sig
-let size: t<'k, 'v, 'id> => int
-```
-
-`size(s)`
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-Belt.Map.size(Belt.Map.fromArray([(2, "2"), (2, "1"), (3, "3")], ~id=module(IntCmp))) == 2
-```
-
-## toArray
-
-```res sig
-let toArray: t<'k, 'v, 'id> => array<('k, 'v)>
-```
-
-`toArray(s)`
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-Belt.Map.toArray(Belt.Map.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntCmp))) == [
-    (1, "1"),
-    (2, "2"),
-    (3, "3"),
-  ]
-```
-
-## toList
-
-```res sig
-let toList: t<'k, 'v, 'id> => list<('k, 'v)>
-```
-
-In increasing order.
-
-See `Belt.Map.toArray`
-
-## fromArray
-
-```res sig
-let fromArray: (array<('k, 'v)>, ~id: id<'k, 'id>) => t<'k, 'v, 'id>
-```
-
-`fromArray(kvs, ~id);`
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-Belt.Map.toArray(Belt.Map.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntCmp))) == [
-    (1, "1"),
-    (2, "2"),
-    (3, "3"),
-  ]
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'k, 'v, 'id> => array<'k>
-```
-
-`keysToArray(s);`
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-Belt.Map.keysToArray(Belt.Map.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntCmp))) == [
-    1,
-    2,
-    3,
-  ]
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'k, 'v, 'id> => array<'v>
-```
-
-`valuesToArray(s);`
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-Belt.Map.valuesToArray(
-  Belt.Map.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntCmp)),
-) == ["1", "2", "3"]
-```
-
-## minKey
-
-```res sig
-let minKey: t<'k, 'a, 'b> => option<'k>
-```
-
-`minKey(s)` returns the minimum key, None if not exist.
-
-## minKeyUndefined
-
-```res sig
-let minKeyUndefined: t<'k, 'a, 'b> => Js.undefined<'k>
-```
-
-See `Belt.Map.minKey`
-
-## maxKey
-
-```res sig
-let maxKey: t<'k, 'a, 'b> => option<'k>
-```
-
-`maxKey(s)` returns the maximum key, None if not exist.
-
-## maxKeyUndefined
-
-```res sig
-let maxKeyUndefined: t<'k, 'a, 'b> => Js.undefined<'k>
-```
-
-See `Belt.Map.maxKey`
-
-## minimum
-
-```res sig
-let minimum: t<'k, 'v, 'a> => option<('k, 'v)>
-```
-
-`minimum(s)` returns the minimum key value pair, None if not exist
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'k, 'v, 'a> => Js.undefined<('k, 'v)>
-```
-
-See `Belt.Map.minimum`
-
-## maximum
-
-```res sig
-let maximum: t<'k, 'v, 'a> => option<('k, 'v)>
-```
-
-`maximum(s)` returns the maximum key value pair, None if not exist.
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'k, 'v, 'a> => Js.undefined<('k, 'v)>
-```
-
-See `Belt.Map.maximum`
-
-## get
-
-```res sig
-let get: (t<'k, 'v, 'id>, 'k) => option<'v>
-```
-
-`get(s, k)`
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-Belt.Map.get(Belt.Map.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntCmp)), 2) ==
-  Some("2")
-
-Belt.Map.get(Belt.Map.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntCmp)), 2) == None
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'k, 'v, 'id>, 'k) => Js.undefined<'v>
-```
-
-See `Belt.Map.get`
-
-Returns `undefined` when not found
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (t<'k, 'v, 'id>, 'k, 'v) => 'v
-```
-
-`getWithDefault(s, k, default)`
-
-See `Belt.Map.get`
-
-Returns default when `k` is not found.
-
-## getExn
-
-```res sig
-let getExn: (t<'k, 'v, 'id>, 'k) => 'v
-```
-
-`getExn(s, k)`
-
-See `Belt.Map.getExn`
-
-raise when `k` not exist
-
-## remove
-
-```res sig
-let remove: (t<'k, 'v, 'id>, 'k) => t<'k, 'v, 'id>
-```
-
-`remove(m, x)` when `x` is not in `m`, `m` is returned reference unchanged.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-let s0 = Belt.Map.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntCmp))
-
-let s1 = Belt.Map.remove(s0, 1)
-
-let s2 = Belt.Map.remove(s1, 1)
-
-s1 === s2
-
-Belt.Map.keysToArray(s1) == [2, 3]
-```
-
-## removeMany
-
-```res sig
-let removeMany: (t<'k, 'v, 'id>, array<'k>) => t<'k, 'v, 'id>
-```
-
-`removeMany(s, xs)`
-
-Removing each of `xs` to `s`, note unlike `Belt.Map.remove`, the reference of return value might be changed even if none in `xs` exists `s`.
-
-## set
-
-```res sig
-let set: (t<'k, 'v, 'id>, 'k, 'v) => t<'k, 'v, 'id>
-```
-
-`set(m, x, y)` returns a map containing the same bindings as `m`, with a new binding of `x` to `y`. If `x` was already bound in `m`, its previous binding disappears.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = (a, b) => Pervasives.compare(a, b)
-})
-
-let s0 = Belt.Map.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntCmp))
-
-let s1 = Belt.Map.set(s0, 2, "3")
-
-Belt.Map.valuesToArray(s1) == ["1", "3", "3"]
-```
-
-## updateU
-
-```res sig
-let updateU: (t<'k, 'v, 'id>, 'k, (. option<'v>) => option<'v>) => t<'k, 'v, 'id>
-```
-
-## update
-
-```res sig
-let update: (t<'k, 'v, 'id>, 'k, option<'v> => option<'v>) => t<'k, 'v, 'id>
-```
-
-`update(m, x, f)` returns a map containing the same bindings as `m`, except for the binding of `x`. Depending on the value of `y` where `y` is `f(get(m, x))`, the binding of `x` is added, removed or updated. If `y` is `None`, the binding is removed if it exists; otherwise, if `y` is `Some(z)` then `x` is associated to `z` in the resulting map.
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'k, 'v, 'id>, array<('k, 'v)>) => t<'k, 'v, 'id>
-```
-
-`mergeMany(s, xs)`
-
-Adding each of `xs` to `s`, note unlike `add`, the reference of return value might be changed even if all values in `xs` exist `s`.
-
-## mergeU
-
-```res sig
-let mergeU: (
-  t<'k, 'v, 'id>,
-  t<'k, 'v2, 'id>,
-  (. 'k, option<'v>, option<'v2>) => option<'v3>,
-) => t<'k, 'v3, 'id>
-```
-
-## merge
-
-```res sig
-let merge: (
-  t<'k, 'v, 'id>,
-  t<'k, 'v2, 'id>,
-  ('k, option<'v>, option<'v2>) => option<'v3>,
-) => t<'k, 'v3, 'id>
-```
-
-`merge(m1, m2, f)` computes a map whose keys is a subset of keys of `m1` and of `m2`. The presence of each such binding, and the corresponding value, is determined with the function `f`.
-
-## keepU
-
-```res sig
-let keepU: (t<'k, 'v, 'id>, (. 'k, 'v) => bool) => t<'k, 'v, 'id>
-```
-
-## keep
-
-```res sig
-let keep: (t<'k, 'v, 'id>, ('k, 'v) => bool) => t<'k, 'v, 'id>
-```
-
-`keep(m, p)` returns the map with all the bindings in m that satisfy predicate `p`.
-
-## partitionU
-
-```res sig
-let partitionU: (t<'k, 'v, 'id>, (. 'k, 'v) => bool) => (t<'k, 'v, 'id>, t<'k, 'v, 'id>)
-```
-
-## partition
-
-```res sig
-let partition: (t<'k, 'v, 'id>, ('k, 'v) => bool) => (t<'k, 'v, 'id>, t<'k, 'v, 'id>)
-```
-
-`partition(m, p)` returns a pair of maps `(m1, m2)`, where `m1` contains all the bindings of `s` that satisfy the predicate `p`, and `m2` is the map with all the bindings of `s` that do not satisfy `p`.
-
-## split
-
-```res sig
-let split: (t<'k, 'v, 'id>, 'k) => ((t<'k, 'v, 'id>, t<'k, 'v, 'id>), option<'v>)
-```
-
-`split(x, m)` returns a tuple `(l, r)`, data, where `l` is the map with all the bindings of `m` whose 'k is strictly less than `x`; `r` is the map with all the bindings of m whose 'k is strictly greater than `x`; `data` is `None` if `m` contains no binding for `x`, or `Some(v)` if `m` binds `v` to `x`.
-
-## mapU
-
-```res sig
-let mapU: (t<'k, 'v, 'id>, (. 'v) => 'v2) => t<'k, 'v2, 'id>
-```
-
-## map
-
-```res sig
-let map: (t<'k, 'v, 'id>, 'v => 'v2) => t<'k, 'v2, 'id>
-```
-
-`map(m, f) returns a map with same domain as`m`, where the associated value`a`of all bindings of`m`has been replaced by the result of the application of`f`to`a`. The bindings are passed to`f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```res sig
-let mapWithKeyU: (t<'k, 'v, 'id>, (. 'k, 'v) => 'v2) => t<'k, 'v2, 'id>
-```
-
-## mapWithKey
-
-```res sig
-let mapWithKey: (t<'k, 'v, 'id>, ('k, 'v) => 'v2) => t<'k, 'v2, 'id>
-```
-
-`mapWithKey(m, f)`
-
-The same as `Belt.Map.map` except that `f` is supplied with one more argument: the key.
-
-## getData
-
-```res sig
-let getData: t<'k, 'v, 'id> => Belt_MapDict.t<'k, 'v, 'id>
-```
-
-`getData(s0)`
-
-Advanced usage only
-
-Returns the raw data (detached from comparator), but its type is still manifested, so that user can pass identity directly without boxing.
-
-## getId
-
-```res sig
-let getId: t<'k, 'v, 'id> => id<'k, 'id>
-```
-
-Advanced usage only
-
-Returns the identity of s0.
-
-## packIdData
-
-```res sig
-let packIdData: (~id: id<'k, 'id>, ~data: Belt_MapDict.t<'k, 'v, 'id>) => t<'k, 'v, 'id>
-```
-
-`packIdData(~id, ~data)`
-
-Advanced usage only
-
-Returns the packed collection.
diff --git a/pages/docs/manual/v9.0.0/api/belt/mutable-map-int.mdx b/pages/docs/manual/v9.0.0/api/belt/mutable-map-int.mdx
deleted file mode 100644
index 73fbcaaab..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/mutable-map-int.mdx
+++ /dev/null
@@ -1,299 +0,0 @@
-# MutableMapInt
-
-## key
-
-```res prelude
-type key = int
-```
-
-## t
-
-```res prelude
-type t<'a>
-```
-
-## make
-
-```res sig
-let make: unit => t<'a>
-```
-
-## clear
-
-```res sig
-let clear: t<'a> => unit
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a> => bool
-```
-
-## has
-
-```res sig
-let has: (t<'a>, key) => bool
-```
-
-## cmpU
-
-```res sig
-let cmpU: (t<'a>, t<'a>, (. 'a, 'a) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'a>, t<'a>, ('a, 'a) => int) => int
-```
-
-`cmp(m1, m2, cmp)` First compare by size, if size is the same, compare by key, value pair.
-
-## eqU
-
-```res sig
-let eqU: (t<'a>, t<'a>, (. 'a, 'a) => bool) => bool
-```
-
-## eq
-
-```res sig
-let eq: (t<'a>, t<'a>, ('a, 'a) => bool) => bool
-```
-
-`eq(m1, m2, cmp)`
-
-## forEachU
-
-```res sig
-let forEachU: (t<'a>, (. key, 'a) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'a>, (key, 'a) => unit) => unit
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the key as first argument, and the associated value as second argument. The application order of `f` is in increasing order.
-
-## reduceU
-
-```res sig
-let reduceU: (t<'a>, 'b, (. 'b, key, 'a) => 'b) => 'b
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'a>, 'b, ('b, key, 'a) => 'b) => 'b
-```
-
-`reduce(m, a, f), computes`(f(kN, dN) ... (f(k1, d1, a))...)`, where`k1 ... kN`are the keys of all bindings in`m`(in increasing order), and`d1 ... dN` are the associated data.
-
-## everyU
-
-```res sig
-let everyU: (t<'a>, (. key, 'a) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'a>, (key, 'a) => bool) => bool
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. The application order of `p` is unspecified.
-
-## someU
-
-```res sig
-let someU: (t<'a>, (. key, 'a) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'a>, (key, 'a) => bool) => bool
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. The application order of `p` is unspecified.
-
-## size
-
-```res sig
-let size: t<'a> => int
-```
-
-## toList
-
-```res sig
-let toList: t<'a> => list<(key, 'a)>
-```
-
-In increasing order
-
-## toArray
-
-```res sig
-let toArray: t<'a> => array<(key, 'a)>
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<(key, 'a)> => t<'a>
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'a> => array<key>
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'a> => array<'a>
-```
-
-## minKey
-
-```res sig
-let minKey: t<'a> => option<key>
-```
-
-## minKeyUndefined
-
-```res sig
-let minKeyUndefined: t<'a> => Js.undefined<key>
-```
-
-## maxKey
-
-```res sig
-let maxKey: t<'a> => option<key>
-```
-
-## maxKeyUndefined
-
-```res sig
-let maxKeyUndefined: t<'a> => Js.undefined<key>
-```
-
-## minimum
-
-```res sig
-let minimum: t<'a> => option<(key, 'a)>
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'a> => Js.undefined<(key, 'a)>
-```
-
-## maximum
-
-```res sig
-let maximum: t<'a> => option<(key, 'a)>
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'a> => Js.undefined<(key, 'a)>
-```
-
-## get
-
-```res sig
-let get: (t<'a>, key) => option<'a>
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'a>, key) => Js.undefined<'a>
-```
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (t<'a>, key, 'a) => 'a
-```
-
-## getExn
-
-```res sig
-let getExn: (t<'a>, key) => 'a
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t<'a> => unit
-```
-
-Raise when invariant is not held.
-
-## remove
-
-```res sig
-let remove: (t<'a>, key) => unit
-```
-
-`remove(m, x)` do the in-place modification.
-
-## removeMany
-
-```res sig
-let removeMany: (t<'a>, array<key>) => unit
-```
-
-## set
-
-```res sig
-let set: (t<'a>, key, 'a) => unit
-```
-
-`set(m, x, y)` do the in-place modification, return `m` for chaining. If `x` was already bound in `m`, its previous binding disappears.
-
-## updateU
-
-```res sig
-let updateU: (t<'a>, key, (. option<'a>) => option<'a>) => unit
-```
-
-## update
-
-```res sig
-let update: (t<'a>, key, option<'a> => option<'a>) => unit
-```
-
-## mapU
-
-```res sig
-let mapU: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-## map
-
-```res sig
-let map: (t<'a>, 'a => 'b) => t<'b>
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value a of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```res sig
-let mapWithKeyU: (t<'a>, (. key, 'a) => 'b) => t<'b>
-```
-
-## mapWithKey
-
-```res sig
-let mapWithKey: (t<'a>, (key, 'a) => 'b) => t<'b>
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/mutable-map-string.mdx b/pages/docs/manual/v9.0.0/api/belt/mutable-map-string.mdx
deleted file mode 100644
index cfc1d228d..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/mutable-map-string.mdx
+++ /dev/null
@@ -1,299 +0,0 @@
-# MutableMapString
-
-## key
-
-```res prelude
-type key = string
-```
-
-## t
-
-```res prelude
-type t<'a>
-```
-
-## make
-
-```res sig
-let make: unit => t<'a>
-```
-
-## clear
-
-```res sig
-let clear: t<'a> => unit
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a> => bool
-```
-
-## has
-
-```res sig
-let has: (t<'a>, key) => bool
-```
-
-## cmpU
-
-```res sig
-let cmpU: (t<'a>, t<'a>, (. 'a, 'a) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'a>, t<'a>, ('a, 'a) => int) => int
-```
-
-`cmp(m1, m2, cmp)` First compare by size, if size is the same, compare by key, value pair.
-
-## eqU
-
-```res sig
-let eqU: (t<'a>, t<'a>, (. 'a, 'a) => bool) => bool
-```
-
-## eq
-
-```res sig
-let eq: (t<'a>, t<'a>, ('a, 'a) => bool) => bool
-```
-
-`eq(m1, m2, cmp)`
-
-## forEachU
-
-```res sig
-let forEachU: (t<'a>, (. key, 'a) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'a>, (key, 'a) => unit) => unit
-```
-
-`forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the key as first argument, and the associated value as second argument. The application order of `f` is in increasing order.
-
-## reduceU
-
-```res sig
-let reduceU: (t<'a>, 'b, (. 'b, key, 'a) => 'b) => 'b
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'a>, 'b, ('b, key, 'a) => 'b) => 'b
-```
-
-`reduce(m, a, f), computes`(f(kN, dN) ... (f(k1, d1, a))...)`, where`k1 ... kN`are the keys of all bindings in`m`(in increasing order), and`d1 ... dN` are the associated data.
-
-## everyU
-
-```res sig
-let everyU: (t<'a>, (. key, 'a) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'a>, (key, 'a) => bool) => bool
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. The application order of `p` is unspecified.
-
-## someU
-
-```res sig
-let someU: (t<'a>, (. key, 'a) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'a>, (key, 'a) => bool) => bool
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. The application order of `p` is unspecified.
-
-## size
-
-```res sig
-let size: t<'a> => int
-```
-
-## toList
-
-```res sig
-let toList: t<'a> => list<(key, 'a)>
-```
-
-In increasing order
-
-## toArray
-
-```res sig
-let toArray: t<'a> => array<(key, 'a)>
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<(key, 'a)> => t<'a>
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'a> => array<key>
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'a> => array<'a>
-```
-
-## minKey
-
-```res sig
-let minKey: t<'a> => option<key>
-```
-
-## minKeyUndefined
-
-```res sig
-let minKeyUndefined: t<'a> => Js.undefined<key>
-```
-
-## maxKey
-
-```res sig
-let maxKey: t<'a> => option<key>
-```
-
-## maxKeyUndefined
-
-```res sig
-let maxKeyUndefined: t<'a> => Js.undefined<key>
-```
-
-## minimum
-
-```res sig
-let minimum: t<'a> => option<(key, 'a)>
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'a> => Js.undefined<(key, 'a)>
-```
-
-## maximum
-
-```res sig
-let maximum: t<'a> => option<(key, 'a)>
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'a> => Js.undefined<(key, 'a)>
-```
-
-## get
-
-```res sig
-let get: (t<'a>, key) => option<'a>
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'a>, key) => Js.undefined<'a>
-```
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (t<'a>, key, 'a) => 'a
-```
-
-## getExn
-
-```res sig
-let getExn: (t<'a>, key) => 'a
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t<'a> => unit
-```
-
-Raise when invariant is not held.
-
-## remove
-
-```res sig
-let remove: (t<'a>, key) => unit
-```
-
-`remove(m, x)` do the in-place modification.
-
-## removeMany
-
-```res sig
-let removeMany: (t<'a>, array<key>) => unit
-```
-
-## set
-
-```res sig
-let set: (t<'a>, key, 'a) => unit
-```
-
-`set(m, x, y)` do the in-place modification, return `m` for chaining. If `x` was already bound in `m`, its previous binding disappears.
-
-## updateU
-
-```res sig
-let updateU: (t<'a>, key, (. option<'a>) => option<'a>) => unit
-```
-
-## update
-
-```res sig
-let update: (t<'a>, key, option<'a> => option<'a>) => unit
-```
-
-## mapU
-
-```res sig
-let mapU: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-## map
-
-```res sig
-let map: (t<'a>, 'a => 'b) => t<'b>
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value a of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```res sig
-let mapWithKeyU: (t<'a>, (. key, 'a) => 'b) => t<'b>
-```
-
-## mapWithKey
-
-```res sig
-let mapWithKey: (t<'a>, (key, 'a) => 'b) => t<'b>
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/mutable-map.mdx b/pages/docs/manual/v9.0.0/api/belt/mutable-map.mdx
deleted file mode 100644
index 21ed52d60..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/mutable-map.mdx
+++ /dev/null
@@ -1,313 +0,0 @@
-# MutableMap
-
-<Intro>
-
-A mutable sorted map module which allows customize compare behavior.
-
-</Intro>
-
-Same as `Belt.Map`, but mutable.
-
-## t
-
-```res prelude
-type t<'k, 'v, 'id>
-```
-
-## id
-
-```res prelude
-type id<'key, 'id> = Belt_Id.comparable<'key, 'id>
-```
-
-## make
-
-```res sig
-let make: (~id: id<'k, 'id>) => t<'k, 'a, 'id>
-```
-
-## clear
-
-```res sig
-let clear: t<'a, 'b, 'c> => unit
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a, 'b, 'c> => bool
-```
-
-## has
-
-```res sig
-let has: (t<'k, 'a, 'b>, 'k) => bool
-```
-
-## cmpU
-
-```res sig
-let cmpU: (t<'k, 'a, 'id>, t<'k, 'a, 'id>, (. 'a, 'a) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'k, 'a, 'id>, t<'k, 'a, 'id>, ('a, 'a) => int) => int
-```
-
-`cmp(m1, m2, cmp)` First compare by size, if size is the same, compare by key, value pair.
-
-## eqU
-
-```res sig
-let eqU: (t<'k, 'a, 'id>, t<'k, 'a, 'id>, (. 'a, 'a) => bool) => bool
-```
-
-## eq
-
-```res sig
-let eq: (t<'k, 'a, 'id>, t<'k, 'a, 'id>, ('a, 'a) => bool) => bool
-```
-
-`eq(m1, m2, eqf)` tests whether the maps `m1` and `m2` are equal, that is, contain equal keys and associate them with equal data. `eqf` is the equality predicate used to compare the data associated with the keys.
-
-## forEachU
-
-```res sig
-let forEachU: (t<'k, 'a, 'id>, (. 'k, 'a) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'k, 'a, 'id>, ('k, 'a) => unit) => unit
-```
-
-`forEach(m, f)` applies f to all bindings in map `m`. `f` receives the `'k` as first argument, and the associated value as second argument. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## reduceU
-
-```res sig
-let reduceU: (t<'k, 'a, 'id>, 'b, (. 'b, 'k, 'a) => 'b) => 'b
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'k, 'a, 'id>, 'b, ('b, 'k, 'a) => 'b) => 'b
-```
-
-`reduce(m, a, f), computes`(f(kN, dN) ... (f(k1, d1, a))...)`, where`k1 ... kN`are the keys of all bindings in`m`(in increasing order), and`d1 ... dN` are the associated data.
-
-## everyU
-
-```res sig
-let everyU: (t<'k, 'a, 'id>, (. 'k, 'a) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'k, 'a, 'id>, ('k, 'a) => bool) => bool
-```
-
-`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`.
-
-## someU
-
-```res sig
-let someU: (t<'k, 'a, 'id>, (. 'k, 'a) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'k, 'a, 'id>, ('k, 'a) => bool) => bool
-```
-
-`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`.
-
-## size
-
-```res sig
-let size: t<'k, 'a, 'id> => int
-```
-
-## toList
-
-```res sig
-let toList: t<'k, 'a, 'id> => list<('k, 'a)>
-```
-
-In increasing order.
-
-## toArray
-
-```res sig
-let toArray: t<'k, 'a, 'id> => array<('k, 'a)>
-```
-
-## fromArray
-
-```res sig
-let fromArray: (array<('k, 'a)>, ~id: id<'k, 'id>) => t<'k, 'a, 'id>
-```
-
-## keysToArray
-
-```res sig
-let keysToArray: t<'k, 'a, 'b> => array<'k>
-```
-
-## valuesToArray
-
-```res sig
-let valuesToArray: t<'b, 'a, 'c> => array<'a>
-```
-
-## minKey
-
-```res sig
-let minKey: t<'k, 'a, 'b> => option<'k>
-```
-
-## minKeyUndefined
-
-```res sig
-let minKeyUndefined: t<'k, 'a, 'b> => Js.undefined<'k>
-```
-
-## maxKey
-
-```res sig
-let maxKey: t<'k, 'a, 'b> => option<'k>
-```
-
-## maxKeyUndefined
-
-```res sig
-let maxKeyUndefined: t<'k, 'a, 'b> => Js.undefined<'k>
-```
-
-## minimum
-
-```res sig
-let minimum: t<'k, 'a, 'b> => option<('k, 'a)>
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'k, 'a, 'b> => Js.undefined<('k, 'a)>
-```
-
-## maximum
-
-```res sig
-let maximum: t<'k, 'a, 'b> => option<('k, 'a)>
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'k, 'a, 'b> => Js.undefined<('k, 'a)>
-```
-
-## get
-
-```res sig
-let get: (t<'k, 'a, 'id>, 'k) => option<'a>
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'k, 'a, 'id>, 'k) => Js.undefined<'a>
-```
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (t<'k, 'a, 'id>, 'k, 'a) => 'a
-```
-
-## getExn
-
-```res sig
-let getExn: (t<'k, 'a, 'id>, 'k) => 'a
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t<'a, 'b, 'c> => unit
-```
-
-Raise when invariant is not held.
-
-## remove
-
-```res sig
-let remove: (t<'k, 'a, 'id>, 'k) => unit
-```
-
-`remove(m, x)` do the in-place modification.
-
-## removeMany
-
-```res sig
-let removeMany: (t<'k, 'a, 'id>, array<'k>) => unit
-```
-
-## set
-
-```res sig
-let set: (t<'k, 'a, 'id>, 'k, 'a) => unit
-```
-
-`set(m, x, y)` do the in-place modification
-
-## updateU
-
-```res sig
-let updateU: (t<'k, 'a, 'id>, 'k, (. option<'a>) => option<'a>) => unit
-```
-
-## update
-
-```res sig
-let update: (t<'k, 'a, 'id>, 'k, option<'a> => option<'a>) => unit
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'k, 'a, 'id>, array<('k, 'a)>) => unit
-```
-
-## mapU
-
-```res sig
-let mapU: (t<'k, 'a, 'id>, (. 'a) => 'b) => t<'k, 'b, 'id>
-```
-
-## map
-
-```res sig
-let map: (t<'k, 'a, 'id>, 'a => 'b) => t<'k, 'b, 'id>
-```
-
-`map(m, f)` returns a map with same domain as `m`, where the associated value a of all bindings of `m` has been replaced by the result of the application of `f` to `a`. The bindings are passed to `f` in increasing order with respect to the ordering over the type of the keys.
-
-## mapWithKeyU
-
-```res sig
-let mapWithKeyU: (t<'k, 'a, 'id>, (. 'k, 'a) => 'b) => t<'k, 'b, 'id>
-```
-
-## mapWithKey
-
-```res sig
-let mapWithKey: (t<'k, 'a, 'id>, ('k, 'a) => 'b) => t<'k, 'b, 'id>
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/mutable-queue.mdx b/pages/docs/manual/v9.0.0/api/belt/mutable-queue.mdx
deleted file mode 100644
index 9efd21a4b..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/mutable-queue.mdx
+++ /dev/null
@@ -1,175 +0,0 @@
-# MutableQueue
-
-<Intro>
-
-An FIFO(first in first out) queue data structure.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a>
-```
-
-The type of queues containing elements of `type('a)`.
-
-## make
-
-```res sig
-let make: unit => t<'a>
-```
-
-Returns a new queue, initially empty.
-
-## clear
-
-```res sig
-let clear: t<'a> => unit
-```
-
-Discard all elements from the queue.
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a> => bool
-```
-
-Returns `true` if the given queue is empty, `false` otherwise.
-
-## fromArray
-
-```res sig
-let fromArray: array<'a> => t<'a>
-```
-
-`fromArray` a is equivalent to `Array.forEach(a, add(q, a));`
-
-## add
-
-```res sig
-let add: (t<'a>, 'a) => unit
-```
-
-`add(q, x)` adds the element `x` at the end of the queue `q`.
-
-## peek
-
-```res sig
-let peek: t<'a> => option<'a>
-```
-
-`peekOpt(q)` returns the first element in queue `q`, without removing it from the queue.
-
-## peekUndefined
-
-```res sig
-let peekUndefined: t<'a> => Js.undefined<'a>
-```
-
-`peekUndefined(q)` returns `undefined` if not found.
-
-## peekExn
-
-```res sig
-let peekExn: t<'a> => 'a
-```
-
-raise an exception if `q` is empty
-
-## pop
-
-```res sig
-let pop: t<'a> => option<'a>
-```
-
-`pop(q)` removes and returns the first element in queue `q`.
-
-## popUndefined
-
-```res sig
-let popUndefined: t<'a> => Js.undefined<'a>
-```
-
-`popUndefined(q)` removes and returns the first element in queue `q`. it will return `undefined` if it is already empty.
-
-## popExn
-
-```res sig
-let popExn: t<'a> => 'a
-```
-
-`popExn(q)` raise an exception if q is empty.
-
-## copy
-
-```res sig
-let copy: t<'a> => t<'a>
-```
-
-`copy(q)` returns a fresh queue.
-
-## size
-
-```res sig
-let size: t<'a> => int
-```
-
-Returns the number of elements in a queue.
-
-## mapU
-
-```res sig
-let mapU: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-## map
-
-```res sig
-let map: (t<'a>, 'a => 'b) => t<'b>
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'a>, (. 'a) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'a>, 'a => unit) => unit
-```
-
-`forEach(q, f) applies`f`in turn to all elements of`q`, from the least recently entered to the most recently entered. The queue itself is unchanged.
-
-## reduceU
-
-```res sig
-let reduceU: (t<'a>, 'b, (. 'b, 'a) => 'b) => 'b
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'a>, 'b, ('b, 'a) => 'b) => 'b
-```
-
-`reduce(q, accu, f)` is equivalent to `List.reduce(l, accu, f)`, where `l` is the list of `q`'s elements. The queue remains unchanged.
-
-## transfer
-
-```res sig
-let transfer: (t<'a>, t<'a>) => unit
-```
-
-`transfer(q1, q2)` adds all of `q1`'s elements at the end of the queue `q2`, then clears `q1`. It is equivalent to the sequence `forEach((x) => add(x, q2), q1);`; clear `q1`, but runs in constant time.
-
-## toArray
-
-```res sig
-let toArray: t<'a> => array<'a>
-```
-
-First added will be in the beginning of the array.
diff --git a/pages/docs/manual/v9.0.0/api/belt/mutable-set-int.mdx b/pages/docs/manual/v9.0.0/api/belt/mutable-set-int.mdx
deleted file mode 100644
index f4fd5a6ce..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/mutable-set-int.mdx
+++ /dev/null
@@ -1,559 +0,0 @@
-# MutableSetInt
-
-<Intro>
-
-This module is [Belt.MutableSet](mutable-set) specialized with key type to be a `int` type.
-It is more efficient in general, the API is the same with [Belt.MutableSet](mutable-set) except its key type is fixed, and identity is not needed (using the built-in one).
-
-</Intro>
-
-## value
-
-```res prelude
-type value = int
-```
-
-The type of the set elements
-
-## t
-
-```res prelude
-type t
-```
-
-Type of the sets.
-
-## make
-
-```res sig
-let make: unit => t
-```
-
-Returns empty set.
-
-```res example
-let set = Belt.MutableSet.Int.make()
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<value> => t
-```
-
-Creates new set from array of elements.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([1, 3, 2, 4])
-
-s0->Belt.MutableSet.Int.toArray /* [1, 2, 3, 4] */
-```
-
-## fromSortedArrayUnsafe
-
-```res sig
-let fromSortedArrayUnsafe: array<value> => t
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-Returns copy of a set.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([1, 3, 2, 4])
-
-let copied = s0->Belt.MutableSet.Int.copy
-copied->Belt.MutableSet.Int.toArray /* [1, 2, 3, 4] */
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t => bool
-```
-
-Checks if set is empty.
-
-```res example
-let empty = Belt.MutableSet.Int.fromArray([])
-let notEmpty = Belt.MutableSet.Int.fromArray([1])
-
-Belt.MutableSet.Int.isEmpty(empty) /* true */
-Belt.MutableSet.Int.isEmpty(notEmpty) /* false */
-```
-
-## has
-
-```res sig
-let has: (t, value) => bool
-```
-
-Checks if element exists in set.
-
-```res example
-let set = Belt.MutableSet.Int.fromArray([1, 4, 2, 5])
-
-set->Belt.MutableSet.Int.has(3) /* false */
-set->Belt.MutableSet.Int.has(1) /* true */
-```
-
-## add
-
-```res sig
-let add: (t, value) => unit
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.MutableSet.Int.make()
-s0->Belt.MutableSet.Int.add(1)
-s0->Belt.MutableSet.Int.add(2)
-s0->Belt.MutableSet.Int.add(2)
-
-s0->Belt.MutableSet.Int.toArray /* [1, 2] */
-```
-
-## addCheck
-
-```
-let addCheck: (t, value) => bool;
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t, array<value>) => unit
-```
-
-Adds each element of array to set. Unlike [add](#add), the reference of return value might be changed even if all values in array already exist in set
-
-```res example
-let set = Belt.MutableSet.Int.make()
-
-set->Belt.MutableSet.Int.mergeMany([5, 4, 3, 2, 1])
-set->Belt.MutableSet.Int.toArray /* [1, 2, 3, 4, 5] */
-```
-
-## remove
-
-```res sig
-let remove: (t, value) => unit
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([2, 3, 1, 4, 5])
-s0->Belt.MutableSet.Int.remove(1)
-s0->Belt.MutableSet.Int.remove(3)
-s0->Belt.MutableSet.Int.remove(3)
-
-s0->Belt.MutableSet.Int.toArray /* [2,4,5] */
-```
-
-## removeCheck
-
-```res sig
-let removeCheck: (t, value) => bool
-```
-
-## removeMany
-
-```res sig
-let removeMany: (t, array<value>) => unit
-```
-
-Removes each element of array from set.
-
-```res example
-let set = Belt.MutableSet.Int.fromArray([1, 2, 3, 4])
-
-set->Belt.MutableSet.Int.removeMany([5, 4, 3, 2, 1])
-set->Belt.MutableSet.Int.toArray /* [] */
-```
-
-## union
-
-```res sig
-let union: (t, t) => t
-```
-
-Returns union of two sets.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([5, 2, 3, 5, 6])
-let s1 = Belt.MutableSet.Int.fromArray([5, 2, 3, 1, 5, 4])
-let union = Belt.MutableSet.Int.union(s0, s1)
-union->Belt.MutableSet.Int.toArray /* [1,2,3,4,5,6] */
-```
-
-## intersect
-
-```res sig
-let intersect: (t, t) => t
-```
-
-Returns intersection of two sets.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([5, 2, 3, 5, 6])
-let s1 = Belt.MutableSet.Int.fromArray([5, 2, 3, 1, 5, 4])
-let intersect = Belt.MutableSet.Int.intersect(s0, s1)
-intersect->Belt.MutableSet.Int.toArray /* [2,3,5] */
-```
-
-## diff
-
-```res sig
-let diff: (t, t) => t
-```
-
-Returns elements from first set, not existing in second set.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([5, 2, 3, 5, 6])
-let s1 = Belt.MutableSet.Int.fromArray([5, 2, 3, 1, 5, 4])
-Belt.MutableSet.Int.toArray(Belt.MutableSet.Int.diff(s0, s1)) /* [6] */
-Belt.MutableSet.Int.toArray(Belt.MutableSet.Int.diff(s1, s0)) /* [1,4] */
-```
-
-## subset
-
-```res sig
-let subset: (t, t) => bool
-```
-
-Checks if second set is subset of first set.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([5, 2, 3, 5, 6])
-let s1 = Belt.MutableSet.Int.fromArray([5, 2, 3, 1, 5, 4])
-let s2 = Belt.MutableSet.Int.intersect(s0, s1)
-Belt.MutableSet.Int.subset(s2, s0) /* true */
-Belt.MutableSet.Int.subset(s2, s1) /* true */
-Belt.MutableSet.Int.subset(s1, s0) /* false */
-```
-
-## cmp
-
-```res sig
-let cmp: (t, t) => int
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```res sig
-let eq: (t, t) => bool
-```
-
-Checks if two sets are equal.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([5, 2, 3])
-let s1 = Belt.MutableSet.Int.fromArray([3, 2, 5])
-
-Belt.MutableSet.Int.eq(s0, s1) /* true */
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t, (. value) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t, value => unit) => unit
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([5, 2, 3, 5, 6])
-let acc = ref(list{})
-s0->Belt.MutableSet.Int.forEach(x => acc := Belt.List.add(acc.contents, x))
-acc /* [6,5,3,2] */
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t, 'a, (. 'a, value) => 'a) => 'a
-```
-
-## reduce
-
-```
-let reduce: (t, 'a, ('a, value) => 'a) => 'a;
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([5, 2, 3, 5, 6])
-s0->Belt.MutableSet.Int.reduce(list{}, (acc, element) =>
-  acc->Belt.List.add(element)
-) /* [6,5,3,2] */
-```
-
-## everyU
-
-```res sig
-let everyU: (t, (. value) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t, value => bool) => bool
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.MutableSet.Int.fromArray([2, 4, 6, 8])
-s0->Belt.MutableSet.Int.every(isEven) /* true */
-```
-
-## someU
-
-```res sig
-let someU: (t, (. value) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t, value => bool) => bool
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```res example
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.MutableSet.Int.fromArray([1, 2, 4, 6, 8])
-s0->Belt.MutableSet.Int.some(isOdd) /* true */
-```
-
-## keepU
-
-```res sig
-let keepU: (t, (. value) => bool) => t
-```
-
-## keep
-
-```res sig
-let keep: (t, value => bool) => t
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.MutableSet.Int.fromArray([1, 2, 3, 4, 5])
-let s1 = s0->Belt.MutableSet.Int.keep(isEven)
-
-s1->Belt.MutableSet.Int.toArray /* [2, 4] */
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t, (. value) => bool) => (t, t)
-```
-
-## partition
-
-```res sig
-let partition: (t, value => bool) => (t, t)
-```
-
-```res example
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.MutableSet.Int.fromArray([1, 2, 3, 4, 5])
-let (s1, s2) = s0->Belt.MutableSet.Int.partition(isOdd)
-
-s1->Belt.MutableSet.Int.toArray /* [1,3,5] */
-s2->Belt.MutableSet.Int.toArray /* [2,4] */
-```
-
-## size
-
-```res sig
-let size: t => int
-```
-
-Returns size of the set.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([1, 2, 3, 4])
-
-s0->Belt.MutableSet.Int.size /* 4 */
-```
-
-## toList
-
-```res sig
-let toList: t => list<value>
-```
-
-Returns list of ordered set elements.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.MutableSet.Int.toList /* [1,2,3,5] */
-```
-
-## toArray
-
-```res sig
-let toArray: t => array<value>
-```
-
-Returns array of ordered set elements.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.MutableSet.Int.toArray /* [1,2,3,5] */
-```
-
-## minimum
-
-```res sig
-let minimum: t => option<value>
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.MutableSet.Int.make()
-let s1 = Belt.MutableSet.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.MutableSet.Int.minimum /* None */
-s1->Belt.MutableSet.Int.minimum /* Some(1) */
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t => Js.undefined<value>
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.MutableSet.Int.make()
-let s1 = Belt.MutableSet.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.MutableSet.Int.minUndefined /* undefined */
-s1->Belt.MutableSet.Int.minUndefined /* 1 */
-```
-
-## maximum
-
-```res sig
-let maximum: t => option<value>
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.MutableSet.Int.make()
-let s1 = Belt.MutableSet.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.MutableSet.Int.maximum /* None */
-s1->Belt.MutableSet.Int.maximum /* Some(5) */
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t => Js.undefined<value>
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.MutableSet.Int.make()
-let s1 = Belt.MutableSet.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.MutableSet.Int.maxUndefined /* undefined */
-s1->Belt.MutableSet.Int.maxUndefined /* 5 */
-```
-
-## get
-
-```res sig
-let get: (t, value) => option<value>
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([1, 2, 3, 4, 5])
-
-s0->Belt.MutableSet.Int.get(3) /* Some(3) */
-s0->Belt.MutableSet.Int.get(20) /* None */
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t, value) => Js.undefined<value>
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```res sig
-let getExn: (t, value) => value
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```res sig
-let split: (t, value) => ((t, t), bool)
-```
-
-Returns a tuple `((smaller, larger), present)`, `present` is true when element exist in set.
-
-```res example
-let s0 = Belt.MutableSet.Int.fromArray([1, 2, 3, 4, 5])
-
-let ((smaller, larger), present) = s0->Belt.MutableSet.Int.split(3)
-
-present /* true */
-smaller->Belt.MutableSet.Int.toArray /* [1,2] */
-larger->Belt.MutableSet.Int.toArray /* [4,5] */
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t => unit
-```
-
-**raise** when invariant is not held
diff --git a/pages/docs/manual/v9.0.0/api/belt/mutable-set-string.mdx b/pages/docs/manual/v9.0.0/api/belt/mutable-set-string.mdx
deleted file mode 100644
index 2acd4467e..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/mutable-set-string.mdx
+++ /dev/null
@@ -1,561 +0,0 @@
-# MutableSetString
-
-<Intro>
-
-This module is [Belt.MutableSet](mutable-set) specialized with key type to be a `string` type.
-It is more efficient in general, the API is the same with [Belt.MutableSet](mutable-set) except its key type is fixed, and identity is not needed (using the built-in one)
-
-</Intro>
-
-## value
-
-```res prelude
-type value = string
-```
-
-The type of the set elements.
-
-## t
-
-```res prelude
-type t
-```
-
-The type of sets.
-
-## make
-
-```res sig
-let make: unit => t
-```
-
-Returns empty set.
-
-```res example
-let set = Belt.MutableSet.String.make()
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<value> => t
-```
-
-Creates new set from array of elements.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "orange", "banana"])
-
-s0->Belt.MutableSet.String.toArray /* ["apple", "banana", "orange"] */
-```
-
-## fromSortedArrayUnsafe
-
-```res sig
-let fromSortedArrayUnsafe: array<value> => t
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-Returns copy of a set.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["orange", "apple"])
-
-let copied = s0->Belt.MutableSet.String.copy
-copied->Belt.MutableSet.String.toArray /* ["apple", "orange"] */
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t => bool
-```
-
-Checks if set is empty.
-
-```res example
-let empty = Belt.MutableSet.String.fromArray([])
-let notEmpty = Belt.MutableSet.String.fromArray(["apple"])
-
-Belt.MutableSet.String.isEmpty(empty) /* true */
-Belt.MutableSet.String.isEmpty(notEmpty) /* false */
-```
-
-## has
-
-```res sig
-let has: (t, value) => bool
-```
-
-Checks if element exists in set.
-
-```res example
-let set = Belt.MutableSet.String.fromArray(["apple", "orange", "banana"])
-
-set->Belt.MutableSet.String.has("strawberry") /* false */
-set->Belt.MutableSet.String.has("apple") /* true */
-```
-
-## add
-
-```res sig
-let add: (t, value) => unit
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.MutableSet.String.make()
-s0->Belt.MutableSet.String.add("apple")
-s0->Belt.MutableSet.String.add("banana")
-s0->Belt.MutableSet.String.add("banana")
-
-s0->Belt.MutableSet.String.toArray /* ["apple", "banana"] */
-```
-
-## addCheck
-
-```res sig
-let addCheck: (t, value) => bool
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t, array<value>) => unit
-```
-
-Adds each element of array to set.
-
-```res example
-let set = Belt.MutableSet.String.make()
-
-set->Belt.MutableSet.String.mergeMany(["apple", "banana", "orange", "strawberry"])
-set->Belt.MutableSet.String.toArray /* ["apple", "banana", "orange", "strawberry"] */
-```
-
-## remove
-
-```res sig
-let remove: (t, value) => unit
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["orange", "banana", "apple"])
-s0->Belt.MutableSet.String.remove("apple")
-s0->Belt.MutableSet.String.remove("banana")
-s0->Belt.MutableSet.String.remove("banana")
-
-s0->Belt.MutableSet.String.toArray /* ["orange"] */
-```
-
-## removeCheck
-
-```res sig
-let removeCheck: (t, value) => bool
-```
-
-## removeMany
-
-```res sig
-let removeMany: (t, array<value>) => unit
-```
-
-Removes each element of array from set.
-
-```res example
-let set = Belt.MutableSet.String.fromArray(["apple", "banana", "orange"])
-
-set->Belt.MutableSet.String.removeMany(["strawberry", "apple", "banana", "orange"])
-set->Belt.MutableSet.String.toArray /* [] */
-```
-
-## union
-
-```res sig
-let union: (t, t) => t
-```
-
-Returns union of two sets.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "banana", "orange", "carrot"])
-let s1 = Belt.MutableSet.String.fromArray(["apple", "banana", "orange", "strawberry"])
-let union = Belt.MutableSet.String.union(s0, s1)
-union->Belt.MutableSet.String.toArray /* ["apple", "banana", "carrot", "orange", "strawberry"] */
-```
-
-## intersect
-
-```res sig
-let intersect: (t, t) => t
-```
-
-Returns intersection of two sets.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "banana", "orange", "carrot"])
-let s1 = Belt.MutableSet.String.fromArray(["apple", "banana", "orange", "strawberry"])
-let intersect = Belt.MutableSet.String.intersect(s0, s1)
-intersect->Belt.MutableSet.String.toArray /* ["apple", "banana", "orange"] */
-```
-
-## diff
-
-```res sig
-let diff: (t, t) => t
-```
-
-Returns elements from first set, not existing in second set.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "banana", "orange", "carrot"])
-let s1 = Belt.MutableSet.String.fromArray(["apple", "banana", "orange", "strawberry"])
-Belt.MutableSet.String.toArray(Belt.MutableSet.String.diff(s0, s1)) /* ["carrot"] */
-Belt.MutableSet.String.toArray(Belt.MutableSet.String.diff(s1, s0)) /* ["strawberry"] */
-```
-
-## subset
-
-```res sig
-let subset: (t, t) => bool
-```
-
-Checks if second set is subset of first set.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["5", "2", "3", "5", "6"])
-let s1 = Belt.MutableSet.String.fromArray(["5", "2", "3", "1", "5", "4"])
-let s2 = Belt.MutableSet.String.intersect(s0, s1)
-Belt.MutableSet.String.subset(s2, s0) /* true */
-Belt.MutableSet.String.subset(s2, s1) /* true */
-Belt.MutableSet.String.subset(s1, s0) /* false */
-```
-
-## cmp
-
-```res sig
-let cmp: (t, t) => int
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```res sig
-let eq: (t, t) => bool
-```
-
-Checks if two sets are equal.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "orange"])
-let s1 = Belt.MutableSet.String.fromArray(["orange", "apple"])
-
-Belt.MutableSet.String.eq(s0, s1) /* true */
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t, (. value) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t, value => unit) => unit
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["banana", "orange", "apple"])
-let acc = ref(list{})
-s0->Belt.MutableSet.String.forEach(x => acc := Belt.List.add(acc.contents, x))
-acc /* ["orange", "banana", "apple"] */
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t, 'a, (. 'a, value) => 'a) => 'a
-```
-
-## reduce
-
-```res sig
-let reduce: (t, 'a, ('a, value) => 'a) => 'a
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "orange"])
-s0->Belt.MutableSet.String.reduce(0, (acc, element) => acc + String.length(element)) /* 11 */
-```
-
-## everyU
-
-```res sig
-let everyU: (t, (. value) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t, value => bool) => bool
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```res example
-let hasAtLeastFiveChars = x => String.length(x) >= 5
-
-let s0 = Belt.MutableSet.String.fromArray(["apple", "carrot"])
-s0->Belt.MutableSet.String.every(hasAtLeastFiveChars) /* true */
-```
-
-## someU
-
-```res sig
-let someU: (t, (. value) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t, value => bool) => bool
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```res example
-let hasFiveChars = x => String.length(x) == 5
-
-let s0 = Belt.MutableSet.String.fromArray(["strawberry", "apple"])
-s0->Belt.MutableSet.String.some(hasFiveChars) /* true */
-```
-
-## keepU
-
-```res sig
-let keepU: (t, (. value) => bool) => t
-```
-
-## keep
-
-```res sig
-let keep: (t, value => bool) => t
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```res example
-let hasFiveChars = x => String.length(x) == 5
-
-let s0 = Belt.MutableSet.String.fromArray(["apple", "orange", "banana"])
-let s1 = s0->Belt.MutableSet.String.keep(hasFiveChars)
-
-s1->Belt.MutableSet.String.toArray /* ["apple"] */
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t, (. value) => bool) => (t, t)
-```
-
-## partition
-
-```res sig
-let partition: (t, value => bool) => (t, t)
-```
-
-Returns a pair of sets, where first is the set of all the elements of set that satisfy the predicate, and second is the set of all the elements of set that do not satisfy the predicate.
-
-```res example
-let hasFiveChars = x => String.length(x) == 5
-
-let s0 = Belt.MutableSet.String.fromArray(["apple", "carrot"])
-let (s1, s2) = s0->Belt.MutableSet.String.partition(hasFiveChars)
-
-s1->Belt.MutableSet.String.toArray /* ["apple"] */
-s2->Belt.MutableSet.String.toArray /* ["carrot"] */
-```
-
-## size
-
-```res sig
-let size: t => int
-```
-
-Returns size of the set.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple"])
-
-s0->Belt.MutableSet.String.size /* 1 */
-```
-
-## toList
-
-```res sig
-let toList: t => list<value>
-```
-
-Returns list of ordered set elements.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "watermelon"])
-
-s0->Belt.MutableSet.String.toList /* ["apple", "watermelon"] */
-```
-
-## toArray
-
-```res sig
-let toArray: t => array<value>
-```
-
-Returns array of ordered set elements.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "watermelon"])
-
-s0->Belt.MutableSet.String.toArray /* ["apple", "watermelon"] */
-```
-
-## minimum
-
-```res sig
-let minimum: t => option<value>
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.MutableSet.String.make()
-let s1 = Belt.MutableSet.String.fromArray(["apple", "orange"])
-
-s0->Belt.MutableSet.String.minimum /* None */
-s1->Belt.MutableSet.String.minimum /* Some("apple") */
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t => Js.undefined<value>
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.MutableSet.String.make()
-let s1 = Belt.MutableSet.String.fromArray(["apple", "orange"])
-
-s0->Belt.MutableSet.String.minUndefined /* undefined */
-s1->Belt.MutableSet.String.minUndefined /* "apple" */
-```
-
-## maximum
-
-```res sig
-let maximum: t => option<value>
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.MutableSet.String.make()
-let s1 = Belt.MutableSet.String.fromArray(["apple", "orange"])
-
-s0->Belt.MutableSet.String.maximum /* None */
-s1->Belt.MutableSet.String.maximum /* Some("orange") */
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t => Js.undefined<value>
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.MutableSet.String.make()
-let s1 = Belt.MutableSet.String.fromArray(["apple", "orange"])
-
-s0->Belt.MutableSet.String.maxUndefined /* undefined */
-s1->Belt.MutableSet.String.maxUndefined /* orange */
-```
-
-## get
-
-```res sig
-let get: (t, value) => option<value>
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "carrot"])
-
-s0->Belt.MutableSet.String.get("carrot") /* Some("carrot") */
-s0->Belt.MutableSet.String.get("watermelon") /* None */
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t, value) => Js.undefined<value>
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```res sig
-let getExn: (t, value) => value
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```res sig
-let split: (t, value) => ((t, t), bool)
-```
-
-Returns a tuple `((smaller, larger), present)`, `present` is true when element exist in set.
-
-```res example
-let s0 = Belt.MutableSet.String.fromArray(["apple", "banana", "orange"])
-
-let ((smaller, larger), present) = s0->Belt.MutableSet.String.split("banana")
-
-present /* true */
-smaller->Belt.MutableSet.String.toArray /* ["apple"] */
-larger->Belt.MutableSet.String.toArray /* ["orange"] */
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t => unit
-```
-
-**raise** when invariant is not held
diff --git a/pages/docs/manual/v9.0.0/api/belt/mutable-set.mdx b/pages/docs/manual/v9.0.0/api/belt/mutable-set.mdx
deleted file mode 100644
index 371f04de0..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/mutable-set.mdx
+++ /dev/null
@@ -1,711 +0,0 @@
-# MutableSet
-
-<Intro>
-
-A **mutable** sorted set module which allows customize compare behavior.
-The implementation uses balanced binary trees, and therefore searching and insertion take time logarithmic in the size of the map.
-
-It also has three specialized inner modules [Belt.MutableSet.Int](mutable-set-int) and [Belt.MutableSet.String](mutable-set-string) - This module separates data from function which is more verbose but slightly more efficient
-
-</Intro>
-
-```res example
-module PairComparator = Belt.Id.MakeComparable({
-  type t = (int, int)
-  let cmp = ((a0, a1), (b0, b1)) =>
-    switch Pervasives.compare(a0, b0) {
-    | 0 => Pervasives.compare(a1, b1)
-    | c => c
-    }
-})
-
-let mySet = Belt.MutableSet.make(~id=module(PairComparator))
-mySet->Belt.MutableSet.add((1, 2))
-```
-
-## t
-
-```res prelude
-type t<'value, 'id>
-```
-
-`'value` is the element type
-
-`'id` the identity of the collection
-
-## id
-
-```res prelude
-type id<'value, 'id> = Belt_Id.comparable<'value, 'id>
-```
-
-The identity needed for making a set from scratch
-
-## make
-
-```res sig
-let make: (~id: id<'value, 'id>) => t<'value, 'id>
-```
-
-Creates a new set by taking in the comparator
-
-## fromArray
-
-```res sig
-let fromArray: (array<'value>, ~id: id<'value, 'id>) => t<'value, 'id>
-```
-
-Creates new set from array of elements.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([1, 3, 2, 4], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.toArray /* [1, 2, 3, 4] */
-```
-
-## fromSortedArrayUnsafe
-
-```res sig
-let fromSortedArrayUnsafe: (array<'value>, ~id: id<'value, 'id>) => t<'value, 'id>
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## copy
-
-```res sig
-let copy: t<'value, 'id> => t<'value, 'id>
-```
-
-Returns copy of a set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([1, 3, 2, 4], ~id=module(IntCmp))
-
-let copied = s0->Belt.MutableSet.copy
-copied->Belt.MutableSet.toArray /* [1, 2, 3, 4] */
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a, 'b> => bool
-```
-
-Checks if set is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let empty = Belt.MutableSet.fromArray([], ~id=module(IntCmp))
-let notEmpty = Belt.MutableSet.fromArray([1], ~id=module(IntCmp))
-
-Belt.MutableSet.isEmpty(empty) /* true */
-Belt.MutableSet.isEmpty(notEmpty) /* false */
-```
-
-## has
-
-```res sig
-let has: (t<'value, 'a>, 'value) => bool
-```
-
-Checks if element exists in set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let set = Belt.MutableSet.fromArray([1, 4, 2, 5], ~id=module(IntCmp))
-
-set->Belt.MutableSet.has(3) /* false */
-set->Belt.MutableSet.has(1) /* true */
-```
-
-## add
-
-```res sig
-let add: (t<'value, 'id>, 'value) => unit
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.make(~id=module(IntCmp))
-s0->Belt.MutableSet.add(1)
-s0->Belt.MutableSet.add(2)
-s0->Belt.MutableSet.add(2)
-
-s0->Belt.MutableSet.toArray /* [1, 2] */
-```
-
-## addCheck
-
-```res sig
-let addCheck: (t<'value, 'id>, 'value) => bool
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'value, 'id>, array<'value>) => unit
-```
-
-Adds each element of array to set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let set = Belt.MutableSet.make(~id=module(IntCmp))
-
-set->Belt.MutableSet.mergeMany([5, 4, 3, 2, 1])
-set->Belt.MutableSet.toArray /* [1, 2, 3, 4, 5] */
-```
-
-## remove
-
-```res sig
-let remove: (t<'value, 'id>, 'value) => unit
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([2, 3, 1, 4, 5], ~id=module(IntCmp))
-s0->Belt.MutableSet.remove(1)
-s0->Belt.MutableSet.remove(3)
-s0->Belt.MutableSet.remove(3)
-
-s0->Belt.MutableSet.toArray /* [2,4,5] */
-```
-
-## removeCheck
-
-```res sig
-let removeCheck: (t<'value, 'id>, 'value) => bool
-```
-
-## removeMany
-
-```res sig
-let removeMany: (t<'value, 'id>, array<'value>) => unit
-```
-
-Removes each element of array from set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let set = Belt.MutableSet.fromArray([1, 2, 3, 4], ~id=module(IntCmp))
-
-set->Belt.MutableSet.removeMany([5, 4, 3, 2, 1])
-set->Belt.MutableSet.toArray /* [] */
-```
-
-## union
-
-```res sig
-let union: (t<'value, 'id>, t<'value, 'id>) => t<'value, 'id>
-```
-
-Returns union of two sets.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([5, 2, 3, 5, 6], ~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([5, 2, 3, 1, 5, 4], ~id=module(IntCmp))
-let union = Belt.MutableSet.union(s0, s1)
-union->Belt.MutableSet.toArray /* [1,2,3,4,5,6] */
-```
-
-## intersect
-
-```res sig
-let intersect: (t<'value, 'id>, t<'value, 'id>) => t<'value, 'id>
-```
-
-Returns intersection of two sets.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([5, 2, 3, 5, 6], ~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([5, 2, 3, 1, 5, 4], ~id=module(IntCmp))
-let intersect = Belt.MutableSet.intersect(s0, s1)
-intersect->Belt.MutableSet.toArray /* [2,3,5] */
-```
-
-## diff
-
-```res sig
-let diff: (t<'value, 'id>, t<'value, 'id>) => t<'value, 'id>
-```
-
-Returns elements from first set, not existing in second set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([5, 2, 3, 5, 6], ~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([5, 2, 3, 1, 5, 4], ~id=module(IntCmp))
-Belt.MutableSet.toArray(Belt.MutableSet.diff(s0, s1)) /* [6] */
-Belt.MutableSet.toArray(Belt.MutableSet.diff(s1, s0)) /* [1,4] */
-```
-
-## subset
-
-```res sig
-let subset: (t<'value, 'id>, t<'value, 'id>) => bool
-```
-
-Checks if second set is subset of first set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([5, 2, 3, 5, 6], ~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([5, 2, 3, 1, 5, 4], ~id=module(IntCmp))
-let s2 = Belt.MutableSet.intersect(s0, s1)
-Belt.MutableSet.subset(s2, s0) /* true */
-Belt.MutableSet.subset(s2, s1) /* true */
-Belt.MutableSet.subset(s1, s0) /* false */
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'value, 'id>, t<'value, 'id>) => int
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```res sig
-let eq: (t<'value, 'id>, t<'value, 'id>) => bool
-```
-
-Checks if two sets are equal.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([5, 2, 3], ~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([3, 2, 5], ~id=module(IntCmp))
-
-Belt.MutableSet.eq(s0, s1) /* true */
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'value, 'id>, (. 'value) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t<'value, 'id>, 'value => unit) => unit
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([5, 2, 3, 5, 6], ~id=module(IntCmp))
-let acc = ref(list{})
-s0->Belt.MutableSet.forEach(x => acc := Belt.List.add(acc.contents, x))
-acc /* [6,5,3,2] */
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t<'value, 'id>, 'a, (. 'a, 'value) => 'a) => 'a
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'value, 'id>, 'a, ('a, 'value) => 'a) => 'a
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([5, 2, 3, 5, 6], ~id=module(IntCmp))
-s0->Belt.MutableSet.reduce(list{}, (acc, element) => acc->Belt.List.add(element)) /* [6,5,3,2] */
-```
-
-## everyU
-
-```res sig
-let everyU: (t<'value, 'id>, (. 'value) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'value, 'id>, 'value => bool) => bool
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.MutableSet.fromArray([2, 4, 6, 8], ~id=module(IntCmp))
-s0->Belt.MutableSet.every(isEven) /* true */
-```
-
-## someU
-
-```res sig
-let someU: (t<'value, 'id>, (. 'value) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'value, 'id>, 'value => bool) => bool
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.MutableSet.fromArray([1, 2, 4, 6, 8], ~id=module(IntCmp))
-s0->Belt.MutableSet.some(isOdd) /* true */
-```
-
-## keepU
-
-```res sig
-let keepU: (t<'value, 'id>, (. 'value) => bool) => t<'value, 'id>
-```
-
-## keep
-
-```res sig
-let keep: (t<'value, 'id>, 'value => bool) => t<'value, 'id>
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.MutableSet.fromArray([1, 2, 3, 4, 5], ~id=module(IntCmp))
-let s1 = s0->Belt.MutableSet.keep(isEven)
-
-s1->Belt.MutableSet.toArray /* [2, 4] */
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t<'value, 'id>, (. 'value) => bool) => (t<'value, 'id>, t<'value, 'id>)
-```
-
-## partition
-
-```res sig
-let partition: (t<'value, 'id>, 'value => bool) => (t<'value, 'id>, t<'value, 'id>)
-```
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.MutableSet.fromArray([1, 2, 3, 4, 5], ~id=module(IntCmp))
-let (s1, s2) = s0->Belt.MutableSet.partition(isOdd)
-
-s1->Belt.MutableSet.toArray /* [1,3,5] */
-s2->Belt.MutableSet.toArray /* [2,4] */
-```
-
-## size
-
-```res sig
-let size: t<'value, 'id> => int
-```
-
-Returns size of the set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([1, 2, 3, 4], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.size /* 4 */
-```
-
-## toList
-
-```res sig
-let toList: t<'value, 'id> => list<'value>
-```
-
-Returns list of ordered set elements.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([3, 2, 1, 5], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.toList /* [1,2,3,5] */
-```
-
-## toArray
-
-```res sig
-let toArray: t<'value, 'id> => array<'value>
-```
-
-Returns array of ordered set elements.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([3, 2, 1, 5], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.toArray /* [1,2,3,5] */
-```
-
-## minimum
-
-```res sig
-let minimum: t<'value, 'id> => option<'value>
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.make(~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([3, 2, 1, 5], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.minimum /* None */
-s1->Belt.MutableSet.minimum /* Some(1) */
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'value, 'id> => Js.undefined<'value>
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.make(~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([3, 2, 1, 5], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.minUndefined /* undefined */
-s1->Belt.MutableSet.minUndefined /* 1 */
-```
-
-## maximum
-
-```res sig
-let maximum: t<'value, 'id> => option<'value>
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.make(~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([3, 2, 1, 5], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.maximum /* None */
-s1->Belt.MutableSet.maximum /* Some(5) */
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'value, 'id> => Js.undefined<'value>
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.make(~id=module(IntCmp))
-let s1 = Belt.MutableSet.fromArray([3, 2, 1, 5], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.maxUndefined /* undefined */
-s1->Belt.MutableSet.maxUndefined /* 5 */
-```
-
-## get
-
-```res sig
-let get: (t<'value, 'id>, 'value) => option<'value>
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([1, 2, 3, 4, 5], ~id=module(IntCmp))
-
-s0->Belt.MutableSet.get(3) /* Some(3) */
-s0->Belt.MutableSet.get(20) /* None */
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'value, 'id>, 'value) => Js.undefined<'value>
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```res sig
-let getExn: (t<'value, 'id>, 'value) => 'value
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```res sig
-let split: (t<'value, 'id>, 'value) => ((t<'value, 'id>, t<'value, 'id>), bool)
-```
-
-Returns a tuple `((smaller, larger), present)`, `present` is true when element exist in set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.MutableSet.fromArray([1, 2, 3, 4, 5], ~id=module(IntCmp))
-
-let ((smaller, larger), present) = s0->Belt.MutableSet.split(3)
-
-present /* true */
-smaller->Belt.MutableSet.toArray /* [1,2] */
-larger->Belt.MutableSet.toArray /* [4,5] */
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t<'a, 'b> => unit
-```
-
-**raise** when invariant is not held
diff --git a/pages/docs/manual/v9.0.0/api/belt/mutable-stack.mdx b/pages/docs/manual/v9.0.0/api/belt/mutable-stack.mdx
deleted file mode 100644
index d8c51f494..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/mutable-stack.mdx
+++ /dev/null
@@ -1,105 +0,0 @@
-# MutableStack
-
-<Intro>
-
-First in last out stack. This module implements stacks, with in-place modification.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a>
-```
-
-## make
-
-```res sig
-let make: unit => t<'a>
-```
-
-Returns a new stack, initially empty.
-
-## clear
-
-```res sig
-let clear: t<'a> => unit
-```
-
-Discard all elements from the stack.
-
-## copy
-
-```res sig
-let copy: t<'a> => t<'a>
-```
-
-`copy(x)` O(1) operation, return a new stack.
-
-## push
-
-```res sig
-let push: (t<'a>, 'a) => unit
-```
-
-## popUndefined
-
-```res sig
-let popUndefined: t<'a> => Js.undefined<'a>
-```
-
-## pop
-
-```res sig
-let pop: t<'a> => option<'a>
-```
-
-## topUndefined
-
-```res sig
-let topUndefined: t<'a> => Js.undefined<'a>
-```
-
-## top
-
-```res sig
-let top: t<'a> => option<'a>
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a> => bool
-```
-
-## size
-
-```res sig
-let size: t<'a> => int
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'a>, (. 'a) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'a>, 'a => unit) => unit
-```
-
-## dynamicPopIterU
-
-```res sig
-let dynamicPopIterU: (t<'a>, (. 'a) => unit) => unit
-```
-
-## dynamicPopIter
-
-```res sig
-let dynamicPopIter: (t<'a>, 'a => unit) => unit
-```
-
-`dynamicPopIter(s, f)` apply `f` to each element of `s`. The item is poped before applying `f`, `s` will be empty after this opeartion. This function is useful for worklist algorithm.
diff --git a/pages/docs/manual/v9.0.0/api/belt/option.mdx b/pages/docs/manual/v9.0.0/api/belt/option.mdx
deleted file mode 100644
index 4e80c7b89..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/option.mdx
+++ /dev/null
@@ -1,256 +0,0 @@
-# Option
-
-<Intro>
-
-In Belt we represent the existence and nonexistence of a value by wrapping it
-with the `option` type.  In order to make it a bit more convenient to work with
-option-types, Belt provides utility-functions for it.
-
-The `option` type is a part of the Reason / OCaml standard library which is defined like this:
-
-</Intro>
-
-```res sig
-type option<'a> = None | Some('a)
-```
-
-```res example
-let someString: option<string> = Some("hello")
-```
-
-## getExn
-
-```res sig
-let getExn: option<'a> => 'a
-```
-
-Raises an Error in case `None` is provided. Use with care.
-
-```res example
-Belt.Option.getExn(Some(3)) /* 3 */
-
-Belt.Option.getExn(None) /* Raises an Error */
-```
-
-## mapWithDefault
-
-```res sig
-let mapWithDefault: (option<'a>, 'b, 'a => 'b) => 'b
-```
-
-If `optionValue` is of `Some(value)`,
-this function returns that value applied with `f`, in other words `f(value)`.
-
-If `optionValue` is `None`, the default is returned.
-
-```res example
-let someValue = Some(3)
-someValue->Belt.Option.mapWithDefault(0, x => x + 5) /* 8 */
-
-let noneValue = None
-noneValue->Belt.Option.mapWithDefault(0, x => x + 5) /* 0 */
-```
-
-## mapWithDefaultU
-
-```res sig
-let mapWithDefaultU: (option<'a>, 'b, (. 'a) => 'b) => 'b
-```
-
-Uncurried version of [mapWithDefault](#mapWithDefault).
-
-## map
-
-```res sig
-let map: (option<'a>, 'a => 'b) => option<'b>
-```
-
-If `optionValue` is `Some(value)` this returns `f(value)`, otherwise it returns `None`.
-
-```res example
-Belt.Option.map(Some(3), x => x * x) /* Some(9) */
-
-Belt.Option.map(None, x => x * x) /* None */
-```
-
-## mapU
-
-```res sig
-let mapU: (option<'a>, (. 'a) => 'b) => option<'b>
-```
-
-Uncurried version of [map](#map).
-
-## flatMap
-
-```res sig
-let flatMap: (option<'a>, 'a => option<'b>) => option<'b>
-```
-
-If `optionValue` is `Some(value)`, returns `f(value)`, otherwise returns
-`None`.<br/>
-The function `f` must have a return type of `option<'b>`.
-
-```res example
-let addIfAboveOne = value =>
-  if (value > 1) {
-    Some(value + 1)
-  } else {
-    None
-  }
-
-Belt.Option.flatMap(Some(2), addIfAboveOne) /* Some(3) */
-
-Belt.Option.flatMap(Some(-4), addIfAboveOne) /* None */
-
-Belt.Option.flatMap(None, addIfAboveOne) /* None */
-```
-
-## flatMapU
-
-```res sig
-let flatMapU: (option<'a>, (. 'a) => option<'b>) => option<'b>
-```
-
-Uncurried version of flatMap.
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (option<'a>, 'a) => 'a
-```
-
-If `optionalValue` is `Some(value)`, returns `value`, otherwise default.
-
-```res example
-Belt.Option.getWithDefault(None, "Banana") /* Banana */
-
-Belt.Option.getWithDefault(Some("Apple"), "Banana") /* Apple */
-```
-
-```res example
-let greet = (firstName: option<string>) =>
-  "Greetings " ++ firstName->Belt.Option.getWithDefault("Anonymous")
-
-Some("Jane")->greet /* "Greetings Jane" */
-
-None->greet /* "Greetings Anonymous" */
-```
-
-```res example
-Belt.Option.getWithDefault(Some(1812), 1066) /* 1812 */
-
-Belt.Option.getWithDefault(None, 1066) /* 1066 */
-```
-
-## isSome
-
-```res sig
-let isSome: option<'a> => bool
-```
-
-Returns `true` if the argument is `Some(value)`, `false` otherwise.
-
-```res example
-Belt.Option.isSome(None) /* false */
-
-Belt.Option.isSome(Some(1)) /* true */
-```
-
-## isNone
-
-```res sig
-let isNone: option<'a> => bool
-```
-
-Returns `true` if the argument is `None`, `false` otherwise.
-
-```res example
-Belt.Option.isNone(None) /* true */
-
-Belt.Option.isNone(Some(1)) /* false */
-```
-
-## eq
-
-```res sig
-let eq: (option<'a>, option<'b>, ('a, 'b) => bool) => bool
-```
-
-Evaluates two optional values for equality with respect to a predicate
-function. If both `optValue1` and `optValue2` are `None`, returns `true`.
-If one of the arguments is `Some(value)` and the other is `None`, returns
-`false`.
-
-If arguments are `Some(value1)` and `Some(value2)`, returns the result of
-`predicate(value1, value2)`; the predicate function must return a bool.
-
-```res example
-let clockEqual = (a, b) => mod(a, 12) == mod(b, 12)
-
-open Belt.Option
-
-eq(Some(3), Some(15), clockEqual) /* true */
-
-eq(Some(3), None, clockEqual) /* false */
-
-eq(None, Some(3), clockEqual) /* false */
-
-eq(None, None, clockEqual) /* true */
-```
-
-## eqU
-
-```res sig
-let eqU: (option<'a>, option<'b>, (.'a, 'b) => bool) => bool
-```
-
-Uncurried version of [eq](#eq).
-
-## cmp
-
-```res sig
-let cmp: (option<'a>, option<'b>, ('a, 'b) => int) => int
-```
-
-`cmp(optValue1, optValue2, comparisonFunction)` compares two optional values
-with respect to given `comparisonFunction`.
-
-If both `optValue1` and `optValue2` are `None`, it returns `0`.
-
-If the first argument is `Some(value1)` and the second is `None`, returns `1`
-(something is greater than nothing).
-
-If the first argument is `None` and the second is `Some(value2)`, returns `-1`
-(nothing is less than something).
-
-If the arguments are `Some(value1)` and `Some(value2)`, returns the result of
-`comparisonFunction(value1, value2)`; comparisonFunction takes two arguments
-and returns `-1` if the first argument is less than the second, `0` if the
-arguments are equal, and `1` if the first argument is greater than the second.
-
-```res example
-let clockCompare = (a, b) => compare(mod(a, 12), mod(b, 12))
-
-open Belt.Option
-
-cmp(Some(3), Some(15), clockCompare) /* 0 */
-
-cmp(Some(3), Some(14), clockCompare) /* 1 */
-
-cmp(Some(2), Some(15), clockCompare) /* (-1) */
-
-cmp(None, Some(15), clockCompare) /* (-1) */
-
-cmp(Some(14), None, clockCompare) /* 1 */
-
-cmp(None, None, clockCompare) /* 0 */
-```
-
-## cmpU
-
-```res sig
-let cmpU: (option<'a>, option<'b>, ((.'a, 'b) => int)) => int
-```
-
-Uncurried version of [cmp](#cmp).
diff --git a/pages/docs/manual/v9.0.0/api/belt/range.mdx b/pages/docs/manual/v9.0.0/api/belt/range.mdx
deleted file mode 100644
index 983789986..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/range.mdx
+++ /dev/null
@@ -1,130 +0,0 @@
-# Range
-
-<Intro>
-
-A small utility module to provide inclusive range operations for `[start,
-finish]`.  Internally it is relying on loops instead of creating new arrays,
-which makes it pretty performant and memory friendly.
-
-</Intro>
-
-## forEachU
-
-```res sig
-let forEachU: (int, int, (. int) => unit) => unit
-```
-
-## forEach
-
-```res sig
-let forEach: (int, int, int => unit) => unit
-```
-
-`forEach(start, finish, action)`
-
-equivalent to `Belt.Array.(forEach(range(start, finish), action))`
-
-```res example
-Belt.Range.forEach(0, 4, (i) => Js.log(i))
-
-/**
- * prints:
- *   0
- *   1
- *   2
- *   3
- *   4
- */
-```
-
-## everyU
-
-```res sig
-let everyU: (int, int, (. int) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (int, int, int => bool) => bool
-```
-
-`every(start, finish, p)`
-
-equivalent to `Belt.Array.(every(range(start, finish), p))`
-
-```res example
-Belt.Range.every(0, 4, (i) => i < 5) /* true */
-
-Belt.Range.every(0, 4, (i) => i < 4) /* false */
-```
-
-## everyByU
-
-```res sig
-let everyByU: (int, int, ~step: int, (. int) => bool) => bool
-```
-
-## everyBy
-
-```res sig
-let everyBy: (int, int, ~step: int, int => bool) => bool
-```
-
-`everyBy(start, finish, ~step, p)`
-
-See `Belt_Array.rangeBy`
-
-equivalent to `Belt.Array.(every(rangeBy(start, finish, ~step), p))`
-
-```res example
-Belt.Range.everyBy(0, 4, ~step=1, (i) => mod(i, 2) === 0) /* false */
-
-Belt.Range.everyBy(0, 4, ~step=2, (i) => mod(i, 2) === 0) /* true */
-```
-
-## someU
-
-```res sig
-let someU: (int, int, (. int) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (int, int, int => bool) => bool
-```
-
-`some(start, finish, p)`
-
-equivalent to `Belt.Array.(some(range(start, finish), p))`
-
-```res example
-Belt.Range.some(0, 4, (i) => i > 5) /* false */
-
-Belt.Range.some(0, 4, (i) => i > 2) /* true */
-```
-
-## someByU
-
-```res sig
-let someByU: (int, int, ~step: int, (. int) => bool) => bool
-```
-
-## someBy
-
-```res sig
-let someBy: (int, int, ~step: int, int => bool) => bool
-```
-
-`someBy(start, finish, ~step, p)`
-
-See `Belt_Array.rangeBy`
-
-equivalent to `Belt.Array.(some(rangeBy(start, finish, ~step), p))`
-
-```res example
-Belt.Range.someBy(1, 5, ~step=2, (i) => mod(i, 2) === 0) /* false */
-
-Belt.Range.someBy(0, 4, ~step=2, (i) => mod(i, 2) === 0) /* true */
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/result.mdx b/pages/docs/manual/v9.0.0/api/belt/result.mdx
deleted file mode 100644
index b2d12472b..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/result.mdx
+++ /dev/null
@@ -1,242 +0,0 @@
-# Result
-
-<Intro>
-
-Result types are really useful to describe the result of a certain operation
-without relying on exceptions or `option` types.
-
-This module gives you useful utilities to create and combine `Result` data.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a, 'b> =
-  | Ok('a)
-  | Error('b)
-```
-
-The type `Result.t(result, err)` describes a variant of two states:
-`Ok(someResult)` represents a successful operation, whereby
-``Error(someError)` signals an erronous operation.
-
-In this concrete example, we are defining our own `Result` type to reflect an HTTP like
-query operation:
-
-```res example
-type responseError = NotAvailable | NotFound
-type queryResult = t<string, responseError>
-
-let failQueryUser = (username: string): queryResult => {
-  Error(NotAvailable)
-}
-```
-
-## getExn
-
-```res sig
-let getExn: t<'a, 'b> => 'a
-```
-
-`getExn(res)`: when `res` is `Ok(n)`, returns `n` when `res` is `Error(m)`, raise an exception
-
-```res example
-Belt.Result.getExn(Belt.Result.Ok(42)) == 42
-
-Belt.Result.getExn(Belt.Result.Error("Invalid data")) /* raises exception */
-```
-
-## mapWithDefaultU
-
-```res sig
-let mapWithDefaultU: (t<'a, 'c>, 'b, (. 'a) => 'b) => 'b
-```
-
-## mapWithDefault
-
-```res sig
-let mapWithDefault: (t<'a, 'c>, 'b, 'a => 'b) => 'b
-```
-
-`mapWithDefault(res, default, f)`: When res is `Ok(n)`, returns `f(n)`,
-otherwise `default`.
-
-```res example
-let ok = Belt.Result.Ok(42)
-Belt.Result.mapWithDefault(ok, 0, (x) => x / 2) == 21
-
-let error = Belt.Result.Error("Invalid data")
-Belt.Result.mapWithDefault(error, 0, (x) => x / 2) == 0
-```
-
-## mapU
-
-```res sig
-let mapU: (t<'a, 'c>, (. 'a) => 'b) => t<'b, 'c>
-```
-
-## map
-
-```res sig
-let map: (t<'a, 'c>, 'a => 'b) => t<'b, 'c>
-```
-
-`map(res, f)`: When res is `Ok(n)`, returns `Ok(f(n))`. Otherwise returns res
-unchanged. Function `f` takes a value of the same type as `n` and returns an
-ordinary value.
-
-```res example
-let f = (x) => sqrt(Belt.Int.toFloat(x))
-
-Belt.Result.map(Ok(64), f) == Ok(8.0)
-
-Belt.Result.map(Error("Invalid data"), f) == Error("Invalid data")
-```
-
-## flatMapU
-
-```res sig
-let flatMapU: (t<'a, 'c>, (. 'a) => t<'b, 'c>) => t<'b, 'c>
-```
-
-## flatMap
-
-```res sig
-let flatMap: (t<'a, 'c>, 'a => t<'b, 'c>) => t<'b, 'c>
-```
-
-`flatMap(res, f)`: When res is `Ok(n)`, returns `f(n)`. Otherwise, returns res
-unchanged. Function `f` takes a value of the same type as `n` and returns a
-`Belt.Result`.
-
-```res example
-let recip = (x) =>
-  if (x !== 0.0) {
-    Belt.Result.Ok(1.0 /. x)
-  } else {
-    Belt.Result.Error("Divide by zero")
-  }
-
-Belt.Result.flatMap(Ok(2.0), recip) == Ok(0.5)
-
-Belt.Result.flatMap(Ok(0.0), recip) == Error("Divide by zero")
-
-Belt.Result.flatMap(Error("Already bad"), recip) == Error("Already bad")
-```
-
-## getWithDefault
-
-```res sig
-let getWithDefault: (t<'a, 'b>, 'a) => 'a
-```
-
-`getWithDefault(res, defaultValue)`: If `res` is `Ok(n)`, returns `n`,
-otherwise `default`
-
-```res example
-Belt.Result.getWithDefault(Ok(42), 0) == 42
-
-Belt.Result.getWithDefault(Error("Invalid Data"), 0) == 0
-```
-
-## isOk
-
-```res sig
-let isOk: t<'a, 'b> => bool
-```
-
-`isOk(res)`: Returns `true` if `res` is of the form `Ok(n)`, `false` if it is
-the `Error(e)` variant.
-
-## isError
-
-```res sig
-let isError: t<'a, 'b> => bool
-```
-
-`isError(res)`: Returns `true` if `res` is of the form `Error(e)`, `false` if
-it is the `Ok(n)` variant.
-
-## eqU
-
-```res sig
-let eqU: (t<'a, 'c>, t<'b, 'd>, (. 'a, 'b) => bool) => bool
-```
-
-## eq
-
-```res sig
-let eq: (t<'a, 'c>, t<'b, 'd>, ('a, 'b) => bool) => bool
-```
-
-`eq(res1, res2, f)`: Determine if two `Belt.Result` variables are equal with
-respect to an equality function. If `res1` and `res2` are of the form `Ok(n)`
-and `Ok(m)`, return the result of `f(n, m)`. If one of `res1` and `res2` are of
-the form `Error(e)`, return false If both `res1` and `res2` are of the form
-`Error(e)`, return true
-
-```res example
-let good1 = Belt.Result.Ok(42)
-
-let good2 = Belt.Result.Ok(32)
-
-let bad1 = Belt.Result.Error("invalid")
-
-let bad2 = Belt.Result.Error("really invalid")
-
-let mod10equal = (a, b) => mod(a, 10) === mod(b, 10)
-
-Belt.Result.eq(good1, good2, mod10equal) == true
-
-Belt.Result.eq(good1, bad1, mod10equal) == false
-
-Belt.Result.eq(bad2, good2, mod10equal) == false
-
-Belt.Result.eq(bad1, bad2, mod10equal) == true
-```
-
-## cmpU
-
-```res sig
-let cmpU: (t<'a, 'c>, t<'b, 'd>, (. 'a, 'b) => int) => int
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'a, 'c>, t<'b, 'd>, ('a, 'b) => int) => int
-```
-
-`cmp(res1, res2, f)`: Compare two `Belt.Result` variables with respect to a
-comparison function. The comparison function returns -1 if the first variable
-is "less than" the second, 0 if the two variables are equal, and 1 if the first
-is "greater than" the second.
-
-If `res1` and `res2` are of the form `Ok(n)` and `Ok(m)`, return the result of
-`f(n, m)`. If `res1` is of the form `Error(e)` and `res2` of the form `Ok(n)`,
-return -1 (nothing is less than something) If `res1` is of the form `Ok(n)` and
-`res2` of the form `Error(e)`, return 1 (something is greater than nothing) If
-both `res1` and `res2` are of the form `Error(e)`, return 0 (equal)
-
-```res example
-let good1 = Belt.Result.Ok(59)
-
-let good2 = Belt.Result.Ok(37)
-
-let bad1 = Belt.Result.Error("invalid")
-
-let bad2 = Belt.Result.Error("really invalid")
-
-let mod10cmp = (a, b) => Pervasives.compare(mod(a, 10), mod(b, 10))
-
-Belt.Result.cmp(Ok(39), Ok(57), mod10cmp) == 1
-
-Belt.Result.cmp(Ok(57), Ok(39), mod10cmp) == (-1)
-
-Belt.Result.cmp(Ok(39), Error("y"), mod10cmp) == 1
-
-Belt.Result.cmp(Error("x"), Ok(57), mod10cmp) == (-1)
-
-Belt.Result.cmp(Error("x"), Error("y"), mod10cmp) == 0
-```
diff --git a/pages/docs/manual/v9.0.0/api/belt/set-dict.mdx b/pages/docs/manual/v9.0.0/api/belt/set-dict.mdx
deleted file mode 100644
index 19ac4be4b..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/set-dict.mdx
+++ /dev/null
@@ -1,680 +0,0 @@
-# SetDict
-
-<Intro>
-
-This module separates identity from data, it is a bit more verbose but slightly more efficient due to the fact that there is no need to pack identity and data back after each operation
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'value, 'identity>
-```
-
-`'value` is the element type
-
-`'identity` the identity of the collection
-
-## cmp
-
-```res prelude
-type cmp<'value, 'id> = Belt.Id.cmp<'value, 'id>
-```
-
-Type of compare function.
-
-## empty
-
-```res sig
-let empty: t<'value, 'id>
-```
-
-```res example
-let s0 = Belt.Set.Dict.empty
-```
-
-## fromArray
-
-```res sig
-let fromArray: (array<'value>, ~cmp: cmp<'value, 'id>) => t<'value, 'id>
-```
-
-Creates new set from array of elements.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([1, 3, 2, 4], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.toArray /* [1, 2, 3, 4] */
-```
-
-## fromSortedArrayUnsafe
-
-```res sig
-let fromSortedArrayUnsafe: array<'value> => t<'value, 'id>
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a, 'b> => bool
-```
-
-Checks if set is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let empty = Belt.Set.Dict.fromArray([], ~cmp=IntCmp.cmp)
-let notEmpty = Belt.Set.Dict.fromArray([1], ~cmp=IntCmp.cmp)
-
-Belt.Set.Dict.isEmpty(empty) /* true */
-Belt.Set.Dict.isEmpty(notEmpty) /* false */
-```
-
-## has
-
-```res sig
-let has: (t<'value, 'id>, 'value, ~cmp: cmp<'value, 'id>) => bool
-```
-
-Checks if element exists in set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let set = Belt.Set.Dict.fromArray([1, 4, 2, 5], ~cmp=IntCmp.cmp)
-
-set->Belt.Set.Dict.has(3) /* false */
-set->Belt.Set.Dict.has(1) /* true */
-```
-
-## add
-
-```res sig
-let add: (t<'value, 'id>, 'value, ~cmp: cmp<'value, 'id>) => t<'value, 'id>
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.empty
-let s1 = s0->Belt.Set.Dict.add(1, ~cmp=IntCmp.cmp)
-let s2 = s1->Belt.Set.Dict.add(2, ~cmp=IntCmp.cmp)
-let s3 = s2->Belt.Set.Dict.add(2, ~cmp=IntCmp.cmp)
-s0->Belt.Set.Dict.toArray /* [] */
-s1->Belt.Set.Dict.toArray /* [1] */
-s2->Belt.Set.Dict.toArray /* [1, 2] */
-s3->Belt.Set.Dict.toArray /* [1,2 ] */
-s2 == s3 /* true */
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'value, 'id>, array<'value>, ~cmp: cmp<'value, 'id>) => t<'value, 'id>
-```
-
-Adds each element of array to set. Unlike [add](#add), the reference of return value might be changed even if all values in array already exist in set
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let set = Belt.Set.Dict.empty
-
-let newSet = set->Belt.Set.Dict.mergeMany([5, 4, 3, 2, 1], ~cmp=IntCmp.cmp)
-newSet->Belt.Set.Dict.toArray /* [1, 2, 3, 4, 5] */
-```
-
-## remove
-
-```res sig
-let remove: (t<'value, 'id>, 'value, ~cmp: cmp<'value, 'id>) => t<'value, 'id>
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([2, 3, 1, 4, 5], ~cmp=IntCmp.cmp)
-let s1 = s0->Belt.Set.Dict.remove(1, ~cmp=IntCmp.cmp)
-let s2 = s1->Belt.Set.Dict.remove(3, ~cmp=IntCmp.cmp)
-let s3 = s2->Belt.Set.Dict.remove(3, ~cmp=IntCmp.cmp)
-
-s1->Belt.Set.Dict.toArray /* [2,3,4,5] */
-s2->Belt.Set.Dict.toArray /* [2,4,5] */
-s2 == s3 /* true */
-```
-
-## removeMany
-
-```res sig
-let removeMany: (t<'value, 'id>, array<'value>, ~cmp: cmp<'value, 'id>) => t<'value, 'id>
-```
-
-Removes each element of array from set. Unlike [remove](#remove), the reference of return value might be changed even if any values in array not existed in set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let set = Belt.Set.Dict.fromArray([1, 2, 3, 4], ~cmp=IntCmp.cmp)
-
-let newSet = set->Belt.Set.Dict.removeMany([5, 4, 3, 2, 1], ~cmp=IntCmp.cmp)
-newSet->Belt.Set.Dict.toArray /* [] */
-```
-
-## union
-
-```res sig
-let union: (t<'value, 'id>, t<'value, 'id>, ~cmp: cmp<'value, 'id>) => t<'value, 'id>
-```
-
-Returns union of two sets.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([5, 2, 3, 5, 6], ~cmp=IntCmp.cmp)
-let s1 = Belt.Set.Dict.fromArray([5, 2, 3, 1, 5, 4], ~cmp=IntCmp.cmp)
-let union = Belt.Set.Dict.union(s0, s1, ~cmp=IntCmp.cmp)
-union->Belt.Set.Dict.toArray /* [1,2,3,4,5,6] */
-```
-
-## intersect
-
-```res sig
-let intersect: (t<'value, 'id>, t<'value, 'id>, ~cmp: cmp<'value, 'id>) => t<'value, 'id>
-```
-
-Returns intersection of two sets.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([5, 2, 3, 5, 6], ~cmp=IntCmp.cmp)
-let s1 = Belt.Set.Dict.fromArray([5, 2, 3, 1, 5, 4], ~cmp=IntCmp.cmp)
-let intersect = Belt.Set.Dict.intersect(s0, s1, ~cmp=IntCmp.cmp)
-intersect->Belt.Set.Dict.toArray /* [2,3,5] */
-```
-
-## diff
-
-```res sig
-let diff: (t<'value, 'id>, t<'value, 'id>, ~cmp: cmp<'value, 'id>) => t<'value, 'id>
-```
-
-Returns elements from first set, not existing in second set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([5, 2, 3, 5, 6], ~cmp=IntCmp.cmp)
-let s1 = Belt.Set.Dict.fromArray([5, 2, 3, 1, 5, 4], ~cmp=IntCmp.cmp)
-
-let diff1 = Belt.Set.Dict.diff(s0, s1, ~cmp=IntCmp.cmp)
-let diff2 = Belt.Set.Dict.diff(s1, s0, ~cmp=IntCmp.cmp)
-
-diff1->Belt.Set.Dict.toArray /* [6] */
-diff2->Belt.Set.Dict.toArray /* [1,4] */
-```
-
-## subset
-
-```res sig
-let subset: (t<'value, 'id>, t<'value, 'id>, ~cmp: cmp<'value, 'id>) => bool
-```
-
-Checks if second set is subset of first set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([5, 2, 3, 5, 6], ~cmp=IntCmp.cmp)
-let s1 = Belt.Set.Dict.fromArray([5, 2, 3, 1, 5, 4], ~cmp=IntCmp.cmp)
-let s2 = Belt.Set.Dict.intersect(s0, s1, ~cmp=IntCmp.cmp)
-Belt.Set.Dict.subset(s2, s0, ~cmp=IntCmp.cmp) /* true */
-Belt.Set.Dict.subset(s2, s1, ~cmp=IntCmp.cmp) /* true */
-Belt.Set.Dict.subset(s1, s0, ~cmp=IntCmp.cmp) /* false */
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'value, 'id>, t<'value, 'id>, ~cmp: cmp<'value, 'id>) => int
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```res sig
-let eq: (t<'value, 'id>, t<'value, 'id>, ~cmp: cmp<'value, 'id>) => bool
-```
-
-Checks if two sets are equal.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([5, 2, 3], ~cmp=IntCmp.cmp)
-let s1 = Belt.Set.Dict.fromArray([3, 2, 5], ~cmp=IntCmp.cmp)
-
-Belt.Set.Dict.eq(s0, s1, ~cmp=IntCmp.cmp) /* true */
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'value, 'id>, (. 'value) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t<'value, 'id>, 'value => unit) => unit
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([5, 2, 3, 5, 6], ~cmp=IntCmp.cmp)
-let acc = ref(list{})
-s0->Belt.Set.Dict.forEach(x => acc := Belt.List.add(acc.contents, x))
-acc /* [6,5,3,2] */
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t<'value, 'id>, 'a, (. 'a, 'value) => 'a) => 'a
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'value, 'id>, 'a, ('a, 'value) => 'a) => 'a
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([5, 2, 3, 5, 6], ~cmp=IntCmp.cmp)
-s0->Belt.Set.Dict.reduce(list{}, (acc, element) => acc->Belt.List.add(element)) /* [6,5,3,2] */
-```
-
-## everyU
-
-```res sig
-let everyU: (t<'value, 'id>, (. 'value) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'value, 'id>, 'value => bool) => bool
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.Set.Dict.fromArray([2, 4, 6, 8], ~cmp=IntCmp.cmp)
-s0->Belt.Set.Dict.every(isEven) /* true */
-```
-
-## someU
-
-```res sig
-let someU: (t<'value, 'id>, (. 'value) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'value, 'id>, 'value => bool) => bool
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.Set.Dict.fromArray([1, 2, 4, 6, 8], ~cmp=IntCmp.cmp)
-s0->Belt.Set.Dict.some(isOdd) /* true */
-```
-
-## keepU
-
-```res sig
-let keepU: (t<'value, 'id>, (. 'value) => bool) => t<'value, 'id>
-```
-
-## keep
-
-```res sig
-let keep: (t<'value, 'id>, 'value => bool) => t<'value, 'id>
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.Set.Dict.fromArray([1, 2, 3, 4, 5], ~cmp=IntCmp.cmp)
-let s1 = s0->Belt.Set.Dict.keep(isEven)
-
-s1->Belt.Set.Dict.toArray /* [2,4] */
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t<'value, 'id>, (. 'value) => bool) => (t<'value, 'id>, t<'value, 'id>)
-```
-
-## partition
-
-```res sig
-let partition: (t<'value, 'id>, 'value => bool) => (t<'value, 'id>, t<'value, 'id>)
-```
-
-Returns a pair of sets, where first is the set of all the elements of set that satisfy the predicate, and second is the set of all the elements of set that do not satisfy the predicate.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.Set.Dict.fromArray([1, 2, 3, 4, 5], ~cmp=IntCmp.cmp)
-let (s1, s2) = s0->Belt.Set.Dict.partition(isOdd)
-
-s1->Belt.Set.Dict.toArray /* [1,3,5] */
-s2->Belt.Set.Dict.toArray /* [2,4] */
-```
-
-## size
-
-```res sig
-let size: t<'value, 'id> => int
-```
-
-Returns size of the set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([1, 2, 3, 4], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.size /* 4 */
-```
-
-## toList
-
-```res sig
-let toList: t<'value, 'id> => list<'value>
-```
-
-Returns list of ordered set elements.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([3, 2, 1, 5], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.toList /* [1,2,3,5] */
-```
-
-## toArray
-
-```res sig
-let toArray: t<'value, 'id> => array<'value>
-```
-
-Returns array of ordered set elements.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([3, 2, 1, 5], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.toArray /* [1,2,3,5] */
-```
-
-## minimum
-
-```res sig
-let minimum: t<'value, 'id> => option<'value>
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.empty
-let s1 = Belt.Set.Dict.fromArray([3, 2, 1, 5], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.minimum /* None */
-s1->Belt.Set.Dict.minimum /* Some(1) */
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'value, 'id> => Js.undefined<'value>
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.empty
-let s1 = Belt.Set.Dict.fromArray([3, 2, 1, 5], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.minUndefined /* undefined */
-s1->Belt.Set.Dict.minUndefined /* 1 */
-```
-
-## maximum
-
-```res sig
-let maximum: t<'value, 'id> => option<'value>
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.empty
-let s1 = Belt.Set.Dict.fromArray([3, 2, 1, 5], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.maximum /* None */
-s1->Belt.Set.Dict.maximum /* Some(5) */
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'value, 'id> => Js.undefined<'value>
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.empty
-let s1 = Belt.Set.Dict.fromArray([3, 2, 1, 5], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.maxUndefined /* undefined */
-s1->Belt.Set.Dict.maxUndefined /* 5 */
-```
-
-## get
-
-```res sig
-let get: (t<'value, 'id>, 'value, ~cmp: cmp<'value, 'id>) => option<'value>
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([1, 2, 3, 4, 5], ~cmp=IntCmp.cmp)
-
-s0->Belt.Set.Dict.get(3, ~cmp=IntCmp.cmp) /* Some(3) */
-s0->Belt.Set.Dict.get(20, ~cmp=IntCmp.cmp) /* None */
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'value, 'id>, 'value, ~cmp: cmp<'value, 'id>) => Js.undefined<'value>
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```res sig
-let getExn: (t<'value, 'id>, 'value, ~cmp: cmp<'value, 'id>) => 'value
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```res sig
-let split: (
-  t<'value, 'id>,
-  'value,
-  ~cmp: cmp<'value, 'id>,
-) => ((t<'value, 'id>, t<'value, 'id>), bool)
-```
-
-Returns a tuple `((smaller, larger), present)`, `present` is true when element exist in set.
-
-```res example
-module IntCmp = Belt.Id.MakeComparable({
-  type t = int
-  let cmp = Pervasives.compare
-})
-
-let s0 = Belt.Set.Dict.fromArray([1, 2, 3, 4, 5], ~cmp=IntCmp.cmp)
-
-let ((smaller, larger), present) = s0->Belt.Set.Dict.split(3, ~cmp=IntCmp.cmp)
-
-present /* true */
-smaller->Belt.Set.Dict.toArray /* [1,2] */
-larger->Belt.Set.Dict.toArray /* [4,5] */
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t<'a, 'b> => unit
-```
-
-**raise** when invariant is not held
-
diff --git a/pages/docs/manual/v9.0.0/api/belt/set-int.mdx b/pages/docs/manual/v9.0.0/api/belt/set-int.mdx
deleted file mode 100644
index c21e8deba..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/set-int.mdx
+++ /dev/null
@@ -1,537 +0,0 @@
-# SetInt
-
-<Intro>
-
-Specalized when value type is `int`, more efficient than the generic type, its compare behavior is fixed using the built-in comparison.
-
-</Intro>
-
-## value
-
-```res prelude
-type value = int
-```
-
-The type of the set elements.
-
-## t
-
-```res prelude
-type t
-```
-
-Type of the sets.
-
-## empty
-
-```res sig
-let empty: t
-```
-
-Empty set
-
-```res example
-let s0 = Belt.Set.Int.empty
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<value> => t
-```
-
-Creates new set from array of elements.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([1, 3, 2, 4])
-
-s0->Belt.Set.Int.toArray /* [1, 2, 3, 4] */
-```
-
-## fromSortedArrayUnsafe
-
-```res sig
-let fromSortedArrayUnsafe: array<value> => t
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## isEmpty
-
-```res sig
-let isEmpty: t => bool
-```
-
-Checks if set is empty.
-
-```res example
-let empty = Belt.Set.Int.fromArray([])
-let notEmpty = Belt.Set.Int.fromArray([1])
-
-Belt.Set.Int.isEmpty(empty) /* true */
-Belt.Set.Int.isEmpty(notEmpty) /* false */
-```
-
-## has
-
-```res sig
-let has: (t, value) => bool
-```
-
-Checks if element exists in set.
-
-```res example
-let set = Belt.Set.Int.fromArray([1, 4, 2, 5])
-
-set->Belt.Set.Int.has(3) /* false */
-set->Belt.Set.Int.has(1) /* true */
-```
-
-## add
-
-```res sig
-let add: (t, value) => t
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.Set.Int.empty
-let s1 = s0->Belt.Set.Int.add(1)
-let s2 = s1->Belt.Set.Int.add(2)
-let s3 = s2->Belt.Set.Int.add(2)
-s0->Belt.Set.Int.toArray /* [] */
-s1->Belt.Set.Int.toArray /* [1] */
-s2->Belt.Set.Int.toArray /* [1, 2] */
-s3->Belt.Set.Int.toArray /* [1,2 ] */
-s2 == s3 /* true */
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t, array<value>) => t
-```
-
-Adds each element of array to set. Unlike [add](#add), the reference of return value might be changed even if all values in array already exist in set
-
-```res example
-let set = Belt.Set.Int.empty
-
-let newSet = set->Belt.Set.Int.mergeMany([5, 4, 3, 2, 1])
-newSet->Belt.Set.Int.toArray /* [1, 2, 3, 4, 5] */
-```
-
-## remove
-
-```res sig
-let remove: (t, value) => t
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([2, 3, 1, 4, 5])
-let s1 = s0->Belt.Set.Int.remove(1)
-let s2 = s1->Belt.Set.Int.remove(3)
-let s3 = s2->Belt.Set.Int.remove(3)
-
-s1->Belt.Set.Int.toArray /* [2,3,4,5] */
-s2->Belt.Set.Int.toArray /* [2,4,5] */
-s2 == s3 /* true */
-```
-
-## removeMany
-
-```res sig
-let removeMany: (t, array<value>) => t
-```
-
-Removes each element of array from set. Unlike [remove](#remove), the reference of return value might be changed even if any values in array not existed in set.
-
-```res example
-let set = Belt.Set.Int.fromArray([1, 2, 3, 4])
-
-let newSet = set->Belt.Set.Int.removeMany([5, 4, 3, 2, 1])
-newSet->Belt.Set.Int.toArray /* [] */
-```
-
-## union
-
-```res sig
-let union: (t, t) => t
-```
-
-Returns union of two sets.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([5, 2, 3, 5, 6])
-let s1 = Belt.Set.Int.fromArray([5, 2, 3, 1, 5, 4])
-let union = Belt.Set.Int.union(s0, s1)
-union->Belt.Set.Int.toArray /* [1,2,3,4,5,6] */
-```
-
-## intersect
-
-```res sig
-let intersect: (t, t) => t
-```
-
-Returns intersection of two sets.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([5, 2, 3, 5, 6])
-let s1 = Belt.Set.Int.fromArray([5, 2, 3, 1, 5, 4])
-let intersect = Belt.Set.Int.intersect(s0, s1)
-intersect->Belt.Set.Int.toArray /* [2,3,5] */
-```
-
-## diff
-
-```res sig
-let diff: (t, t) => t
-```
-
-Returns elements from first set, not existing in second set.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([5, 2, 3, 5, 6])
-let s1 = Belt.Set.Int.fromArray([5, 2, 3, 1, 5, 4])
-Belt.Set.Int.toArray(Belt.Set.Int.diff(s0, s1)) /* [6] */
-Belt.Set.Int.toArray(Belt.Set.Int.diff(s1, s0)) /* [1,4] */
-```
-
-## subset
-
-```res sig
-let subset: (t, t) => bool
-```
-
-Checks if second set is subset of first set.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([5, 2, 3, 5, 6])
-let s1 = Belt.Set.Int.fromArray([5, 2, 3, 1, 5, 4])
-let s2 = Belt.Set.Int.intersect(s0, s1)
-Belt.Set.Int.subset(s2, s0) /* true */
-Belt.Set.Int.subset(s2, s1) /* true */
-Belt.Set.Int.subset(s1, s0) /* false */
-```
-
-## cmp
-
-```res sig
-let cmp: (t, t) => int
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```res sig
-let eq: (t, t) => bool
-```
-
-Checks if two sets are equal.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([5, 2, 3])
-let s1 = Belt.Set.Int.fromArray([3, 2, 5])
-
-Belt.Set.Int.eq(s0, s1) /* true */
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t, (. value) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t, value => unit) => unit
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([5, 2, 3, 5, 6])
-let acc = ref(list{})
-s0->Belt.Set.Int.forEach(x => acc := Belt.List.add(acc.contents, x))
-acc /* [6,5,3,2] */
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t, 'a, (. 'a, value) => 'a) => 'a
-```
-
-## reduce
-
-```res sig
-let reduce: (t, 'a, ('a, value) => 'a) => 'a
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([5, 2, 3, 5, 6])
-s0->Belt.Set.Int.reduce(list{}, (acc, element) => acc->Belt.List.add(element)) /* [6,5,3,2] */
-```
-
-## everyU
-
-```res sig
-let everyU: (t, (. value) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t, value => bool) => bool
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.Set.Int.fromArray([2, 4, 6, 8])
-s0->Belt.Set.Int.every(isEven) /* true */
-```
-
-## someU
-
-```res sig
-let someU: (t, (. value) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t, value => bool) => bool
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```res example
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.Set.Int.fromArray([1, 2, 4, 6, 8])
-s0->Belt.Set.Int.some(isOdd) /* true */
-```
-
-## keepU
-
-```res sig
-let keepU: (t, (. value) => bool) => t
-```
-
-## keep
-
-```res sig
-let keep: (t, value => bool) => t
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.Set.Int.fromArray([1, 2, 3, 4, 5])
-let s1 = s0->Belt.Set.Int.keep(isEven)
-
-s1->Belt.Set.Int.toArray /* [2,4] */
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t, (. value) => bool) => (t, t)
-```
-
-## partition
-
-```res sig
-let partition: (t, value => bool) => (t, t)
-```
-
-Returns a pair of sets, where first is the set of all the elements of set that satisfy the predicate, and second is the set of all the elements of set that do not satisfy the predicate.
-
-```res example
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.Set.Int.fromArray([1, 2, 3, 4, 5])
-let (s1, s2) = s0->Belt.Set.Int.partition(isOdd)
-
-s1->Belt.Set.Int.toArray /* [1,3,5] */
-s2->Belt.Set.Int.toArray /* [2,4] */
-```
-
-## size
-
-```res sig
-let size: t => int
-```
-
-Returns size of the set.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([1, 2, 3, 4])
-
-s0->Belt.Set.Int.size /* 4 */
-```
-
-## toList
-
-```res sig
-let toList: t => list<value>
-```
-
-Returns list of ordered set elements.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.Set.Int.toList /* [1,2,3,5] */
-```
-
-## toArray
-
-```res sig
-let toArray: t => array<value>
-```
-
-Returns array of ordered set elements.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.Set.Int.toArray /* [1,2,3,5] */
-```
-
-## minimum
-
-```res sig
-let minimum: t => option<value>
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.Set.Int.empty
-let s1 = Belt.Set.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.Set.Int.minimum /* None */
-s1->Belt.Set.Int.minimum /* Some(1) */
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t => Js.undefined<value>
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.Set.Int.empty
-let s1 = Belt.Set.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.Set.Int.minUndefined /* undefined */
-s1->Belt.Set.Int.minUndefined /* 1 */
-```
-
-## maximum
-
-```res sig
-let maximum: t => option<value>
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.Set.Int.empty
-let s1 = Belt.Set.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.Set.Int.maximum /* None */
-s1->Belt.Set.Int.maximum /* Some(5) */
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t => Js.undefined<value>
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.Set.Int.empty
-let s1 = Belt.Set.Int.fromArray([3, 2, 1, 5])
-
-s0->Belt.Set.Int.maxUndefined /* undefined */
-s1->Belt.Set.Int.maxUndefined /* 5 */
-```
-
-## get
-
-```res sig
-let get: (t, value) => option<value>
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([1, 2, 3, 4, 5])
-
-s0->Belt.Set.Int.get(3) /* Some(3) */
-s0->Belt.Set.Int.get(20) /* None */
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t, value) => Js.undefined<value>
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```res sig
-let getExn: (t, value) => value
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```res sig
-let split: (t, value) => ((t, t), bool)
-```
-
-Returns a tuple `((l, r), present)`, where `l` is the set of elements of set that are strictly less than value, `r` is the set of elements of set that are strictly greater than value, `present` is `false` if set contains no element equal to value, or `true` if set contains an element equal to value.
-
-```res example
-let s0 = Belt.Set.Int.fromArray([1, 2, 3, 4, 5])
-
-let ((smaller, larger), present) = s0->Belt.Set.Int.split(3)
-
-present /* true */
-smaller->Belt.Set.Int.toArray /* [1,2] */
-larger->Belt.Set.Int.toArray /* [4,5] */
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t => unit
-```
-
-**raise** when invariant is not held
-
diff --git a/pages/docs/manual/v9.0.0/api/belt/set-string.mdx b/pages/docs/manual/v9.0.0/api/belt/set-string.mdx
deleted file mode 100644
index bf21b7964..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/set-string.mdx
+++ /dev/null
@@ -1,538 +0,0 @@
-# SetString
-
-<Intro>
-
-Specalized when value type is `string`, more efficient than the generic type, its compare behavior is fixed using the built-in comparison.
-
-</Intro>
-
-## value
-
-```res prelude
-type value = string
-```
-
-The type of the set elements.
-
-## t
-
-```res prelude
-type t
-```
-
-The type of sets.
-
-## empty
-
-```res sig
-let empty: t
-```
-
-Empty set
-
-```res example
-let s0 = Belt.Set.String.empty
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<value> => t
-```
-
-Creates new set from array of elements.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "orange", "banana"])
-
-s0->Belt.Set.String.toArray /* ["apple", "banana", "orange"] */
-```
-
-## fromSortedArrayUnsafe
-
-```res sig
-let fromSortedArrayUnsafe: array<value> => t
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## isEmpty
-
-```res sig
-let isEmpty: t => bool
-```
-
-Checks if set is empty.
-
-```res example
-let empty = Belt.Set.String.fromArray([])
-let notEmpty = Belt.Set.String.fromArray(["apple"])
-
-Belt.Set.String.isEmpty(empty) /* true */
-Belt.Set.String.isEmpty(notEmpty) /* false */
-```
-
-## has
-
-```res sig
-let has: (t, value) => bool
-```
-
-Checks if element exists in set.
-
-```res example
-let set = Belt.Set.String.fromArray(["apple", "orange", "banana"])
-
-set->Belt.Set.String.has("strawberry") /* false */
-set->Belt.Set.String.has("apple") /* true */
-```
-
-## add
-
-```res sig
-let add: (t, value) => t
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.Set.String.empty
-let s1 = s0->Belt.Set.String.add("apple")
-let s2 = s1->Belt.Set.String.add("banana")
-let s3 = s2->Belt.Set.String.add("banana")
-s0->Belt.Set.String.toArray /* [] */
-s1->Belt.Set.String.toArray /* ["apple"] */
-s2->Belt.Set.String.toArray /* ["apple", "banana"] */
-s3->Belt.Set.String.toArray /* ["apple", "banana"] */
-s2 == s3 /* true */
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t, array<value>) => t
-```
-
-Adds each element of array to set. Unlike [add](#add), the reference of return value might be changed even if all values in array already exist in set
-
-```res example
-let set = Belt.Set.String.empty
-
-let newSet = set->Belt.Set.String.mergeMany(["apple", "banana", "orange", "strawberry"])
-
-newSet->Belt.Set.String.toArray /* ["apple", "banana", "orange", "strawberry"] */
-```
-
-## remove
-
-```res sig
-let remove: (t, value) => t
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["orange", "banana", "apple"])
-let s1 = s0->Belt.Set.String.remove("apple")
-let s2 = s1->Belt.Set.String.remove("banana")
-let s3 = s2->Belt.Set.String.remove("banana")
-
-s1->Belt.Set.String.toArray /* ["orange", "banana"] */
-s2->Belt.Set.String.toArray /* ["orange"] */
-s2 == s3 /* true */
-```
-
-## removeMany
-
-```res sig
-let removeMany: (t, array<value>) => t
-```
-
-Removes each element of array from set. Unlike [remove](#remove), the reference of return value might be changed even if any values in array not existed in set.
-
-```res example
-let set = Belt.Set.String.fromArray(["apple", "banana", "orange"])
-
-let newSet = set->Belt.Set.String.removeMany(["strawberry", "apple", "banana", "orange"])
-newSet->Belt.Set.String.toArray /* [] */
-```
-
-## union
-
-```res sig
-let union: (t, t) => t
-```
-
-Returns union of two sets.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "banana", "orange", "carrot"])
-let s1 = Belt.Set.String.fromArray(["apple", "banana", "orange", "strawberry"])
-let union = Belt.Set.String.union(s0, s1)
-union->Belt.Set.String.toArray /* ["apple", "banana", "carrot", "orange", "strawberry"] */
-```
-
-## intersect
-
-```res sig
-let intersect: (t, t) => t
-```
-
-Returns intersection of two sets.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "banana", "orange", "carrot"])
-let s1 = Belt.Set.String.fromArray(["apple", "banana", "orange", "strawberry"])
-let intersect = Belt.Set.String.intersect(s0, s1)
-intersect->Belt.Set.String.toArray /* ["apple", "banana", "orange"] */
-```
-
-## diff
-
-```res sig
-let diff: (t, t) => t
-```
-
-Returns elements from first set, not existing in second set.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "banana", "orange", "carrot"])
-let s1 = Belt.Set.String.fromArray(["apple", "banana", "orange", "strawberry"])
-Belt.Set.String.toArray(Belt.Set.String.diff(s0, s1)) /* ["carrot"] */
-Belt.Set.String.toArray(Belt.Set.String.diff(s1, s0)) /* ["strawberry"] */
-```
-
-## subset
-
-```res sig
-let subset: (t, t) => bool
-```
-
-Checks if second set is subset of first set.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["5", "2", "3", "5", "6"])
-let s1 = Belt.Set.String.fromArray(["5", "2", "3", "1", "5", "4"])
-let s2 = Belt.Set.String.intersect(s0, s1)
-Belt.Set.String.subset(s2, s0) /* true */
-Belt.Set.String.subset(s2, s1) /* true */
-Belt.Set.String.subset(s1, s0) /* false */
-```
-
-## cmp
-
-```res sig
-let cmp: (t, t) => int
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```res sig
-let eq: (t, t) => bool
-```
-
-Checks if two sets are equal.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "orange"])
-let s1 = Belt.Set.String.fromArray(["orange", "apple"])
-
-Belt.Set.String.eq(s0, s1) /* true */
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t, (. value) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t, value => unit) => unit
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["banana", "orange", "apple"])
-let acc = ref(list{})
-s0->Belt.Set.String.forEach(x => acc := Belt.List.add(acc.contents, x))
-acc /* ["orange", "banana", "apple"] */
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t, 'a, (. 'a, value) => 'a) => 'a
-```
-
-## reduce
-
-```res sig
-let reduce: (t, 'a, ('a, value) => 'a) => 'a
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "orange"])
-s0->Belt.Set.String.reduce(0, (acc, element) => acc + String.length(element)) /* 11 */
-```
-
-## everyU
-
-```res sig
-let everyU: (t, (. value) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t, value => bool) => bool
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```res example
-let hasAtLeastFiveChars = x => String.length(x) >= 5
-
-let s0 = Belt.Set.String.fromArray(["apple", "carrot"])
-s0->Belt.Set.String.every(hasAtLeastFiveChars) /* true */
-```
-
-## someU
-
-```res sig
-let someU: (t, (. value) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t, value => bool) => bool
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```res example
-let hasFiveChars = x => String.length(x) == 5
-
-let s0 = Belt.Set.String.fromArray(["strawberry", "apple"])
-s0->Belt.Set.String.some(hasFiveChars) /* true */
-```
-
-## keepU
-
-```res sig
-let keepU: (t, (. value) => bool) => t
-```
-
-## keep
-
-```res sig
-let keep: (t, value => bool) => t
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```res example
-let hasFiveChars = x => String.length(x) == 5
-
-let s0 = Belt.Set.String.fromArray(["apple", "orange", "banana"])
-let s1 = s0->Belt.Set.String.keep(hasFiveChars)
-
-s1->Belt.Set.String.toArray /* ["apple"] */
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t, (. value) => bool) => (t, t)
-```
-
-## partition
-
-```res sig
-let partition: (t, value => bool) => (t, t)
-```
-
-Returns a pair of sets, where first is the set of all the elements of set that satisfy the predicate, and second is the set of all the elements of set that do not satisfy the predicate.
-
-```res example
-let hasFiveChars = x => String.length(x) == 5
-
-let s0 = Belt.Set.String.fromArray(["apple", "carrot"])
-let (s1, s2) = s0->Belt.Set.String.partition(hasFiveChars)
-
-s1->Belt.Set.String.toArray /* ["apple"] */
-s2->Belt.Set.String.toArray /* ["carrot"] */
-```
-
-## size
-
-```res sig
-let size: t => int
-```
-
-Returns size of the set.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple"])
-
-s0->Belt.Set.String.size /* 1 */
-```
-
-## toList
-
-```res sig
-let toList: t => list<value>
-```
-
-Returns list of ordered set elements.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "watermelon"])
-
-s0->Belt.Set.String.toList /* ["apple", "watermelon"] */
-```
-
-## toArray
-
-```res sig
-let toArray: t => array<value>
-```
-
-Returns array of ordered set elements.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "watermelon"])
-
-s0->Belt.Set.String.toArray /* ["apple", "watermelon"] */
-```
-
-## minimum
-
-```res sig
-let minimum: t => option<value>
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.Set.String.empty
-let s1 = Belt.Set.String.fromArray(["apple", "orange"])
-
-s0->Belt.Set.String.minimum /* None */
-s1->Belt.Set.String.minimum /* Some("apple") */
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t => Js.undefined<value>
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.Set.String.empty
-let s1 = Belt.Set.String.fromArray(["apple", "orange"])
-
-s0->Belt.Set.String.minUndefined /* undefined */
-s1->Belt.Set.String.minUndefined /* "apple" */
-```
-
-## maximum
-
-```res sig
-let maximum: t => option<value>
-```
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.Set.String.empty
-let s1 = Belt.Set.String.fromArray(["apple", "orange"])
-
-s0->Belt.Set.String.maximum /* None */
-s1->Belt.Set.String.maximum /* Some("orange") */
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t => Js.undefined<value>
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.Set.String.empty
-let s1 = Belt.Set.String.fromArray(["apple", "orange"])
-
-s0->Belt.Set.String.maxUndefined /* undefined */
-s1->Belt.Set.String.maxUndefined /* orange */
-```
-
-## get
-
-```res sig
-let get: (t, value) => option<value>
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "carrot"])
-
-s0->Belt.Set.String.get("carrot") /* Some("carrot") */
-s0->Belt.Set.String.get("watermelon") /* None */
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t, value) => Js.undefined<value>
-```
-
-See [get](#get) - returns `undefined` when element does not exist.
-
-## getExn
-
-```res sig
-let getExn: (t, value) => value
-```
-
-See [get](#get) - raise when element does not exist.
-
-## split
-
-```res sig
-let split: (t, value) => ((t, t), bool)
-```
-
-Returns a triple `((l, r), present)`, where `l` is the set of elements of set that are strictly less than value, `r` is the set of elements of set that are strictly greater than value, `present` is `false` if set contains no element equal to value, or `true` if set contains an element equal to value.
-
-```res example
-let s0 = Belt.Set.String.fromArray(["apple", "banana", "orange"])
-
-let ((smaller, larger), present) = s0->Belt.Set.String.split("banana")
-
-present /* true */
-smaller->Belt.Set.String.toArray /* ["apple"] */
-larger->Belt.Set.String.toArray /* ["orange"] */
-```
-
-## checkInvariantInternal
-
-```res sig
-let checkInvariantInternal: t => unit
-```
-
-**raise** when invariant is not held
-
diff --git a/pages/docs/manual/v9.0.0/api/belt/set.mdx b/pages/docs/manual/v9.0.0/api/belt/set.mdx
deleted file mode 100644
index 173cdd865..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/set.mdx
+++ /dev/null
@@ -1,590 +0,0 @@
-# Set
-
-<Intro>
-
-A **immutable** sorted set module which allows customize compare behavior.
-The implementation uses balanced binary trees, and therefore searching and insertion take time logarithmic in the size of the map.
-
-It also has three specialized inner modules [Belt.Set.Int](set-int), [Belt.Set.String](set-string) and [Belt.Set.Dict](set-dict) - This module separates data from function which is more verbose but slightly more efficient
-
-</Intro>
-
-```res example
-module PairComparator =
-  Belt.Id.MakeComparable({
-    type t = (int, int)
-    let cmp = ((a0, a1), (b0, b1)) =>
-      switch (Pervasives.compare(a0, b0)) {
-      | 0 => Pervasives.compare(a1, b1)
-      | c => c
-      }
-  })
-
-let mySet = Belt.Set.make(~id=module(PairComparator))
-let mySet2 = Belt.Set.add(mySet, (1, 2))
-```
-
-**Note:** This module's examples will assume a predeclared module for integers
-called `IntCmp`. It is declared like this:
-
-```res prelude
-module IntCmp =
-  Belt.Id.MakeComparable({
-    type t = int
-    let cmp = Pervasives.compare
-  })
-```
-
-## t
-
-```res prelude
-type t<'value, 'identity>
-```
-
-`'value` is the element type
-
-`'identity` the identity of the collection
-
-## id
-
-```res prelude
-type id<'value, 'id> = Belt_Id.comparable<'value, 'id>
-```
-
-The identity needed for making a set from scratch
-
-## make
-
-```res sig
-let make: (~id: id<'value, 'id>) => t<'value, 'id>
-```
-
-Creates a new set by taking in the comparator
-
-```res example
-let set = Belt.Set.make(~id=module(IntCmp))
-```
-
-## fromArray
-
-```res sig
-let fromArray: (array<'value>, ~id: id<'value, 'id>) => t<'value, 'id>
-```
-
-Creates new set from array of elements.
-
-```res example
-let s0 = Belt.Set.fromArray([1, 3, 2, 4], ~id=module(IntCmp))
-
-s0->Belt.Set.toArray /* [1, 2, 3, 4] */
-```
-
-## fromSortedArrayUnsafe
-
-```res sig
-let fromSortedArrayUnsafe: (array<'value>, ~id: id<'value, 'id>) => t<'value, 'id>
-```
-
-The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a, 'b> => bool
-```
-
-Checks if set is empty.
-
-```res example
-let empty = Belt.Set.fromArray([], ~id=module(IntCmp))
-let notEmpty = Belt.Set.fromArray([1],~id=module(IntCmp))
-
-Belt.Set.isEmpty(empty) /* true */
-Belt.Set.isEmpty(notEmpty) /* false */
-```
-
-## has
-
-```res sig
-let has: (t<'value, 'id>, 'value) => bool
-```
-
-Checks if element exists in set.
-
-```res example
-let set = Belt.Set.fromArray([1, 4, 2, 5], ~id=module(IntCmp))
-
-set->Belt.Set.has(3) /* false */
-set->Belt.Set.has(1) /* true */
-```
-
-## add
-
-```res sig
-let add: (t<'value, 'id>, 'value) => t<'value, 'id>
-```
-
-Adds element to set. If element existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.Set.make(~id=module(IntCmp))
-let s1 = s0->Belt.Set.add(1)
-let s2 = s1->Belt.Set.add(2)
-let s3 = s2->Belt.Set.add(2)
-s0->Belt.Set.toArray /* [] */
-s1->Belt.Set.toArray /* [1] */
-s2->Belt.Set.toArray /* [1, 2] */
-s3->Belt.Set.toArray /* [1,2 ] */
-s2 == s3 /* true */
-```
-
-## mergeMany
-
-```res sig
-let mergeMany: (t<'value, 'id>, array<'value>) => t<'value, 'id>
-```
-
-Adds each element of array to set. Unlike [add](#add), the reference of return value might be changed even if all values in array already exist in set
-
-```res example
-let set = Belt.Set.make(~id=module(IntCmp))
-
-let newSet = set->Belt.Set.mergeMany([5, 4, 3, 2, 1])
-newSet->Belt.Set.toArray /* [1, 2, 3, 4, 5] */
-```
-
-## remove
-
-```res sig
-let remove: (t<'value, 'id>, 'value) => t<'value, 'id>
-```
-
-Removes element from set. If element wasn't existed in set, value is unchanged.
-
-```res example
-let s0 = Belt.Set.fromArray([2,3,1,4,5], ~id=module(IntCmp))
-let s1 = s0->Belt.Set.remove(1)
-let s2 = s1->Belt.Set.remove(3)
-let s3 = s2->Belt.Set.remove(3)
-
-s1->Belt.Set.toArray /* [2,3,4,5] */
-s2->Belt.Set.toArray /* [2,4,5] */
-s2 == s3 /* true */
-```
-
-## removeMany
-
-```res sig
-let removeMany: (t<'value, 'id>, array<'value>) => t<'value, 'id>
-```
-
-Removes each element of array from set. Unlike [remove](#remove), the reference of return value might be changed even if any values in array not existed in set.
-
-```res example
-let set = Belt.Set.fromArray([1, 2, 3, 4],~id=module(IntCmp))
-
-let newSet = set->Belt.Set.removeMany([5, 4, 3, 2, 1])
-newSet->Belt.Set.toArray /* [] */
-```
-
-## union
-
-```res sig
-let union: (t<'value, 'id>, t<'value, 'id>) => t<'value, 'id>
-```
-
-Returns union of two sets.
-
-```res example
-let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([5,2,3,1,5,4], ~id=module(IntCmp))
-let union = Belt.Set.union(s0, s1)
-union->Belt.Set.toArray /* [1,2,3,4,5,6] */
-```
-
-## intersect
-
-```res sig
-let intersect: (t<'value, 'id>, t<'value, 'id>) => t<'value, 'id>
-```
-
-Returns intersection of two sets.
-
-```res example
-let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([5,2,3,1,5,4], ~id=module(IntCmp))
-let intersect = Belt.Set.intersect(s0, s1)
-intersect->Belt.Set.toArray /* [2,3,5] */
-```
-
-## diff
-
-```res sig
-let diff: (t<'value, 'id>, t<'value, 'id>) => t<'value, 'id>
-```
-
-Returns elements from first set, not existing in second set.
-
-```res example
-let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([5,2,3,1,5,4], ~id=module(IntCmp))
-Belt.Set.toArray(Belt.Set.diff(s0, s1)) /* [6] */
-Belt.Set.toArray(Belt.Set.diff(s1,s0)) /* [1,4] */
-```
-
-## subset
-
-```res sig
-let subset: (t<'value, 'id>, t<'value, 'id>) => bool
-```
-
-Checks if second set is subset of first set.
-
-```res example
-let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([5,2,3,1,5,4], ~id=module(IntCmp))
-let s2 = Belt.Set.intersect(s0, s1)
-Belt.Set.subset(s2, s0) /* true */
-Belt.Set.subset(s2, s1) /* true */
-Belt.Set.subset(s1, s0) /* false */
-```
-
-## cmp
-
-```res sig
-let cmp: (t<'value, 'id>, t<'value, 'id>) => int
-```
-
-Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.
-
-## eq
-
-```res sig
-let eq: (t<'value, 'id>, t<'value, 'id>) => bool
-```
-
-Checks if two sets are equal.
-
-```res example
-let s0 = Belt.Set.fromArray([5,2,3], ~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([3,2,5], ~id=module(IntCmp))
-
-Belt.Set.eq(s0, s1) /* true */
-```
-
-## forEachU
-
-```res sig
-let forEachU: (t<'value, 'id>, (. 'value) => unit) => unit
-```
-
-Same as [forEach](##forEach) but takes uncurried functon.
-
-## forEach
-
-```res sig
-let forEach: (t<'value, 'id>, 'value => unit) => unit
-```
-
-Applies function `f` in turn to all elements of set in increasing order.
-
-```res example
-let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
-let acc = ref(list{})
-s0->Belt.Set.forEach(x => {
-  acc := Belt.List.add(acc.contents, x)
-})
-acc /* [6,5,3,2] */
-```
-
-## reduceU
-
-```res sig
-let reduceU: (t<'value, 'id>, 'a, (. 'a, 'value) => 'a) => 'a
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'value, 'id>, 'a, ('a, 'value) => 'a) => 'a
-```
-
-Applies function `f` to each element of set in increasing order. Function `f` has two parameters: the item from the set and an “accumulator”, which starts with a value of `initialValue`. `reduce` returns the final value of the accumulator.
-
-```res example
-let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
-s0->Belt.Set.reduce(list{}, (acc, element) =>
-  acc->Belt.List.add(element)
-) /* [6,5,3,2] */
-```
-
-## everyU
-
-```res sig
-let everyU: (t<'value, 'id>, (. 'value) => bool) => bool
-```
-
-## every
-
-```res sig
-let every: (t<'value, 'id>, 'value => bool) => bool
-```
-
-Checks if all elements of the set satisfy the predicate. Order unspecified.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.Set.fromArray([2,4,6,8], ~id=module(IntCmp))
-s0->Belt.Set.every(isEven) /* true */
-```
-
-## someU
-
-```res sig
-let someU: (t<'value, 'id>, (. 'value) => bool) => bool
-```
-
-## some
-
-```res sig
-let some: (t<'value, 'id>, 'value => bool) => bool
-```
-
-Checks if at least one element of the set satisfies the predicate.
-
-```res example
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.Set.fromArray([1,2,4,6,8], ~id=module(IntCmp))
-s0->Belt.Set.some(isOdd) /* true */
-```
-
-## keepU
-
-```res sig
-let keepU: (t<'value, 'id>, (. 'value) => bool) => t<'value, 'id>
-```
-
-## keep
-
-```res sig
-let keep: (t<'value, 'id>, 'value => bool) => t<'value, 'id>
-```
-
-Returns the set of all elements that satisfy the predicate.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-let s0 = Belt.Set.fromArray([1,2,3,4,5], ~id=module(IntCmp))
-let s1 = s0->Belt.Set.keep(isEven)
-
-s1->Belt.Set.toArray /* [2,4] */
-```
-
-## partitionU
-
-```res sig
-let partitionU: (t<'value, 'id>, (. 'value) => bool) => (t<'value, 'id>, t<'value, 'id>)
-```
-
-## partition
-
-```res sig
-let partition: (t<'value, 'id>, 'value => bool) => (t<'value, 'id>, t<'value, 'id>)
-```
-
-Returns a pair of sets, where first is the set of all the elements of set that satisfy the predicate, and second is the set of all the elements of set that do not satisfy the predicate.
-
-```res example
-let isOdd = x => mod(x, 2) != 0
-
-let s0 = Belt.Set.fromArray([1,2,3,4,5], ~id=module(IntCmp))
-let (s1, s2) = s0->Belt.Set.partition(isOdd)
-
-s1->Belt.Set.toArray /* [1,3,5] */
-s2->Belt.Set.toArray /* [2,4] */
-```
-
-## size
-
-```res sig
-let size: t<'value, 'id> => int
-```
-
-Returns size of the set.
-
-```res example
-let s0 = Belt.Set.fromArray([1,2,3,4], ~id=module(IntCmp))
-
-s0->Belt.Set.size /* 4 */
-```
-
-## toArray
-
-```res sig
-let toArray: t<'value, 'id> => array<'value>
-```
-
-Returns array of ordered set elements.
-
-```res example
-let s0 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))
-
-s0->Belt.Set.toArray /* [1,2,3,5] */
-```
-
-## toList
-
-```res sig
-let toList: t<'value, 'id> => list<'value>
-```
-
-Returns list of ordered set elements.
-
-```res example
-let s0 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))
-
-s0->Belt.Set.toList /* [1,2,3,5] */
-```
-
-## minimum
-
-```res sig
-let minimum: t<'value, 'id> => option<'value>
-```
-
-Returns minimum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.Set.make(~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))
-
-s0->Belt.Set.minimum /* None */
-s1->Belt.Set.minimum /* Some(1) */
-```
-
-## minUndefined
-
-```res sig
-let minUndefined: t<'value, 'id> => Js.undefined<'value>
-```
-
-Returns minimum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.Set.make(~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))
-
-s0->Belt.Set.minUndefined /* undefined */
-s1->Belt.Set.minUndefined /* 1 */
-```
-
-## maximum
-
-Returns maximum value of the collection. `None` if collection is empty.
-
-```res example
-let s0 = Belt.Set.make(~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))
-
-s0->Belt.Set.maximum /* None */
-s1->Belt.Set.maximum /* Some(5) */
-```
-
-## maxUndefined
-
-```res sig
-let maxUndefined: t<'value, 'id> => Js.undefined<'value>
-```
-
-Returns maximum value of the collection. `undefined` if collection is empty.
-
-```res example
-let s0 = Belt.Set.make(~id=module(IntCmp))
-let s1 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))
-
-s0->Belt.Set.maxUndefined /* undefined */
-s1->Belt.Set.maxUndefined /* 5 */
-```
-
-## get
-
-```res sig
-let get: (t<'value, 'id>, 'value) => option<'value>
-```
-
-Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns `None` if element does not exist.
-
-```res example
-let s0 = Belt.Set.fromArray([1,2,3,4,5], ~id=module(IntCmp))
-
-s0->Belt.Set.get(3) /* Some(3) */
-s0->Belt.Set.get(20) /* None */
-```
-
-## getUndefined
-
-```res sig
-let getUndefined: (t<'value, 'id>, 'value) => Js.undefined<'value>
-```
-
-Same as [get](#get) but returns `undefined` when element does not exist.
-
-## getExn
-
-```res sig
-let getExn: (t<'value, 'id>, 'value) => 'value
-```
-
-Same as [get](#get) but raise when element does not exist.
-
-## split
-
-```res sig
-let split: (t<'value, 'id>, 'value) => ((t<'value, 'id>, t<'value, 'id>), bool)
-```
-
-Returns a tuple `((smaller, larger), present)`, `present` is true when element exist in set.
-
-```res example
-let s0 = Belt.Set.fromArray([1,2,3,4,5], ~id=module(IntCmp))
-
-let ((smaller, larger), present) = s0->Belt.Set.split(3)
-
-present /* true */
-smaller->Belt.Set.toArray /* [1,2] */
-larger->Belt.Set.toArray /* [4,5] */
-
-```
-
-## getData
-
-```res sig
-let getData: t<'value, 'id> => Belt_SetDict.t<'value, 'id>
-```
-
-**Advanced usage only**
-
-Returns the raw data (detached from comparator), but its type is still manifested, so that user can pass identity directly without boxing.
-
-## getId
-
-```res sig
-let getId: t<'value, 'id> => id<'value, 'id>
-```
-
-**Advanced usage only**
-
-Returns the identity of set.
-
-## packIdData
-
-```res sig
-let packIdData: (~id: id<'value, 'id>, ~data: Belt_SetDict.t<'value, 'id>) => t<'value, 'id>
-```
-
-**Advanced usage only**
-
-Returns the packed collection.
diff --git a/pages/docs/manual/v9.0.0/api/belt/sort-array-int.mdx b/pages/docs/manual/v9.0.0/api/belt/sort-array-int.mdx
deleted file mode 100644
index 15fc2dc4c..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/sort-array-int.mdx
+++ /dev/null
@@ -1,59 +0,0 @@
-# SortArrayInt
-
-<Intro>
-
-This is a specialized module for `Belt.SortArray`, the docs in that module also applies here, except the comparator is fixed and inlined.
-
-</Intro>
-
-## element
-
-```res prelude
-type element = int
-```
-
-## strictlySortedLength
-
-```res sig
-let strictlySortedLength: array<element> => int
-```
-
-The same as `Belt.SortArray.strictlySortedLength` except the comparator is fixed.
-
-Returns `+n` means increasing order `-n` means negative order.
-
-## isSorted
-
-```res sig
-let isSorted: array<element> => bool
-```
-
-`sorted(xs)` return true if `xs` is in non strict increasing order.
-
-## stableSortInPlace
-
-```res sig
-let stableSortInPlace: array<element> => unit
-```
-
-The same as `Belt.SortArray.stableSortInPlaceBy` except the comparator is fixed.
-
-## stableSort
-
-```res sig
-let stableSort: array<element> => array<element>
-```
-
-The same as `Belt.SortArray.stableSortBy` except the comparator is fixed.
-
-## binarySearch
-
-```res sig
-let binarySearch: (array<element>, element) => int
-```
-
-If value is not found and value is less than one or more elements in array, the negative number returned is the bitwise complement of the index of the first element that is larger than value.
-
-If value is not found and value is greater than all elements in array, the negative number returned is the bitwise complement of (the index of the last element plus 1)
-
-for example, if `key` is smaller than all elements return `-1` since `lnot(-1) = 0` if `key` is larger than all elements return `- (len + 1)` since `lnot(-(len+1)) = len`.
diff --git a/pages/docs/manual/v9.0.0/api/belt/sort-array-string.mdx b/pages/docs/manual/v9.0.0/api/belt/sort-array-string.mdx
deleted file mode 100644
index 3016c1903..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/sort-array-string.mdx
+++ /dev/null
@@ -1,59 +0,0 @@
-# SortArrayString
-
-<Intro>
-
-This is a specialized module for `Belt.SortArray`, the docs in that module also applies here, except the comparator is fixed and inlined.
-
-</Intro>
-
-## element
-
-```res prelude
-type element = string
-```
-
-## strictlySortedLength
-
-```res sig
-let strictlySortedLength: array<element> => int
-```
-
-The same as `Belt.SortArray.strictlySortedLength` except the comparator is fixed.
-
-Returns `+n` means increasing order `-n` means negative order.
-
-## isSorted
-
-```res sig
-let isSorted: array<element> => bool
-```
-
-`sorted(xs)` return true if `xs` is in non strict increasing order.
-
-## stableSortInPlace
-
-```res sig
-let stableSortInPlace: array<element> => unit
-```
-
-The same as `Belt.SortArray.stableSortInPlaceBy` except the comparator is fixed.
-
-## stableSort
-
-```res sig
-let stableSort: array<element> => array<element>
-```
-
-The same as `Belt.SortArray.stableSortBy` except the comparator is fixed.
-
-## binarySearch
-
-```res sig
-let binarySearch: (array<element>, element) => int
-```
-
-If value is not found and value is less than one or more elements in array, the negative number returned is the bitwise complement of the index of the first element that is larger than value.
-
-If value is not found and value is greater than all elements in array, the negative number returned is the bitwise complement of (the index of the last element plus 1)
-
-for example, if `key` is smaller than all elements return `-1` since `lnot(-1) = 0` if `key` is larger than all elements return `- (len + 1)` since `lnot(-(len+1)) = len`.
diff --git a/pages/docs/manual/v9.0.0/api/belt/sort-array.mdx b/pages/docs/manual/v9.0.0/api/belt/sort-array.mdx
deleted file mode 100644
index 7ea25b672..000000000
--- a/pages/docs/manual/v9.0.0/api/belt/sort-array.mdx
+++ /dev/null
@@ -1,111 +0,0 @@
-# SortArray
-
-## SortArrayInt
-
-```res example
-module Int = Belt.SortArray.Int
-```
-
-Specalized when key type is `int`, more efficient than the generic type
-
-## SortArrayString
-
-```res example
-module String = Belt.SortArray.String
-```
-
-Specalized when key type is `string`, more efficient than the generic type
-
-## strictlySortedLengthU
-
-```res sig
-let strictlySortedLengthU: (array<'a>, (. 'a, 'a) => bool) => int
-```
-
-## strictlySortedLength
-
-```res sig
-let strictlySortedLength: (array<'a>, ('a, 'a) => bool) => int
-```
-
-`strictlySortedLenght(xs, cmp);` return `+n` means increasing order `-n` means negative order
-
-```res example
-Belt.SortArray.strictlySortedLength([1, 2, 3, 4, 3], (x, y) => x < y) == 4
-
-Belt.SortArray.strictlySortedLength([], (x, y) => x < y) == 0
-
-Belt.SortArray.strictlySortedLength([1], (x, y) => x < y) == 1
-
-Belt.SortArray.strictlySortedLength([4, 3, 2, 1], (x, y) => x < y) == -4
-```
-
-## isSortedU
-
-```res sig
-let isSortedU: (array<'a>, (. 'a, 'a) => int) => bool
-```
-
-## isSorted
-
-```res sig
-let isSorted: (array<'a>, ('a, 'a) => int) => bool
-```
-
-`isSorted(arr, cmp)`: Returns true if array is increasingly sorted (equal is okay)
-
-## stableSortInPlaceByU
-
-```res sig
-let stableSortInPlaceByU: (array<'a>, (. 'a, 'a) => int) => unit
-```
-
-## stableSortInPlaceBy
-
-```res sig
-let stableSortInPlaceBy: (array<'a>, ('a, 'a) => int) => unit
-```
-
-## stableSortByU
-
-```res sig
-let stableSortByU: (array<'a>, (. 'a, 'a) => int) => array<'a>
-```
-
-## stableSortBy
-
-```res sig
-let stableSortBy: (array<'a>, ('a, 'a) => int) => array<'a>
-```
-
-`stableSortBy(xs, cmp)`: Returns a fresh array Sort `xs` in place using
-comparator `cmp`, the stable means if the elements are equal, their order will
-be preserved
-
-## binarySearchByU
-
-```res sig
-let binarySearchByU: (array<'a>, 'a, (. 'a, 'a) => int) => int
-```
-
-## binarySearchBy
-
-```res sig
-let binarySearchBy: (array<'a>, 'a, ('a, 'a) => int) => int
-```
-
-If value is not found and value is less than one or more elements in array, the
-negative number returned is the bitwise complement of the index of the first
-element that is larger than value.
-
-If value is not found and value is greater
-than all elements in array, the negative number returned is the bitwise
-complement of (the index of the last element plus 1)for example, if `key` is
-smaller than all elements return `-1` since `lnot(-1) == 0` if `key` is larger
-than all elements return `lnot(-1) == 0` since `lnot(- (len + 1)) == len`
-
-```res example
-Belt.SortArray.binarySearchBy([1, 2, 3, 4, 33, 35, 36], 33, Pervasives.compare) == 4
-
-lnot(Belt.SortArray.binarySearchBy([1, 3, 5, 7], 4, Pervasives.compare)) == 2
-```
diff --git a/pages/docs/manual/v9.0.0/api/dom.mdx b/pages/docs/manual/v9.0.0/api/dom.mdx
deleted file mode 100644
index eee448156..000000000
--- a/pages/docs/manual/v9.0.0/api/dom.mdx
+++ /dev/null
@@ -1,855 +0,0 @@
-# Dom
-
-<Intro>
-
-The Dom module offers a canonical set of dom related types that third party libraries can depend on. It only provides types, no functions to manipulate the values of certain types whatsoever.
-
-</Intro>
-
-## animation
-
-```res sig
-type animation
-```
-
-## cssStyleDeclaration
-
-```res sig
-type cssStyleDeclaration
-```
-
-## cssStyleSheet
-
-```res sig
-type cssStyleSheet
-```
-
-## node
-
-```res sig
-type node
-```
-
-## characterData
-
-```res sig
-type characterData
-```
-
-## cdataSection
-
-```res sig
-type cdataSection
-```
-
-## comment
-
-```res sig
-type comment
-```
-
-## document
-
-```res sig
-type document
-```
-
-## documentType
-
-```res sig
-type documentType
-```
-
-## domImplementation
-
-```res sig
-type domImplementation
-```
-
-## element
-
-```res sig
-type element
-```
-
-## htmlCollection
-
-```res sig
-type htmlCollection
-```
-
-## htmlFormControlsCollection
-
-```res sig
-type htmlFormControlsCollection
-```
-
-## htmlOptionsCollection
-
-```res sig
-type htmlOptionsCollection
-```
-
-## intersectionObserver
-
-```res sig
-type intersectionObserver
-```
-
-## intersectionObserverEntry
-
-```res sig
-type intersectionObserverEntry
-```
-
-## mutationObserver
-
-```res sig
-type mutationObserver
-```
-
-## mutationRecord
-
-```res sig
-type mutationRecord
-```
-
-## performanceObserver
-
-```res sig
-type performanceObserver
-```
-
-## performanceObserverEntryList
-
-```res sig
-type performanceObserverEntryList
-```
-
-## reportingObserver
-
-```res sig
-type reportingObserver
-```
-
-## reportingObserverOptions
-
-```res sig
-type reportingObserverOptions
-```
-
-## resizeObserver
-
-```res sig
-type resizeObserver
-```
-
-## resizeObserverEntry
-
-```res sig
-type resizeObserverEntry
-```
-
-## namedNodeMap
-
-```res sig
-type namedNodeMap
-```
-
-## nodeList
-
-```res sig
-type nodeList
-```
-
-## radioNodeList
-
-```res sig
-type radioNodeList
-```
-
-## processingInstruction
-
-```res sig
-type processingInstruction
-```
-
-## shadowRoot
-
-```res sig
-type shadowRoot
-```
-
-## text
-
-```res sig
-type text
-```
-
-## domRect
-
-```res sig
-type domRect
-```
-
-## dataTransfer
-
-```res sig
-type dataTransfer
-```
-
-## domStringMap
-
-```res sig
-type domStringMap
-```
-
-## history
-
-```res sig
-type history
-```
-
-## htmlDocument
-
-```res sig
-type htmlDocument
-```
-
-## htmlElement
-
-```res sig
-type htmlElement
-```
-
-## htmlAnchorElement
-
-```res sig
-type htmlAnchorElement
-```
-
-## htmlAreaElement
-
-```res sig
-type htmlAreaElement
-```
-
-## htmlAudioElement
-
-```res sig
-type htmlAudioElement
-```
-
-## htmlBaseElement
-
-```res sig
-type htmlBaseElement
-```
-
-## htmlBodyElement
-
-```res sig
-type htmlBodyElement
-```
-
-## htmlBrElement
-
-```res sig
-type htmlBrElement
-```
-
-## htmlButtonElement
-
-```res sig
-type htmlButtonElement
-```
-
-## htmlCanvasElement
-
-```res sig
-type htmlCanvasElement
-```
-
-## htmlDataElement
-
-```res sig
-type htmlDataElement
-```
-
-## htmlDataListElement
-
-```res sig
-type htmlDataListElement
-```
-
-## htmlDialogElement
-
-```res sig
-type htmlDialogElement
-```
-
-## htmlDivElement
-
-```res sig
-type htmlDivElement
-```
-
-## htmlDlistElement
-
-```res sig
-type htmlDlistElement
-```
-
-## htmlEmbedElement
-
-```res sig
-type htmlEmbedElement
-```
-
-## htmlFieldSetElement
-
-```res sig
-type htmlFieldSetElement
-```
-
-## htmlFormElement
-
-```res sig
-type htmlFormElement
-```
-
-## htmlHeadElement
-
-```res sig
-type htmlHeadElement
-```
-
-## htmlHeadingElement
-
-```res sig
-type htmlHeadingElement
-```
-
-## htmlHrElement
-
-```res sig
-type htmlHrElement
-```
-
-## htmlHtmlElement
-
-```res sig
-type htmlHtmElement
-```
-
-## htmlIframeElement
-
-```res sig
-type htmlIframeElement
-```
-
-## htmlImageElement
-
-```res sig
-type htmlImageElement
-```
-
-## htmlInputElement
-
-```res sig
-type htmlInputElement
-```
-
-## htmlLabelElement
-
-```res sig
-type htmlLabelElement
-```
-
-## htmlLegendElement
-
-```res sig
-type htmlLegendElement
-```
-
-## htmlLiElement
-
-```res sig
-type htmlLiElement
-```
-
-## htmlLinkElement
-
-```res sig
-type htmlLinkElement
-```
-
-## htmlMapElement
-
-```res sig
-type htmlMapElement
-```
-
-## htmlMediaElement
-
-```res sig
-type htmlMediaElement
-```
-
-## htmlMenuElement
-
-```res sig
-type htmlMenuElement
-```
-
-## htmlMetaElement
-
-```res sig
-type htmlMetaElement
-```
-
-## htmlMeterElement
-
-```res sig
-type htmlMeterElement
-```
-
-## htmlModElement
-
-```res sig
-type htmlModElement
-```
-
-## htmlOListElement
-
-```res sig
-type htmlOListElement
-```
-
-## htmlObjectElement
-
-```res sig
-type htmlObjectElement
-```
-
-## htmlOptGroupElement
-
-```res sig
-type htmlOptGroupElement
-```
-
-## htmlOptionElement
-
-```res sig
-type htmlOptionElement
-```
-
-## htmlOutputElement
-
-```res sig
-type htmlOutputElement
-```
-
-## htmlParagraphElement
-
-```res sig
-type htmlParagraphElement
-```
-
-## htmlParamElement
-
-```res sig
-type htmlParamElement
-```
-
-## htmlPreElement
-
-```res sig
-type htmlPreElement
-```
-
-## htmlProgressElement
-
-```res sig
-type htmlProgressElement 
-```
-
-## htmlQuoteElement
-
-```res sig
-type  htmlQuoteElement
-```
-
-## htmlScriptElement
-
-```res sig
-type htmlScriptElement
-```
-
-## htmlSelectElement
-
-```res sig
-type htmlSelectElement 
-```
-
-## htmlSlotElement
-
-```res sig
-type htmlSlotElement
-```
-
-## htmlSourceElement
-
-```res sig
-type htmlSourceElement
-```
-
-## htmlSpanElement
-
-```res sig
-type htmlSpanElement
-```
-
-## htmlStyleElement
-
-```res sig
-type htmlStyleElement
-```
-
-## htmlTableCaptionElement
-
-```res sig
-type htmlTableCaptionElement
-```
-
-## htmlTableCellElement
-
-```res sig
-type htmlTableCellElement
-```
-
-## htmlTableColElement
-
-```res sig
-type htmlTableColElement
-```
-
-## htmlTableDataCellElement
-
-```res sig
-type htmlTableDataCellElement
-```
-
-## htmlTableElement
-
-```res sig
-type htmlTableElement
-```
-
-## htmlTableHeaderCellElement
-
-```res sig
-type htmlTableHeaderCellElement
-```
-
-## htmlTableRowElement
-
-```res sig
-type htmlTableRowElement
-```
-
-## htmlTableSectionElement
-
-```res sig
-type htmlTableSectionElement
-```
-
-## htmlTextAreaElement
-
-```res sig
-type htmlTextAreaElement
-```
-
-## htmlTimeElement
-
-```res sig
-type htmlTimeElement
-```
-
-## htmlTitleElement
-
-```res sig
-type htmlTitleElement
-```
-
-## htmlTrackElement
-
-```res sig
-type htmlTrackElement
-```
-
-## htmlUlistElement
-
-```res sig
-type htmlUlistElement
-```
-
-## htmlUnknownElement
-
-```res sig
-type htmlUnknownElement
-```
-
-## htmlVideoElement
-
-```res sig
-type htmlVideoElement
-```
-
-## location
-
-```res sig
-type location
-```
-
-## window
-
-```res sig
-type window
-```
-
-## xmlDocument
-
-```res sig
-type xmlDocument
-```
-
-## event
-
-```res sig
-type event
-```
-
-## uiEvent 
-
-```res sig
-type uiEvent
-```
-
-## animationEvent
-
-```res sig
-type animationEvent
-```
-
-## beforeUnloadEvent
-
-```res sig
-type beforeUnloadEvent
-```
-
-## clipboardEvent
-
-```res sig
-type clipboardEvent
-```
-
-## closeEvent
-
-```res sig
-type closeEvent
-```
-
-## compositionEvent
-
-```res sig
-type compositionEvent
-```
-
-## customEvent
-
-```res sig
-type customEvent
-```
-
-## dragEvent
-
-```res sig
-type dragEvent
-```
-
-## errorEvent
-
-```res sig
-type errorEvent
-```
-
-## focusEvent
-
-```res sig
-type focusEvent
-```
-
-## idbVersionChangeEvent
-
-```res sig
-type idbVersionChangeEvent
-```
-
-## inputEvent
-
-```res sig
-type inputEvent
-```
-
-## keyboardEvent
-
-```res sig
-type keyboardEvent
-```
-
-## mouseEvent
-
-```res sig
-type mouseEvent
-```
-
-## pageTransitionEvent
-
-```res sig
-type pageTransitionEvent
-```
-
-## pointerEvent
-
-```res sig
-type pointerEvent
-```
-
-## popStateEvent
-
-```res sig
-type popStateEvent
-```
-
-## progressEvent
-
-```res sig
-type progressEvent
-```
-
-## relatedEvent
-
-```res sig
-type relatedEvent
-```
-
-## storageEvent
-
-```res sig
-type storageEvent
-```
-
-## svgZoomEvent
-
-```res sig
-type svgZoomEvent
-```
-
-## timeEvent
-
-```res sig
-type timeEvent
-```
-
-## touchEvent
-
-```res sig
-type touchEvent
-```
-
-## trackEvent
-
-```res sig
-type trackEvent
-```
-
-## transitionEvent
-
-```res sig
-type transitionEvent
-```
-
-## webGlContextEvent
-
-```res sig
-type webGlContextEvent
-```
-
-## wheelEvent
-
-```res sig
-type wheelEvent
-```
-
-## range
-
-```res sig
-type range
-```
-
-## selection
-
-```res sig
-type selection
-```
-
-## domTokenList
-
-```res sig
-type domTokenList
-```
-
-## domSettableTokenList
-
-```res sig
-type domSettableTokenList
-```
-
-## nodeFilter
-
-```res sig
-type nodeFilter = {
-  acceptNode: (Dom.element) => int
-}
-```
-
-## nodeIterator
-
-```res sig
-type nodeIterator
-```
-
-## treeWalker
-
-```res sig
-type treeWalker
-```
-
-## svgRect
-
-```res sig
-type svgRect
-```
-
-## svgPoint
-
-```res sig
-type svgPoint
-```
-
-## eventPointerId
-
-```res sig
-type eventPointerId
-```
diff --git a/pages/docs/manual/v9.0.0/api/dom/storage.mdx b/pages/docs/manual/v9.0.0/api/dom/storage.mdx
deleted file mode 100644
index 412cae405..000000000
--- a/pages/docs/manual/v9.0.0/api/dom/storage.mdx
+++ /dev/null
@@ -1,55 +0,0 @@
-# Storage
-
-## t
-
-```res prelude sig
-type t
-```
-
-## getItem
-
-```res sig
-external getItem: (string, t) => option<string> = "getItem"
-```
-
-## setItem
-
-```res sig
-external setItem: (string, string, t) => unit = "setItem"
-```
-
-## removeItem
-
-```res sig
-external removeItem: (string, t) => unit = "removeItem"
-```
-
-## clear
-
-```res sig
-external clear: t => unit = "clear"
-```
-
-## key
-
-```res sig
-external key: (int, t) => option<string> = "key"
-```
-
-## length
-
-```res sig
-external length: t => int = "length"
-```
-
-## localStorage
-
-```res sig
-@bs.val external localStorage: t = "localStorage"
-```
-
-## sessionStorage
-
-```res sig
-@bs.val external sessionStorage: t = "sessionStorage"
-```
diff --git a/pages/docs/manual/v9.0.0/api/dom/storage2.mdx b/pages/docs/manual/v9.0.0/api/dom/storage2.mdx
deleted file mode 100644
index a126b6c14..000000000
--- a/pages/docs/manual/v9.0.0/api/dom/storage2.mdx
+++ /dev/null
@@ -1,61 +0,0 @@
-# Storage2
-
-<Intro>
-
-The same as [Dom.Storage](./storage2), but with `t` on first argument position for proper `->` usage.
-
-</Intro>
-
-## t
-
-```res prelude sig
-type t
-```
-
-## getItem
-
-```res sig
-external getItem: (t, string) => option<string> = "getItem"
-```
-
-## setItem
-
-```res sig
-external setItem: (t, string, string) => unit = "setItem"
-```
-
-## removeItem
-
-```res sig
-external removeItem: (t, string) => unit = "removeItem"
-```
-
-## clear
-
-```res sig
-external clear: t => unit = "clear"
-```
-
-## key
-
-```res sig
-external key: (t, int) => option<string> = "key"
-```
-
-## length
-
-```res sig
-external length: t => int = "length"
-```
-
-## localStorage
-
-```res sig
-@bs.val external localStorage: t = "localStorage"
-```
-
-## sessionStorage
-
-```res sig
-@bs.val external sessionStorage: t = "sessionStorage"
-```
diff --git a/pages/docs/manual/v9.0.0/api/js.mdx b/pages/docs/manual/v9.0.0/api/js.mdx
deleted file mode 100644
index d3aea4c57..000000000
--- a/pages/docs/manual/v9.0.0/api/js.mdx
+++ /dev/null
@@ -1,178 +0,0 @@
-# Js
-
-The Js module mostly contains ReScript bindings to _standard JavaScript APIs_
-like [console.log](https://developer.mozilla.org/en-US/docs/Web/API/Console/log),
-or the JavaScript
-[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String),
-[Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date), and
-[Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
-classes.
-
-It is meant as a zero-abstraction interop layer and directly exposes JavaScript functions as they are. If you can find your API in this module, prefer this over an equivalent Belt helper. For example, prefer [Js.Array2](js/array-2) over [Belt.Array](belt/array)
-
-## Argument Order
-
-For historical reasons, some APIs in the Js namespace (e.g. [Js.String](js/string)) are
-using the data-last argument order whereas others (e.g. [Js.Date](js/date)) are using data-first.
-
-For more information about these argument orders and the trade-offs between them, see
-[this blog post](https://www.javierchavarri.com/data-first-and-data-last-a-comparison/).
-
-_Eventually, all modules in the Js namespace are going to be migrated to data-first though._
-
-In the meantime, there are several options for dealing with the data-last APIs:
-
-```res example
-/* Js.String (data-last API used with pipe last operator) */
-Js.log("2019-11-10" |> Js.String.split("-"))
-Js.log("ReScript" |> Js.String.startsWith("Re"))
-
-/* Js.String (data-last API used with pipe first operator) */
-Js.log("2019-11-10"->Js.String.split("-", _))
-Js.log("ReScript"->Js.String.startsWith("Re", _))
-
-/* Js.String (data-last API used without any piping) */
-Js.log(Js.String.split("-", "2019-11-10"))
-Js.log(Js.String.startsWith("Re", "ReScript"))
-```
-## Js.Xxx2 Modules
-
-Prefer `Js.Array2` over `Js.Array`, `Js.String2` over `Js.String`, etc. The latters are old modules.
-
-## Object
-
-```res sig
-type t<+'a>
-```
-
-Js object type.
-
-```res example
-let x: {"x": int, "y": int} = {"x": 1, "y": 2}
-```
-
-## Nullable and Undefined
-
-```res prelude
-type null<+'a>
-```
-
-nullable, value of this type can be either null or 'a this type is the same as type t in Js.Null
-
-```res prelude
-type undefined<+'a>
-```
-
-value of this type can be either undefined or 'a this type is the same as type t in Js.Undefined
-
-```res prelude
-type nullable<+'a>
-```
-
-value of this type can be undefined, null or 'a this type is the same as type t n Js.Null_undefined
-
-```res prelude
-type null_undefined<'a> = Js.nullable<'a>
-```
-
-```res sig
-let toOption: Js.nullable<'a> => option<'a>
-```
-
-```res sig
-let undefinedToOption: Js.undefined<'a> => option<'a>
-```
-
-```res sig
-let nullToOption: Js.null<'a> => option<'a>
-```
-
-```res sig
-let test: Js.nullable<'a> => bool
-```
-
-```res sig
-let isNullable: Js.nullable<'a> => bool
-```
-
-```res sig
-let testAny: 'a => bool
-```
-
-The same as `Js.test` except that it is more permissive on the types of input.
-
-```res sig
-type promise<+'a, +'e>
-```
-
-Deprecated. please use `Js.Promise`.
-The promise type, defined here for interoperation across packages.
-
-```res sig
-let null: Js.null<'a>
-```
-
-The same as empty in `Js.Null`. Will be compiled as `null`.
-
-```res sig
-let undefined: Js.undefined<'a>
-```
-
-The same as empty `Js.Undefined`. Will be compiled as `undefined`.
-
-## TypeOf
-
-```res sig
-let typeof: 'a => string
-```
-
-`typeof x` will be compiled as `typeof x` in JS. Please consider functions in `Js.Types` for a type safe way of reflection.
-
-## Logging
-
-```res sig
-let log: 'a => unit
-let log2: ('a, 'b) => unit
-let log3: ('a, 'b, 'c) => unit
-let log4: ('a, 'b, 'c, 'd) => unit
-```
-
-A convenience function to log everything.
-
-```res sig
-let logMany: array<'a> => unit
-```
-
-A convenience function to log more than 4 arguments
-
-## Comparison
-
-```res sig
-let eqNull: ('a, null<'a>) => bool
-let eqUndefined: ('a, undefined<'a>) => bool
-let eqNullable: ('a, nullable<'a>) => bool
-```
-
-```res sig
-let unsafe_lt: ('a, 'a) => bool
-```
-
-`unsafe_lt a b` will be compiled as `a < b`. It is marked as unsafe, since it is impossible to give a proper semantics for comparision which applies to any type.
-
-```res sig
-let unsafe_le: ('a, 'a) => bool
-```
-
-`unsafe_le a b` will be compiled as `a <= b`. See also `Js.unsafe_lt`.
-
-```res sig
-let unsafe_gt: ('a, 'a) => bool
-```
-
-`unsafe_gt a b` will be compiled as `a > b`. See also `Js.unsafe_lt`.
-
-```res sig
-let unsafe_ge: ('a, 'a) => bool
-```
-
-`unsafe_ge a b` will be compiled as `a >= b`. See also `Js.unsafe_lt`.
diff --git a/pages/docs/manual/v9.0.0/api/js/array-2.mdx b/pages/docs/manual/v9.0.0/api/js/array-2.mdx
deleted file mode 100644
index 393134ce6..000000000
--- a/pages/docs/manual/v9.0.0/api/js/array-2.mdx
+++ /dev/null
@@ -1,850 +0,0 @@
-# Array2
-
-<Intro>
-
-Provides bindings to JavaScript’s `Array` functions. These bindings are optimized for pipe-first (`->`), where the array to be processed is the first parameter in the function.
-
-Here is an example to find the sum of squares of all even numbers in an array.
-Without pipe first, we must call the functions in reverse order:
-
-```res example
-let isEven = x => mod(x, 2) == 0
-let square = x => x * x
-let result = {
-  open Js.Array2
-  reduce(map(filter([5, 2, 3, 4, 1], isEven), square), \"+", 0)
-}
-```
-
-With pipe first, we call the functions in the “natural” order:
-
-```res example
-let isEven = x => mod(x, 2) == 0
-let square = x => x * x
-let result = {
-  open Js.Array2
-  [5, 2, 3, 4, 1]->filter(isEven)->map(square)->reduce(\"+", 0)
-}
-```
-</Intro>
-
-## t
-
-```res prelude
-type t<'a> = array<'a>
-```
-
-The type used to describe a JavaScript array.
-
-## array_like
-
-```res prelude
-type array_like<'a>
-```
-
-A type used to describe JavaScript objects that are like an array or are iterable.
-
-## from
-
-```res sig
-let from: array_like<'a> => array<'a>
-```
-
-Creates a shallow copy of an array from an array-like object. See [`Array.from`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from) on MDN.
-
-```res example
-let strArr = Js.String.castToArrayLike("abcd")
-Js.Array2.from(strArr) == ["a", "b", "c", "d"]
-```
-
-## fromMap
-
-```res sig
-let fromMap: (array_like<'a>, 'a => 'b) => array<'b>
-```
-
-Creates a new array by applying a function (the second argument) to each item in the `array_like` first argument.  See [`Array.from`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from) on MDN.
-
-```res example
-let strArr = Js.String.castToArrayLike("abcd")
-let code = s => Js.String.charCodeAt(0, s)
-Js.Array2.fromMap(strArr, code) == [97.0, 98.0, 99.0, 100.0]
-```
-
-## isArray
-
-```res sig
-let isArray: 'a => bool
-```
-
-Returns `true` if its argument is an array; `false` otherwise. This is a runtime check, which is why the second example returns `true`---a list is internally represented as a nested JavaScript array.
-
-```res example
-Js.Array2.isArray([5, 2, 3, 1, 4]) == true
-Js.Array2.isArray(list{5, 2, 3, 1, 4}) == true
-Js.Array2.isArray("abcd") == false
-```
-
-## length
-
-```res sig
-let length: array<'a> => int
-```
-
-Returns the number of elements in the array. See [`Array.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length) on MDN.
-
-## copyWithin
-
-```res sig
-let copyWithin: (t<'a>, ~to_: int) => t<'a>
-```
-
-Copies from the first element in the given array to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array2.copyWithin(arr, ~to_=2) == [100, 101, 100, 101, 102]
-arr == [100, 101, 100, 101, 102]
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (t<'a>, ~to_: int, ~from: int) => t<'a>
-```
-
-Copies starting at element `~from` in the given array to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array2.copyWithinFrom(arr, ~from=2, ~to_=0) == [102, 103, 104, 103, 104]
-arr == [102, 103, 104, 103, 104]
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (t<'a>, ~to_: int, ~start: int, ~end_: int) => t<'a>
-```
-
-Copies starting at element `~start` in the given array up to but not including `~end_` to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104, 105]
-Js.Array2.copyWithinFromRange(arr, ~start=2, ~end_=5, ~to_=1) == [100, 102, 103, 104, 104, 105]
-arr == [100, 102, 103, 104, 104, 105]
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (t<'a>, 'a) => t<'a>
-```
-Sets all elements of the given array (the first arumgent) to the designated value (the secon argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array2.fillInPlace(arr, 99) == [99, 99, 99, 99, 99]
-arr == [99, 99, 99, 99, 99]
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (t<'a>, 'a, ~from: int) => t<'a>
-```
-Sets all elements of the given array (the first arumgent) from position `~from` to the end to the designated value (the second argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array2.fillFromInPlace(arr, 99, ~from=2) == [100, 101, 99, 99, 99]
-arr == [100, 101, 99, 99, 99]
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (t<'a>, 'a, ~start: int, ~end_: int) => t<'a>
-```
-Sets the elements of the given array (the first arumgent) from position `~start` up to but not including position `~end_` to the designated value (the second argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array2.fillRangeInPlace(arr, 99, ~start=1, ~end_=4) == [100, 99, 99, 99, 104]
-arr == [100, 99, 99, 99, 104]
-```
-
-## pop
-
-```res sig
-let pop: t<'a> => option<'a>
-```
-If the array is not empty, removes the last element and returns it as `Some(value)`; returns `None` if the array is empty. *This function modifies the original array.* See [`Array.pop`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array2.pop(arr) == Some(104)
-arr == [100, 101, 102, 103]
-
-let empty: array<int> = []
-Js.Array2.pop(empty) == None
-```
-
-## push
-
-```res sig
-let push: (t<'a>, 'a) => int
-```
-Appends the given value to the array, returning the number of elements in the updated array. *This function modifies the original array.* See [`Array.push`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) on MDN.
-
-```res example
-let arr = ["ant", "bee", "cat"]
-Js.Array2.push(arr, "dog") == 4
-arr == ["ant", "bee", "cat", "dog"]
-```
-
-## pushMany
-
-```res sig
-let pushMany: (t<'a>, array<'a>) => int
-```
-Appends the values from one array (the second argument) to another (the first argument), returning the number of elements in the updated array. *This function modifies the original array.* See [`Array.push`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) on MDN.
-
-```res example
-let arr = ["ant", "bee", "cat"]
-Js.Array2.pushMany(arr, ["dog", "elk"]) == 5
-arr == ["ant", "bee", "cat", "dog", "elk"]
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t<'a> => t<'a>
-```
-Returns an array with the elements of the input array in reverse order. *This function modifies the original array.* See [`Array.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse) on MDN.
-
-```res example
-let arr = ["ant", "bee", "cat"]
-Js.Array2.reverseInPlace(arr) == ["cat", "bee", "ant"]
-arr == ["cat", "bee", "ant"]
-```
-
-## shift
-
-```res sig
-let shift: t<'a> => option<'a>
-```
-If the array is not empty, removes the first element and returns it as `Some(value)`; returns `None` if the array is empty. *This function modifies the original array.* See [`Array.shift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array2.shift(arr) == Some(100)
-arr == [101, 102, 103, 104]
-
-let empty: array<int> = []
-Js.Array2.shift(empty) == None
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t<'a> => t<'a>
-```
-Sorts the given array in place and returns the sorted array. JavaScript sorts the array by converting the arguments to UTF-16 strings and sorting them. See the second example with sorting numbers, which does not do a numeric sort. *This function modifies the original array.* See [`Array.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) on MDN.
-
-```res example
-let words = ["bee", "dog", "ant", "cat"]
-Js.Array2.sortInPlace(words) == ["ant", "bee", "cat", "dog"]
-words == ["ant", "bee", "cat", "dog"]
-
-let numbers = [3, 30, 10, 1, 20, 2]
-Js.Array2.sortInPlace(numbers) == [1, 10, 2, 20, 3, 30]
-numbers == [1, 10, 2, 20, 3, 30]
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: (t<'a>, ('a, 'a) => int) => t<'a>
-```
-Sorts the given array in place and returns the sorted array. *This function modifies the original array.*
-
-The first argument to `sortInPlaceWith()` is a function that compares two items from the array and returns:
-
-* an integer less than zero if the first item is less than the second item
-* zero if the items are equal
-* an integer greater than zero if the first item is greater than the second item
-
-See [`Array.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) on MDN.
-
-```res example
-// sort by word length
-let words = ["horse", "aardvark", "dog", "camel"]
-let byLength = (s1, s2) => Js.String.length(s1) - Js.String.length(s2)
-
-Js.Array2.sortInPlaceWith(words, byLength) == ["dog", "horse", "camel", "aardvark"]
-
-// sort in reverse numeric order
-let numbers = [3, 30, 10, 1, 20, 2]
-let reverseNumeric = (n1, n2) => n2 - n1
-Js.Array2.sortInPlaceWith(numbers, reverseNumeric) == [30, 20, 10, 3, 2, 1]
-```
-
-## spliceInPlace
-
-```res sig
-let spliceInPlace: (t<'a>, ~pos: int, ~remove: int, ~add: array<'a>) => t<'a>
-```
-Starting at position `~pos`, remove `~remove` elements and then add the elements from the `~add` array. Returns an array consisting of the removed items. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```res example
-let arr = ["a", "b", "c", "d", "e", "f"]
-Js.Array2.spliceInPlace(arr, ~pos=2, ~remove=2, ~add=["x", "y", "z"]) == ["c", "d"]
-arr == ["a", "b", "x", "y", "z", "e", "f"]
-
-let arr2 = ["a", "b", "c", "d"]
-Js.Array2.spliceInPlace(arr2, ~pos=3, ~remove=0, ~add=["x", "y"]) == []
-arr2 == ["a", "b", "c", "x", "y", "d"]
-
-let arr3 = ["a", "b", "c", "d", "e", "f"]
-Js.Array2.spliceInPlace(arr3, ~pos=9, ~remove=2, ~add=["x", "y", "z"]) == []
-arr3 == ["a", "b", "c", "d", "e", "f", "x", "y", "z"]
-```
-
-## removeFromInPlace
-
-```res sig
-let removeFromInPlace: (t<'a>, ~pos: int) => t<'a>
-```
-Removes elements from the given array starting at position `~pos` to the end of the array, returning the removed elements. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```res example
-let arr = ["a", "b", "c", "d", "e", "f"]
-Js.Array2.removeFromInPlace(arr, ~pos=4) == ["e", "f"]
-arr == ["a", "b", "c", "d"]
-```
-
-## removeCountInPlace
-
-```res sig
-let removeCountInPlace: (t<'a>, ~pos: int, ~count: int) => t<'a>
-```
-Removes `~count` elements from the given array starting at position `~pos`, returning the removed elements. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```res example
-let arr = ["a", "b", "c", "d", "e", "f"]
-Js.Array2.removeCountInPlace(arr, ~pos=2, ~count=3) == ["c", "d", "e"]
-arr == ["a", "b", "f"]
-```
-
-## unshift
-
-```res sig
-let unshift: (t<'a>, 'a) => int
-```
-Adds the given element to the array, returning the new number of elements in the array. *This function modifies the original array.* See [`Array.unshift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) on MDN.
-
-```res example
-let arr = ["b", "c", "d"]
-Js.Array2.unshift(arr, "a") == 4
-arr == ["a", "b", "c", "d"]
-```
-
-## unshiftMany
-
-```res sig
-let unshiftMany: (t<'a>, array<'a>) => int
-```
-Adds the elements in the second array argument at the beginning of the first array argument, returning the new number of elements in the array. *This function modifies the original array.* See [`Array.unshift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) on MDN.
-
-```res example
-let arr = ["d", "e"]
-Js.Array2.unshiftMany(arr, ["a", "b", "c"]) == 5
-arr == ["a", "b", "c", "d", "e"]
-```
-
-## append
-
-```res sig
-let append: (t<'a>, 'a) => t<'a>
-```
-Deprecated. `append()` is not type-safe. Use `concat()` instead.
-
-## concat
-
-```res sig
-let concat: (t<'a>, t<'a>) => t<'a>
-```
-Concatenates the second array argument to the first array argument, returning a new array. The original arrays are not modified. See [`Array.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat) on MDN.
-
-```res example
-Js.Array2.concat(["a", "b"], ["c", "d", "e"]) == ["a", "b", "c", "d", "e"]
-```
-
-## concatMany
-
-```res sig
-let concatMany: (t<'a>, array<t<'a>>) => t<'a>
-```
-The second argument to `concatMany()` is an array of arrays; these are added at the end of the first argument, returning a new array. See [`Array.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat) on MDN.
-
-```res example
-Js.Array2.concatMany(["a", "b", "c"], [["d", "e"], ["f", "g", "h"]]) == [
-    "a",
-    "b",
-    "c",
-    "d",
-    "e",
-    "f",
-    "g",
-    "h",
-  ]
-```
-
-## includes
-
-```res sig
-let includes: (t<'a>, 'a) => bool
-```
-Returns true if the given value is in the array, `false` otherwise. See [`Array.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes) on MDN.
-
-```res example
-Js.Array2.includes(["a", "b", "c"], "b") == true
-Js.Array2.includes(["a", "b", "c"], "x") == false
-```
-
-## indexOf
-
-```res sig
-let indexOf: (t<'a>, 'a) => int
-```
-Returns the index of the first element in the array that has the given value. If the value is not in the array, returns -1. See [`Array.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf) on MDN.
-
-```res example
-Js.Array2.indexOf([100, 101, 102, 103], 102) == 2
-Js.Array2.indexOf([100, 101, 102, 103], 999) == -1
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (t<'a>, 'a, ~from: int) => int
-```
-Returns the index of the first element in the array with the given value. The search starts at position `~from`. See [`Array.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf) on MDN.
-
-```res example
-Js.Array2.indexOfFrom(["a", "b", "a", "c", "a"], "a", ~from=2) == 2
-Js.Array2.indexOfFrom(["a", "b", "a", "c", "a"], "a", ~from=3) == 4
-Js.Array2.indexOfFrom(["a", "b", "a", "c", "a"], "b", ~from=2) == -1
-```
-
-## joinWith
-
-```res sig
-let joinWith: (t<'a>, string) => string
-```
-This function converts each element of the array to a string (via JavaScript) and concatenates them, separated by the string given in the first argument, into a single string. See [`Array.join`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join) on MDN.
-
-```res example
-Js.Array2.joinWith(["ant", "bee", "cat"], "--") == "ant--bee--cat"
-Js.Array2.joinWith(["door", "bell"], "") == "doorbell"
-Js.Array2.joinWith([2020, 9, 4], "/") == "2020/9/4"
-Js.Array2.joinWith([2.5, 3.6, 3e-2], ";") == "2.5;3.6;0.03"
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (t<'a>, 'a) => int
-```
-Returns the index of the last element in the array that has the given value. If the value is not in the array, returns -1. See [`Array.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) on MDN.
-
-```res example
-Js.Array2.lastIndexOf(["a", "b", "a", "c"], "a") == 2
-Js.Array2.lastIndexOf(["a", "b", "a", "c"], "x") == -1
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (t<'a>, 'a, ~from: int) => int
-```
-Returns the index of the last element in the array that has the given value, searching from position `~from` down to the start of the array. If the value is not in the array, returns -1. See [`Array.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) on MDN.
-
-```res example
-Js.Array2.lastIndexOfFrom(["a", "b", "a", "c", "a", "d"], "a", ~from=3) == 2
-Js.Array2.lastIndexOfFrom(["a", "b", "a", "c", "a", "d"], "c", ~from=2) == -1
-```
-
-## slice
-
-```res sig
-let slice: (t<'a>, ~start: int, ~end_: int) => t<'a>
-```
-Returns a shallow copy of the given array from the `~start` index up to but not including the `~end_` position. Negative numbers indicate an offset from the end of the array. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104, 105, 106]
-Js.Array2.slice(arr, ~start=2, ~end_=5) == [102, 103, 104]
-Js.Array2.slice(arr, ~start=-3, ~end_=-1) == [104, 105]
-Js.Array2.slice(arr, ~start=9, ~end_=10) == []
-```
-
-## copy
-
-```res sig
-let copy: t<'a> => t<'a>
-```
-Returns a copy of the entire array. Same as `Js.Array2.Slice(arr, ~start=0, ~end_=Js.Array2.length(arr))`. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-## sliceFrom
-
-```res sig
-let sliceFrom: (t<'a>, int) => t<'a>
-```
-Returns a shallow copy of the given array from the given index to the end. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-
-```res example
-Js.Array2.sliceFrom([100, 101, 102, 103, 104], 2) == [102, 103, 104]
-```
-
-## toString
-
-```res sig
-let toString: t<'a> => string
-```
-Converts the array to a string. Each element is converted to a string using JavaScript. Unlike the JavaScript `Array.toString()`, all elements in a ReasonML array must have the same type. See [`Array.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString) on MDN.
-
-```res example
-Js.Array2.toString([3.5, 4.6, 7.8]) == "3.5,4.6,7.8"
-Js.Array2.toString(["a", "b", "c"]) == "a,b,c"
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t<'a> => string
-```
-Converts the array to a string using the conventions of the current locale. Each element is converted to a string using JavaScript. Unlike the JavaScript `Array.toLocaleString()`, all elements in a ReasonML array must have the same type. See [`Array.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toLocaleString) on MDN.
-
-```res example
-Js.Array2.toLocaleString([Js.Date.make()])
-// returns "3/19/2020, 10:52:11 AM" for locale en_US.utf8
-// returns "2020-3-19 10:52:11" for locale de_DE.utf8
-```
-
-## every
-
-```res sig
-let every: (t<'a>, 'a => bool) => bool
-```
-The first argument to `every()` is an array. The second argument is a predicate function that returns a boolean. The `every()` function returns `true` if the predicate function is true for all items in the given array. If given an empty array, returns `true`. See [`Array.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) on MDN.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-Js.Array2.every([6, 22, 8, 4], isEven) == true
-Js.Array2.every([6, 22, 7, 4], isEven) == false
-```
-
-## everyi
-
-```res sig
-let everyi: (t<'a>, ('a, int) => bool) => bool
-```
-
-The first argument to `everyi()` is an array. The second argument is a predicate function with two arguments: an array element and that element’s index; it returns a boolean. The `everyi()` function returns `true` if the predicate function is true for all items in the given array. If given an empty array, returns `true`. See [`Array.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) on MDN.
-
-```res example
-// determine if all even-index items are positive
-let evenIndexPositive = (item, index) => mod(index, 2) == 0 ? item > 0 : true
-
-Js.Array2.everyi([6, -3, 5, 8], evenIndexPositive) == true
-Js.Array2.everyi([6, 3, -5, 8], evenIndexPositive) == false
-```
-
-## filter
-
-```res sig
-let filter: (t<'a>, 'a => bool) => t<'a>
-```
-Applies the given predicate function (the second argument) to each element in the array; the result is an array of those elements for which the predicate function returned `true`. See [`Array.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) on MDN.
-
-```res example
-let nonEmpty = s => s != ""
-Js.Array2.filter(["abc", "", "", "def", "ghi"], nonEmpty) == ["abc", "def", "ghi"]
-```
-
-## filteri
-
-```res sig
-let filteri: (t<'a>, ('a, int) => bool) => t<'a>
-```
-Each element of the given array are passed to the predicate function. The return value is an array of all those elements for which the predicate function returned `true`.  See [`Array.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) on MDN.
-
-```res example
-// keep only positive elements at odd indices
-let positiveOddElement = (item, index) => mod(index, 2) == 1 && item > 0
-
-Js.Array2.filteri([6, 3, 5, 8, 7, -4, 1], positiveOddElement) == [3, 8]
-```
-
-## find
-
-```res sig
-let find: (t<'a>, 'a => bool) => option<'a>
-```
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```res example
-// find first negative element
-Js.Array2.find([33, 22, -55, 77, -44], x => x < 0) == Some(-55)
-Js.Array2.find([33, 22, 55, 77, 44], x => x < 0) == None
-```
-
-## findi
-
-```res sig
-let findi: (t<'a>, ('a, int) => bool) => option<'a>
-```
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. The predicate function takes an array element and an index as its parameters. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```res example
-// find first positive item at an odd index
-let positiveOddElement = (item, index) => mod(index, 2) == 1 && item > 0
-
-Js.Array2.findi([66, -33, 55, 88, 22], positiveOddElement) == Some(88)
-Js.Array2.findi([66, -33, 55, -88, 22], positiveOddElement) == None
-```
-
-## findIndex
-
-```res sig
-let findIndex: (t<'a>, 'a => bool) => int
-```
-Returns the index of the first element in the array that satisifies the given predicate function, or -1 if no element satisifies the predicate. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```res example
-Js.Array2.findIndex([33, 22, -55, 77, -44], x => x < 0) == 2
-Js.Array2.findIndex([33, 22, 55, 77, 44], x => x < 0) == -1
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: (t<'a>, ('a, int) => bool) => int
-```
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. The predicate function takes an array element and an index as its parameters. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```res example
-// find index of first positive item at an odd index
-let positiveOddElement = (item, index) => mod(index, 2) == 1 && item > 0
-
-Js.Array2.findIndexi([66, -33, 55, 88, 22], positiveOddElement) == 3
-Js.Array2.findIndexi([66, -33, 55, -88, 22], positiveOddElement) == -1
-```
-
-## forEach
-
-```res sig
-let forEach: (t<'a>, 'a => unit) => unit
-```
-The `forEach()` function applies the function given as the second argument to each element in the array. The function you provide returns `unit`, and the `forEach()` function also returns `unit`. You use `forEach()` when you need to process each element in the array but not return any new array or value; for example, to print the items in an array. See [`Array.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) on MDN.
-
-```res example
-// display all elements in an array
-Js.Array2.forEach(["a", "b", "c"], x => Js.log(x)) == ()
-```
-
-## forEachi
-
-```res sig
-let forEachi: (t<'a>, ('a, int) => unit) => unit
-```
-The `forEachi()` function applies the function given as the second argument to each element in the array. The function you provide takes an item in the array and its index number, and returns `unit`. The `forEachi()` function also returns `unit`. You use `forEachi()` when you need to process each element in the array but not return any new array or value; for example, to print the items in an array. See [`Array.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) on MDN.
-
-```res example
-// display all elements in an array as a numbered list
-Js.Array2.forEachi(["a", "b", "c"], (item, index) => Js.log2(index + 1, item)) == ()
-```
-
-## map
-
-```res sig
-let map: (t<'a>, 'a => 'b) => t<'b>
-```
-Applies the function (the second argument) to each item in the array, returning a new array. The result array does not have to have elements of the same type as the input array. See [`Array.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) on MDN.
-
-```res example
-Js.Array2.map([12, 4, 8], x => x * x) == [144, 16, 64]
-Js.Array2.map(["animal", "vegetable", "mineral"], Js.String.length) == [6, 9, 7]
-```
-
-## mapi
-
-```res sig
-let mapi: (t<'a>, ('a, int) => 'b) => t<'b>
-```
-Applies the function (the second argument) to each item in the array, returning a new array. The function acceps two arguments: an item from the array and its index number. The result array does not have to have elements of the same type as the input array. See [`Array.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) on MDN.
-
-```res example
-// multiply each item in array by its position
-let product = (item, index) => item * index
-Js.Array2.mapi([10, 11, 12], product) == [0, 11, 24]
-```
-
-## reduce
-
-```res sig
-let reduce: (t<'a>, ('b, 'a) => 'b, 'b) => 'b
-```
-The `reduce()` function takes three parameters: an array, a *reducer function*,  and a beginning accumulator value. The reducer function has two parameters: an accumulated value and an element of the array.
-
-`reduce()` first calls the reducer function with the beginning value and the first element in the array. The result becomes the new accumulator value, which is passed in to the reducer function along with the second element in the array. `reduce()` proceeds through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduce()`. See [`Array.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) on MDN.
-
-```res example
-let sumOfSquares = (accumulator, item) => accumulator + item * item
-
-Js.Array2.reduce([10, 2, 4], sumOfSquares, 0) == 120
-Js.Array2.reduce([10, 2, 4], \"*", 1) == 80
-Js.Array2.reduce(
-  ["animal", "vegetable", "mineral"],
-  (acc, item) => acc + Js.String.length(item),
-  0,
-) == 22 // 6 + 9 + 7
-Js.Array2.reduce([2.0, 4.0], (acc, item) => item /. acc, 1.0) == 2.0 // 4.0 / (2.0 / 1.0)
-```
-
-## reducei
-
-```res sig
-let reducei: (t<'a>, ('b, 'a, int) => 'b, 'b) => 'b
-```
-The `reducei()` function takes three parameters: an array, a *reducer function*, and a beginning accumulator value. The reducer function has three parameters: an accumulated value, an element of the array, and the index of that element.
-
-`reducei()` first calls the reducer function with the beginning value, the first element in the array, and zero (its index). The result becomes the new accumulator value, which is passed to the reducer function along with the second element in the array and one (its index). `reducei()` proceeds from left to right through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reducei()`. See [`Array.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) on MDN.
-
-```res example
-// find sum of even-index elements in array
-let sumOfEvens = (accumulator, item, index) =>
-  if mod(index, 2) == 0 {
-    accumulator + item
-  } else {
-    accumulator
-  }
-
-Js.Array2.reducei([2, 5, 1, 4, 3], sumOfEvens, 0) == 6
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: (t<'a>, ('b, 'a) => 'b, 'b) => 'b
-```
-The `reduceRight()` function takes three parameters: an array, a *reducer function*, and a beginning accumulator value. The reducer function has two parameters: an accumulated value and an element of the array.
-
-`reduceRight()` first calls the reducer function with the beginning value and the last element in the array. The result becomes the new accumulator value, which is passed in to the reducer function along with the next-to-last element in the array. `reduceRight()` proceeds from right to left through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduceRight()`.  See [`Array.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight) on MDN.
-
-**NOTE:** In many cases, `reduce()` and `reduceRight()` give the same result. However, see the last example here and compare it to the example from `reduce()`, where order makes a difference.
-
-```res example
-let sumOfSquares = (accumulator, item) => accumulator + item * item
-
-Js.Array2.reduceRight([10, 2, 4], sumOfSquares, 0) == 120
-Js.Array2.reduceRight([2.0, 4.0], (acc, item) => item /. acc, 1.0) == 0.5 // 2.0 / (4.0 / 1.0)
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: (t<'a>, ('b, 'a, int) => 'b, 'b) => 'b
-```
-The `reduceRighti()` function takes three parameters: an array, a *reducer function*, and a beginning accumulator value. The reducer function has three parameters: an accumulated value, an element of the array, and the index of that element. `reduceRighti()` first calls the reducer function with the beginning value, the last element in the array, and its index (length of array minus one). The result becomes the new accumulator value, which is passed in to the reducer function along with the second element in the array and one (its index). `reduceRighti()` proceeds from right to left through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduceRighti()`. See [`Array.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight) on MDN.
-
-**NOTE:** In many cases, `reducei()` and `reduceRighti()` give the same result. However, there are cases where the order in which items are processed makes a difference.
-
-```res example
-// find sum of even-index elements in array
-let sumOfEvens = (accumulator, item, index) =>
-  if mod(index, 2) == 0 {
-    accumulator + item
-  } else {
-    accumulator
-  }
-
-Js.Array2.reduceRighti([2, 5, 1, 4, 3], sumOfEvens, 0) == 6
-```
-
-## some
-
-```res sig
-let some: (t<'a>, 'a => bool) => bool
-```
-Returns `true` if the predicate function given as the second argument to `some()` returns `true` for any element in the array; `false` otherwise.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-Js.Array2.some([3, 7, 5, 2, 9], isEven) == true
-Js.Array2.some([3, 7, 5, 1, 9], isEven) == false
-```
-
-## somei
-
-```res sig
-let somei: (t<'a>, ('a, int) => bool) => bool
-```
-Returns `true` if the predicate function given as the second argument to `somei()` returns `true` for any element in the array; `false` otherwise. The predicate function has two arguments: an item from the array and the index value
-
-```res example
-// Does any string in the array
-// have the same length as its index?
-
-let sameLength = (str, index) => Js.String.length(str) == index
-
-// "ef" has length 2 and is it at index 2
-Js.Array2.somei(["ab", "cd", "ef", "gh"], sameLength) == true
-// no item has the same length as its index
-Js.Array2.somei(["a", "bc", "def", "gh"], sameLength) == false
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (array<'a>, int) => 'a
-```
-Returns the value at the given position in the array if the position is in bounds; returns the JavaScript value `undefined` otherwise.
-
-```res example
-let arr = [100, 101, 102, 103]
-Js.Array2.unsafe_get(arr, 3) == 103
-Js.Array2.unsafe_get(arr, 4) // returns undefined
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (array<'a>, int, 'a) => unit
-```
-Sets the value at the given position in the array if the position is in bounds. If the index is out of bounds, well, “here there be dragons.“ *This function modifies the original array.*
-
-```res example
-let arr = [100, 101, 102, 103]
-Js.Array2.unsafe_set(arr, 3, 99)
-// result is [100, 101, 102, 99];
-
-Js.Array2.unsafe_set(arr, 4, 88)
-// result is [100, 101, 102, 99, 88]
-
-Js.Array2.unsafe_set(arr, 6, 77)
-// result is [100, 101, 102, 99, 88, <1 empty item>, 77]
-
-Js.Array2.unsafe_set(arr, -1, 66)
-// you don't want to know.
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/array.mdx b/pages/docs/manual/v9.0.0/api/js/array.mdx
deleted file mode 100644
index 1ed2abb75..000000000
--- a/pages/docs/manual/v9.0.0/api/js/array.mdx
+++ /dev/null
@@ -1,926 +0,0 @@
-# Array
-
-<Intro>
-
-Provides bindings to JavaScript’s `Array` functions. These bindings are optimized for pipe-last (`|>`), where the array to be processed is the last parameter in the function.
-
-Here is an example to find the sum of squares of all even numbers in an array.
-Without pipe last, we must call the functions in reverse order:
-
-```res example
-let isEven = x => mod(x, 2) == 0
-let square = x => x * x
-let result = {
-  open Js.Array
-  reduce(\"+", 0, map(square, filter(isEven, [5, 2, 3, 4, 1])))
-}
-```
-
-With pipe last, we call the functions in the “natural” order:
-
-```res example
-let isEven = x => mod(x, 2) == 0
-let square = x => x * x
-let result = {
-  open Js.Array
-  [5, 2, 3, 4, 1] |> filter(isEven) |> map(square) |> reduce(\"+", 0)
-}
-```
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a> = array<'a>
-```
-
-The type used to describe a JavaScript array.
-
-## array_like
-
-```res prelude
-type array_like<'a> = Js_array2.array_like<'a>
-```
-
-A type used to describe JavaScript objects that are like an array or are iterable.
-
-## from
-
-```res sig
-let from: array_like<'a> => array<'a>
-```
-
-Creates a shallow copy of an array from an array-like object. See [`Array.from`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from) on MDN.
-
-```res example
-let strArr = Js.String.castToArrayLike("abcd")
-Js.Array.from(strArr) == ["a", "b", "c", "d"]
-```
-
-## fromMap
-
-```res sig
-let fromMap: (array_like<'a>, 'a => 'b) => array<'b>
-```
-
-Creates a new array by applying a function (the second argument) to each item in the `array_like` first argument.  See [`Array.from`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from) on MDN.
-
-```res example
-let strArr = Js.String.castToArrayLike("abcd")
-let code = s => Js.String.charCodeAt(0, s)
-Js.Array.fromMap(strArr, code) == [97.0, 98.0, 99.0, 100.0]
-```
-
-## isArray
-
-```res sig
-let isArray: 'a => bool
-```
-
-Returns `true` if its argument is an array; `false` otherwise. This is a runtime check, which is why the second example returns `true`---a list is internally represented as a nested JavaScript array.
-
-```res example
-Js.Array.isArray([5, 2, 3, 1, 4]) == true
-Js.Array.isArray(list{5, 2, 3, 1, 4}) == true
-Js.Array.isArray("abcd") == false
-```
-
-## length
-
-```res sig
-let length: array<'a> => int
-```
-
-Returns the number of elements in the array. See [`Array.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length) on MDN.
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t<'a>) => t<'a>
-```
-
-Copies from the first element in the given array to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array.copyWithin(~to_=2, arr) == [100, 101, 100, 101, 102]
-arr == [100, 101, 100, 101, 102]
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t<'a>) => t<'a>
-```
-
-Copies starting at element `~from` in the given array to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array.copyWithinFrom(~from=2, ~to_=0, arr) == [102, 103, 104, 103, 104]
-arr == [102, 103, 104, 103, 104]
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t<'a>) => t<'a>
-```
-
-Copies starting at element `~start` in the given array up to but not including `~end_` to the designated `~to_` position, returning the resulting array. *This function modifies the original array.* See [`Array.copyWithin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104, 105]
-Js.Array.copyWithinFromRange(~start=2, ~end_=5, ~to_=1, arr) == [100, 102, 103, 104, 104, 105]
-arr == [100, 102, 103, 104, 104, 105]
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: ('a, t<'a>) => t<'a>
-```
-Sets all elements of the given array (the second arumgent) to the designated value (the first argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array.fillInPlace(99, arr) == [99, 99, 99, 99, 99]
-arr == [99, 99, 99, 99, 99]
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: ('a, ~from: int, t<'a>) => t<'a>
-```
-Sets all elements of the given array (the last arumgent) from position `~from` to the end to the designated value (the first argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array.fillFromInPlace(99, ~from=2, arr) == [100, 101, 99, 99, 99]
-arr == [100, 101, 99, 99, 99]
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: ('a, ~start: int, ~end_: int, t<'a>) => t<'a>
-```
-
-Sets the elements of the given array (the last arumgent) from position `~start` up to but not including position `~end_` to the designated value (the first argument), returning the resulting array. *This function modifies the original array.* See [`Array.fill`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array.fillRangeInPlace(99, ~start=1, ~end_=4, arr) == [100, 99, 99, 99, 104]
-arr == [100, 99, 99, 99, 104]
-```
-
-## pop
-
-```res sig
-let pop: t<'a> => option<'a>
-```
-
-If the array is not empty, removes the last element and returns it as `Some(value)`; returns `None` if the array is empty. *This function modifies the original array.* See [`Array.pop`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array.pop(arr) == Some(104)
-arr == [100, 101, 102, 103]
-
-let empty: array<int> = []
-Js.Array.pop(empty) == None
-```
-
-## push
-
-```res sig
-let push: ('a, t<'a>) => int
-```
-
-Appends the given value to the array, returning the number of elements in the updated array. *This function modifies the original array.* See [`Array.push`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) on MDN.
-
-```res example
-let arr = ["ant", "bee", "cat"]
-Js.Array.push("dog", arr) == 4
-arr == ["ant", "bee", "cat", "dog"]
-```
-
-## pushMany
-
-```res sig
-let pushMany: (array<'a>, t<'a>) => int
-```
-
-Appends the values from one array (the first argument) to another (the second argument), returning the number of elements in the updated array. *This function modifies the original array.* See [`Array.push`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) on MDN.
-
-```res example
-let arr = ["ant", "bee", "cat"]
-Js.Array.pushMany(["dog", "elk"], arr) == 5
-arr == ["ant", "bee", "cat", "dog", "elk"]
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t<'a> => t<'a>
-```
-
-Returns an array with the elements of the input array in reverse order. *This function modifies the original array.* See [`Array.reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse) on MDN.
-
-```res example
-let arr = ["ant", "bee", "cat"]
-Js.Array.reverseInPlace(arr) == ["cat", "bee", "ant"]
-arr == ["cat", "bee", "ant"]
-```
-
-## shift
-
-```res sig
-let shift: t<'a> => option<'a>
-```
-If the array is not empty, removes the first element and returns it as `Some(value)`; returns `None` if the array is empty. *This function modifies the original array.* See [`Array.shift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104]
-Js.Array.shift(arr) == Some(100)
-arr == [101, 102, 103, 104]
-
-let empty: array<int> = []
-Js.Array.shift(empty) == None
-```
-## sortInPlace
-
-```res sig
-let sortInPlace: t<'a> => t<'a>
-```
-
-Sorts the given array in place and returns the sorted array. JavaScript sorts the array by converting the arguments to UTF-16 strings and sorting them. See the second example with sorting numbers, which does not do a numeric sort. *This function modifies the original array.* See [`Array.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) on MDN.
-
-```res example
-let words = ["bee", "dog", "ant", "cat"]
-Js.Array.sortInPlace(words) == ["ant", "bee", "cat", "dog"]
-words == ["ant", "bee", "cat", "dog"]
-
-let numbers = [3, 30, 10, 1, 20, 2]
-Js.Array.sortInPlace(numbers) == [1, 10, 2, 20, 3, 30]
-numbers == [1, 10, 2, 20, 3, 30]
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: (('a, 'a) => int, t<'a>) => t<'a>
-```
-
-Sorts the given array in place and returns the sorted array. *This function modifies the original array.*
-
-The first argument to `sortInPlaceWith()` is a function that compares two items from the array and returns:
-
-* an integer less than zero if the first item is less than the second item
-* zero if the items are equal
-* an integer greater than zero if the first item is greater than the second item
-
-See [`Array.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) on MDN.
-
-```res example
-// sort by word length
-let words = ["horse", "aardvark", "dog", "camel"]
-let byLength = (s1, s2) => Js.String.length(s1) - Js.String.length(s2)
-
-Js.Array.sortInPlaceWith(byLength, words) == ["dog", "horse", "camel", "aardvark"]
-
-// sort in reverse numeric order
-let numbers = [3, 30, 10, 1, 20, 2]
-let reverseNumeric = (n1, n2) => n2 - n1
-Js.Array.sortInPlaceWith(reverseNumeric, numbers) == [30, 20, 10, 3, 2, 1]
-```
-
-## spliceInPlace
-
-```res sig
-let spliceInPlace: (~pos: int, ~remove: int, ~add: array<'a>, t<'a>) => t<'a>
-```
-
-Starting at position `~pos`, remove `~remove` elements and then add the elements from the `~add` array. Returns an array consisting of the removed items. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```res example
-let arr = ["a", "b", "c", "d", "e", "f"]
-Js.Array.spliceInPlace(~pos=2, ~remove=2, ~add=["x", "y", "z"], arr) == ["c", "d"]
-arr == ["a", "b", "x", "y", "z", "e", "f"]
-
-let arr2 = ["a", "b", "c", "d"]
-Js.Array.spliceInPlace(~pos=3, ~remove=0, ~add=["x", "y"], arr2) == []
-arr2 == ["a", "b", "c", "x", "y", "d"]
-
-let arr3 = ["a", "b", "c", "d", "e", "f"]
-Js.Array.spliceInPlace(~pos=9, ~remove=2, ~add=["x", "y", "z"], arr3) == []
-arr3 == ["a", "b", "c", "d", "e", "f", "x", "y", "z"]
-```
-
-## removeFromInPlace
-
-```res sig
-let removeFromInPlace: (~pos: int, t<'a>) => t<'a>
-```
-
-Removes elements from the given array starting at position `~pos` to the end of the array, returning the removed elements. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```res example
-let arr = ["a", "b", "c", "d", "e", "f"]
-Js.Array.removeFromInPlace(~pos=4, arr) == ["e", "f"]
-arr == ["a", "b", "c", "d"]
-```
-
-## removeCountInPlace
-
-```res sig
-let removeCountInPlace: (~pos: int, ~count: int, t<'a>) => t<'a>
-```
-
-Removes `~count` elements from the given array starting at position `~pos`, returning the removed elements. *This function modifies the original array.* See [`Array.splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) on MDN.
-
-```res example
-let arr = ["a", "b", "c", "d", "e", "f"]
-Js.Array.removeCountInPlace(~pos=2, ~count=3, arr) == ["c", "d", "e"]
-arr == ["a", "b", "f"]
-```
-
-## unshift
-
-```res sig
-let unshift: ('a, t<'a>) => int
-```
-
-Adds the given element to the array, returning the new number of elements in the array. *This function modifies the original array.* See [`Array.unshift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) on MDN.
-
-```res example
-let arr = ["b", "c", "d"]
-Js.Array.unshift("a", arr) == 4
-arr == ["a", "b", "c", "d"]
-```
-
-## unshiftMany
-
-```res sig
-let unshiftMany: (array<'a>, t<'a>) => int
-```
-
-Adds the elements in the first array argument at the beginning of the second array argument, returning the new number of elements in the array. *This function modifies the original array.* See [`Array.unshift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) on MDN.
-
-```res example
-let arr = ["d", "e"]
-Js.Array.unshiftMany(["a", "b", "c"], arr) == 5
-arr == ["a", "b", "c", "d", "e"]
-```
-
-## append
-
-```res sig
-let append: ('a, t<'a>) => t<'a>
-```
-
-Deprecated. `append()` is not type-safe. Use `concat()` instead.
-
-## concat
-
-```res sig
-let concat: (t<'a>, t<'a>) => t<'a>
-```
-
-Concatenates the first array argument to the second array argument, returning a new array. The original arrays are not modified. See [`Array.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat) on MDN.
-
-```res example
-Js.Array.concat(["c", "d", "e"], ["a", "b"]) == ["a", "b", "c", "d", "e"]
-```
-
-## concatMany
-
-```res sig
-let concatMany: (array<t<'a>>, t<'a>) => t<'a>
-```
-
-The first argument to `concatMany()` is an array of arrays; these are added at the end of the second argument, returning a new array. See [`Array.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat) on MDN.
-
-```res example
-Js.Array.concatMany([["d", "e"], ["f", "g", "h"]], ["a", "b", "c"]) == [
-    "a",
-    "b",
-    "c",
-    "d",
-    "e",
-    "f",
-    "g",
-    "h",
-  ]
-```
-
-## includes
-
-```res sig
-let includes: ('a, t<'a>) => bool
-```
-
-Returns true if the given value is in the array, `false` otherwise. See [`Array.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes) on MDN.
-
-```res example
-Js.Array.includes("b", ["a", "b", "c"]) == true
-Js.Array.includes("x", ["a", "b", "c"]) == false
-```
-
-## indexOf
-
-```res sig
-let indexOf: ('a, t<'a>) => int
-```
-Returns the index of the first element in the array that has the given value. If the value is not in the array, returns -1. See [`Array.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf) on MDN.
-
-```res example
-Js.Array.indexOf(102, [100, 101, 102, 103]) == 2
-Js.Array.indexOf(999, [100, 101, 102, 103]) == -1
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: ('a, ~from: int, t<'a>) => int
-```
-
-Returns the index of the first element in the array with the given value. The search starts
-at position `~from`. See [`Array.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf) on MDN.
-
-```res example
-Js.Array.indexOfFrom("a", ~from=2, ["a", "b", "a", "c", "a"]) == 2
-Js.Array.indexOfFrom("a", ~from=3, ["a", "b", "a", "c", "a"]) == 4
-Js.Array.indexOfFrom("b", ~from=2, ["a", "b", "a", "c", "a"]) == -1
-```
-
-## join
-
-```res sig
-let join: t<'a> => string
-```
-Deprecated. Use `joinWith` instead.
-
-## joinWith
-
-```res sig
-let joinWith: (string, t<'a>) => string
-```
-This function converts each element of the array to a string (via JavaScript) and concatenates them, separated by the string given in the first argument, into a single string. See [`Array.join`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join) on MDN.
-
-```res example
-Js.Array.joinWith("--", ["ant", "bee", "cat"]) == "ant--bee--cat"
-Js.Array.joinWith("", ["door", "bell"]) == "doorbell"
-Js.Array.joinWith("/", [2020, 9, 4]) == "2020/9/4"
-Js.Array.joinWith(";", [2.5, 3.6, 3e-2]) == "2.5;3.6;0.03"
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: ('a, t<'a>) => int
-```
-
-Returns the index of the last element in the array that has the given value. If the value is not in the array, returns -1. See [`Array.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) on MDN.
-
-```res example
-Js.Array.lastIndexOf("a", ["a", "b", "a", "c"]) == 2
-Js.Array.lastIndexOf("x", ["a", "b", "a", "c"]) == -1
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: ('a, ~from: int, t<'a>) => int
-```
-
-Returns the index of the last element in the array that has the given value, searching from position `~from` down to the start of the array. If the value is not in the array, returns -1. See [`Array.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) on MDN.
-
-```res example
-Js.Array.lastIndexOfFrom("a", ~from=3, ["a", "b", "a", "c", "a", "d"]) == 2
-Js.Array.lastIndexOfFrom("c", ~from=2, ["a", "b", "a", "c", "a", "d"]) == -1
-```
-
-## lastIndexOf_start
-
-```res sig
-let lastIndexOf_start: ('a, t<'a>) => int
-```
-
-Deprecated. Please use `lastIndexOf`.
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t<'a>) => t<'a>
-```
-
-Returns a shallow copy of the given array from the `~start` index up to but not including the `~end_` position. Negative numbers indicate an offset from the end of the array. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-
-```res example
-let arr = [100, 101, 102, 103, 104, 105, 106]
-Js.Array.slice(~start=2, ~end_=5, arr) == [102, 103, 104]
-Js.Array.slice(~start=-3, ~end_=-1, arr) == [104, 105]
-Js.Array.slice(~start=9, ~end_=10, arr) == []
-```
-
-## copy
-
-```res sig
-let copy: t<'a> => t<'a>
-```
-
-Returns a copy of the entire array. Same as `Js.Array.Slice(~start=0, ~end_=Js.Array.length(arr), arr)`. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-
-## slice_copy
-
-```res sig
-let slice_copy: (unit, t<'a>) => t<'a>
-```
-
-Deprecated. Please use `copy`.
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t<'a>) => t<'a>
-```
-
-Returns a shallow copy of the given array from the given index to the end. See [`Array.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) on MDN.
-
-```res example
-Js.Array.sliceFrom(2, [100, 101, 102, 103, 104]) == [102, 103, 104]
-```
-
-## slice_start
-
-```res sig
-let slice_start: (int, t<'a>) => t<'a>
-```
-
-Deprecated. Please `sliceFrom`.
-
-## toString
-
-```res sig
-let toString: t<'a> => string
-```
-
-Converts the array to a string. Each element is converted to a string using JavaScript. Unlike the JavaScript `Array.toString()`, all elements in a ReasonML array must have the same type. See [`Array.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString) on MDN.
-
-```res example
-Js.Array.toString([3.5, 4.6, 7.8]) == "3.5,4.6,7.8"
-Js.Array.toString(["a", "b", "c"]) == "a,b,c"
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t<'a> => string
-```
-
-Converts the array to a string using the conventions of the current locale. Each element is converted to a string using JavaScript. Unlike the JavaScript `Array.toLocaleString()`, all elements in a ReasonML array must have the same type. See [`Array.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toLocaleString) on MDN.
-
-```res example
-Js.Array.toLocaleString([Js.Date.make()])
-// returns "3/19/2020, 10:52:11 AM" for locale en_US.utf8
-// returns "2020-3-19 10:52:11" for locale de_DE.utf8
-```
-
-## every
-
-```res sig
-let every: ('a => bool, t<'a>) => bool
-```
-
-The first argument to `every()` is a predicate function that returns a boolean. The `every()` function returns `true` if the predicate function is true for all items in the given array. If given an empty array, returns `true`. See [`Array.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) on MDN.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-Js.Array.every(isEven, [6, 22, 8, 4]) == true
-Js.Array.every(isEven, [6, 22, 7, 4]) == false
-```
-
-## everyi
-
-```res sig
-let everyi: (('a, int) => bool, t<'a>) => bool
-```
-
-The first argument to `everyi()` is a predicate function with two arguments: an array element and that element’s index; it returns a boolean. The `everyi()` function returns `true` if the predicate function is true for all items in the given array. If given an empty array, returns `true`. See [`Array.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) on MDN.
-
-```res example
-// determine if all even-index items are positive
-let evenIndexPositive = (item, index) => mod(index, 2) == 0 ? item > 0 : true
-
-Js.Array.everyi(evenIndexPositive, [6, -3, 5, 8]) == true
-Js.Array.everyi(evenIndexPositive, [6, 3, -5, 8]) == false
-```
-
-## filter
-
-```res sig
-let filter: ('a => bool, t<'a>) => t<'a>
-```
-
-Applies the given predicate function to each element in the array; the result is an array of those elements for which the predicate function returned `true`. See [`Array.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) on MDN.
-
-```res example
-let nonEmpty = s => s != ""
-Js.Array.filter(nonEmpty, ["abc", "", "", "def", "ghi"]) == ["abc", "def", "ghi"]
-```
-
-
-## filteri
-
-```res sig
-let filteri: (('a, int) => bool, t<'a>) => t<'a>
-```
-
-Each element of the given array are passed to the predicate function. The return value is an array of all those elements for which the predicate function returned `true`.  See [`Array.filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) on MDN.
-
-```res example
-// keep only positive elements at odd indices
-let positiveOddElement = (item, index) => mod(index, 2) == 1 && item > 0
-
-Js.Array.filteri(positiveOddElement, [6, 3, 5, 8, 7, -4, 1]) == [3, 8]
-```
-
-## find
-
-```res sig
-let find: ('a => bool, t<'a>) => option<'a>
-```
-
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```res example
-// find first negative element
-Js.Array.find(x => x < 0, [33, 22, -55, 77, -44]) == Some(-55)
-Js.Array.find(x => x < 0, [33, 22, 55, 77, 44]) == None
-```
-
-## findi
-
-```res sig
-let findi: (('a, int) => bool, t<'a>) => option<'a>
-```
-
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. The predicate function takes an array element and an index as its parameters. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```res example
-// find first positive item at an odd index
-let positiveOddElement = (item, index) => mod(index, 2) == 1 && item > 0
-
-Js.Array.findi(positiveOddElement, [66, -33, 55, 88, 22]) == Some(88)
-Js.Array.findi(positiveOddElement, [66, -33, 55, -88, 22]) == None
-```
-
-## findIndex
-
-```res sig
-let findIndex: ('a => bool, t<'a>) => int
-```
-
-Returns the index of the first element in the array that satisifies the given predicate function, or -1 if no element satisifies the predicate. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```res example
-Js.Array.findIndex(x => x < 0, [33, 22, -55, 77, -44]) == 2
-Js.Array.findIndex(x => x < 0, [33, 22, 55, 77, 44]) == -1
-```
-## findIndexi
-
-```res sig
-let findIndexi: (('a, int) => bool, t<'a>) => int
-```
-
-Returns `Some(value)` for the first element in the array that satisifies the given predicate function, or `None` if no element satisifies the predicate. The predicate function takes an array element and an index as its parameters. See [`Array.find`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) on MDN.
-
-```res example
-// find index of first positive item at an odd index
-let positiveOddElement = (item, index) => mod(index, 2) == 1 && item > 0
-
-Js.Array.findIndexi(positiveOddElement, [66, -33, 55, 88, 22]) == 3
-Js.Array.findIndexi(positiveOddElement, [66, -33, 55, -88, 22]) == -1
-```
-
-## forEach
-
-```res sig
-let forEach: ('a => unit, t<'a>) => unit
-```
-
-The `forEach()` function applies the function given as the first argument to each element in the array. The function you provide returns `unit`, and the `forEach()` function also returns `unit`. You use `forEach()` when you need to process each element in the array but not return any new array or value; for example, to print the items in an array. See [`Array.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) on MDN.
-
-```res example
-// display all elements in an array
-Js.Array.forEach(x => Js.log(x), ["a", "b", "c"]) == ()
-```
-
-## forEachi
-
-```res sig
-let forEachi: (('a, int) => unit, t<'a>) => unit
-```
-
-The `forEachi()` function applies the function given as the first argument to each element in the array. The function you provide takes an item in the array and its index number, and returns `unit`. The `forEachi()` function also returns `unit`. You use `forEachi()` when you need to process each element in the array but not return any new array or value; for example, to print the items in an array. See [`Array.forEach`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) on MDN.
-
-```res example
-// display all elements in an array as a numbered list
-Js.Array.forEachi((item, index) => Js.log2(index + 1, item), ["a", "b", "c"]) == ()
-```
-
-## map
-
-```res sig
-let map: ('a => 'b, t<'a>) => t<'b>
-```
-
-Applies the function (given as the first argument) to each item in the array, returning a new array. The result array does not have to have elements of the same type as the input array. See [`Array.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) on MDN.
-
-```res example
-Js.Array.map(x => x * x, [12, 4, 8]) == [144, 16, 64]
-Js.Array.map(Js.String.length, ["animal", "vegetable", "mineral"]) == [6, 9, 7]
-```
-
-## mapi
-
-```res sig
-let mapi: (('a, int) => 'b, t<'a>) => t<'b>
-```
-
-Applies the function (given as the first argument) to each item in the array, returning a new array. The function acceps two arguments: an item from the array and its index number. The result array does not have to have elements of the same type as the input array. See [`Array.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) on MDN.
-
-```res example
-// multiply each item in array by its position
-let product = (item, index) => item * index
-Js.Array.mapi(product, [10, 11, 12]) == [0, 11, 24]
-```
-
-## reduce
-
-```res sig
-let reduce: (('b, 'a) => 'b, 'b, t<'a>) => 'b
-```
-
-The `reduce()` function takes three parameters: a *reducer function*, a beginning accumulator value, and an array. The reducer function has two parameters: an accumulated value and an element of the array.
-
-`reduce()` first calls the reducer function with the beginning value and the first element in the array. The result becomes the new accumulator value, which is passed in to the reducer function along with the second element in the array. `reduce()` proceeds through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduce()`. See [`Array.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) on MDN.
-
-```res example
-let sumOfSquares = (accumulator, item) => accumulator + item * item
-
-Js.Array.reduce(sumOfSquares, 0, [10, 2, 4]) == 120
-Js.Array.reduce(\"*", 1, [10, 2, 4]) == 80
-Js.Array.reduce(
-  (acc, item) => acc + Js.String.length(item),
-  0,
-  ["animal", "vegetable", "mineral"],
-) == 22 // 6 + 9 + 7
-Js.Array.reduce((acc, item) => item /. acc, 1.0, [2.0, 4.0]) == 2.0 // 4.0 / (2.0 / 1.0)
-```
-
-## reducei
-
-```res sig
-let reducei: (('b, 'a, int) => 'b, 'b, t<'a>) => 'b
-```
-
-The `reducei()` function takes three parameters: a *reducer function*, a beginning accumulator value, and an array. The reducer function has three parameters: an accumulated value, an element of the array, and the index of that element.
-
-`reducei()` first calls the reducer function with the beginning value, the first element in the array, and zero (its index). The result becomes the new accumulator value, which is passed to the reducer function along with the second element in the array and one (its index). `reducei()` proceeds from left to right through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reducei()`. See [`Array.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) on MDN.
-
-```res example
-// find sum of even-index elements in array
-let sumOfEvens = (accumulator, item, index) =>
-  if mod(index, 2) == 0 {
-    accumulator + item
-  } else {
-    accumulator
-  }
-
-Js.Array.reducei(sumOfEvens, 0, [2, 5, 1, 4, 3]) == 6
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: (('b, 'a) => 'b, 'b, t<'a>) => 'b
-```
-
-The `reduceRight()` function takes three parameters: a *reducer function*, a beginning accumulator value, and an array. The reducer function has two parameters: an accumulated value and an element of the array.
-
-`reduceRight()` first calls the reducer function with the beginning value and the last element in the array. The result becomes the new accumulator value, which is passed in to the reducer function along with the next-to-last element in the array. `reduceRight()` proceeds from right to left through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduceRight()`.  See [`Array.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight) on MDN.
-
-**NOTE:** In many cases, `reduce()` and `reduceRight()` give the same result. However, see the last example here and compare it to the example from `reduce()`, where order makes a difference.
-
-```res example
-let sumOfSquares = (accumulator, item) => accumulator + item * item
-
-Js.Array.reduceRight(sumOfSquares, 0, [10, 2, 4]) == 120
-Js.Array.reduceRight((acc, item) => item /. acc, 1.0, [2.0, 4.0]) == 0.5 // 2.0 / (4.0 / 1.0)
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: (('b, 'a, int) => 'b, 'b, t<'a>) => 'b
-```
-
-The `reduceRighti()` function takes three parameters: a *reducer function*, a beginning accumulator value, and an array. The reducer function has three parameters: an accumulated value, an element of the array, and the index of that element. `reduceRighti()` first calls the reducer function with the beginning value, the last element in the array, and its index (length of array minus one). The result becomes the new accumulator value, which is passed in to the reducer function along with the second element in the array and one (its index). `reduceRighti()` proceeds from right to left through the array, passing in the result of each stage as the accumulator to the reducer function.
-
-When all array elements are processed, the final value of the accumulator becomes the return value of `reduceRighti()`. See [`Array.reduceRight`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight) on MDN.
-
-**NOTE:** In many cases, `reducei()` and `reduceRighti()` give the same result. However, there are cases where the order in which items are processed makes a difference.
-
-```res example
-// find sum of even-index elements in array
-let sumOfEvens = (accumulator, item, index) =>
-  if mod(index, 2) == 0 {
-    accumulator + item
-  } else {
-    accumulator
-  }
-
-Js.Array.reduceRighti(sumOfEvens, 0, [2, 5, 1, 4, 3]) == 6
-```
-
-## some
-
-```res sig
-let some: ('a => bool, t<'a>) => bool
-```
-
-Returns `true` if the predicate function given as the first argument to `some()` returns `true` for any element in the array; `false` otherwise.
-
-```res example
-let isEven = x => mod(x, 2) == 0
-
-Js.Array.some(isEven, [3, 7, 5, 2, 9]) == true
-Js.Array.some(isEven, [3, 7, 5, 1, 9]) == false
-```
-
-## somei
-
-```res sig
-let somei: (('a, int) => bool, t<'a>) => bool
-```
-
-Returns `true` if the predicate function given as the first argument to `somei()` returns `true` for any element in the array; `false` otherwise. The predicate function has two arguments: an item from the array and the index value
-
-```res example
-// Does any string in the array
-// have the same length as its index?
-
-let sameLength = (str, index) => Js.String.length(str) == index
-
-// "ef" has length 2 and is it at index 2
-Js.Array.somei(sameLength, ["ab", "cd", "ef", "gh"]) == true
-// no item has the same length as its index
-Js.Array.somei(sameLength, ["a", "bc", "def", "gh"]) == false
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (array<'a>, int) => 'a
-```
-Returns the value at the given position in the array if the position is in bounds; returns
-the JavaScript value `undefined` otherwise.
-
-```res example
-let arr = [100, 101, 102, 103]
-Js.Array.unsafe_get(arr, 3) == 103
-Js.Array.unsafe_get(arr, 4) // returns undefined
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (array<'a>, int, 'a) => unit
-```
-
-Sets the value at the given position in the array if the position is in bounds. If the index is out of bounds, well, “here there be dragons.“ *This function modifies the original array.*
-
-```res example
-let arr = [100, 101, 102, 103]
-Js.Array.unsafe_set(arr, 3, 99)
-// result is [100, 101, 102, 99]
-
-Js.Array.unsafe_set(arr, 4, 88)
-// result is [100, 101, 102, 99, 88]
-
-Js.Array.unsafe_set(arr, 6, 77)
-// result is [100, 101, 102, 99, 88, <1 empty item>, 77]
-
-Js.Array.unsafe_set(arr, -1, 66)
-// you don't want to know.
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/console.mdx b/pages/docs/manual/v9.0.0/api/js/console.mdx
deleted file mode 100644
index f02bd576b..000000000
--- a/pages/docs/manual/v9.0.0/api/js/console.mdx
+++ /dev/null
@@ -1,114 +0,0 @@
-# Console
-
-<Intro>
-
-Provide console (logging) utilities.
-
-</Intro>
-
-
-## log
-
-```res sig
-let log: 'a => unit
-```
-
-```res sig
-let log2: ('a, 'b) => unit
-```
-
-```res sig
-let log3: ('a, 'b, 'c) => unit
-```
-
-```res sig
-let log4: ('a, 'b, 'c, 'd) => unit
-```
-
-```res sig
-let logMany: array<'a> => unit
-```
-
-## info
-
-```res sig
-let info: 'a => unit
-```
-
-```res sig
-let info2: ('a, 'b) => unit
-```
-
-```res sig
-let info3: ('a, 'b, 'c) => unit
-```
-
-```res sig
-let info4: ('a, 'b, 'c, 'd) => unit
-```
-
-```res sig
-let infoMany: array<'a> => unit
-```
-
-## warn
-
-```res sig
-let warn: 'a => unit
-```
-
-```res sig
-let warn2: ('a, 'b) => unit
-```
-
-```res sig
-let warn3: ('a, 'b, 'c) => unit
-```
-
-```res sig
-let warn4: ('a, 'b, 'c, 'd) => unit
-```
-
-```res sig
-let warnMany: array<'a> => unit
-```
-
-## error
-
-```res sig
-let error: 'a => unit
-```
-
-```res sig
-let error2: ('a, 'b) => unit
-```
-
-```res sig
-let error3: ('a, 'b, 'c) => unit
-```
-
-```res sig
-let error4: ('a, 'b, 'c, 'd) => unit
-```
-
-```res sig
-let errorMany: array<'a> => unit
-```
-
-## trace
-
-```res sig
-let trace: unit => unit
-```
-
-## timeStart
-
-```res sig
-let timeStart: string => unit
-```
-
-## timeEnd
-
-```res sig
-let timeEnd: string => unit
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/date.mdx b/pages/docs/manual/v9.0.0/api/js/date.mdx
deleted file mode 100644
index 9212782d7..000000000
--- a/pages/docs/manual/v9.0.0/api/js/date.mdx
+++ /dev/null
@@ -1,1060 +0,0 @@
-# Date
-
-<Intro>
-
-Provide bindings to JS date. (See [`Date`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date) on MDN.) JavaScript stores dates as the number of milliseconds since
-the UNIX *epoch*, midnight 1 January 1970, UTC.
-</Intro>
-
-In these examples, we will be using this date:
-
-```res prelude
-let exampleDate = Js.Date.fromFloat(123456654321.0)
-```
-
-which is Thu, 29 Nov 1973 21:30:54 GMT. There is no particular significance to this date.
-The code used to access this date is running in the Europe/Austria time zone with the `en_US.utf8` locale.
-
-In all of these functions, month values are in the range 0-11, where January is month zero.
-
-
-## t
-
-```res prelude
-type t
-```
-
-## valueOf
-
-```res sig
-let valueOf: t => float
-```
-Returns the primitive value of this date, equivalent to `getTime()`. (See [`Date.valueOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/valueOf) on MDN.)
-
-```res example
-Js.Date.valueOf(exampleDate) == 123456654321.0
-```
-
-## make
-
-```res sig
-let make: unit => t
-```
-Returns a date representing the current time. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-```res example
-let now = Js.Date.make()
-```
-
-## fromFloat
-
-```res sig
-let fromFloat: float => t
-```
-
-Returns a date representing the given argument, which is a number of milliseconds since the epoch. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-```res example
-Js.Date.fromFloat(123456654321.0) == exampleDate
-```
-
-## fromString
-
-```res sig
-let fromString: string => t
-```
-
-Returns a `Js.Date.t` represented by the given string. The string can be in “IETF-compliant RFC 2822 timestamps, and also strings in a version of ISO8601.” Returns `NaN` if given an invalid date string. According to the [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) documentation on MDN, its use is discouraged.
-
-```res example
-Js.Date.fromString("Thu, 29 Nov 1973 21:30:54.321 GMT") == exampleDate
-Js.Date.fromString("1973-11-29T21:30:54.321Z00:00") == exampleDate
-Js.Date.fromString("Thor, 32 Lok -19 60:70:80 XYZ") // returns NaN
-```
-
-## makeWithYM
-
-```res sig
-let makeWithYM: (~year: float, ~month: float, unit) => t
-```
-Returns a date representing midnight of the first day of the given month and year in the current time zone. Fractional parts of arguments are ignored. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-```res example
-let november1 = Js.Date.makeWithYM(~year=2020.0, ~month=10.0, ())
-```
-
-## makeWithYMD
-
-```res sig
-let makeWithYMD: (~year: float, ~month: float, ~date: float, unit) => t
-```
-Returns a date representing midnight of the given date of the given month and year in the current time zone. Fractional parts of arguments are ignored. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-## makeWithYMDH
-
-```res sig
-let makeWithYMDH: (~year: float, ~month: float, ~date: float, ~hours: float, unit) => t
-```
-Returns a date representing the given date of the given month and year, at zero minutes and zero seconds past the given `hours`, in the current time zone. Fractional parts of arguments are ignored. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN. Fractional parts of the arguments are ignored.
-
-## makeWithYMDHM
-
-```res sig
-let makeWithYMDHM: (
-  ~year: float,
-  ~month: float,
-  ~date: float,
-  ~hours: float,
-  ~minutes: float,
-  unit,
-) => t
-```
-Returns a date representing the given date of the given month and year, at zero seconds past the given time in hours and minutes in the current time zone.  Fractional parts of arguments are ignored. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-## makeWithYMDHMS
-
-```res sig
-let makeWithYMDHMS: (
-  ~year: float,
-  ~month: float,
-  ~date: float,
-  ~hours: float,
-  ~minutes: float,
-  ~seconds: float,
-  unit,
-) => t
-```
-Returns a date representing the given date of the given month and year, at the given time in hours, minutes, and seconds in the current time zone. Fractional parts of arguments are ignored. See [`Date()` Constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date) on MDN.
-
-```res example
-Js.Date.makeWithYMDHMS(
-  ~year=1973.0,
-  ~month=11.0,
-  ~date=29.0,
-  ~hours=21.0,
-  ~minutes=30.0,
-  ~seconds=54.321,
-  (),
-) == exampleDate
-```
-
-## utcWithYM
-
-```res sig
-let utcWithYM: (~year: float, ~month: float, unit) => float
-```
-Returns a float representing the number of milliseconds past the epoch for midnight of the first day of the given month and year in UTC. Fractional parts of arguments are ignored. See [`Date.UTC`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC) on MDN.
-
-```res example
-let november1 = Js.Date.utcWithYM(~year=2020.0, ~month=10.0, ())
-```
-
-## utcWithYMD
-
-```res sig
-let utcWithYMD: (~year: float, ~month: float, ~date: float, unit) => float
-```
-Returns a float representing the number of milliseconds past the epoch for midnight of the given date of the given month and year in UTC. Fractional parts of arguments are ignored. See [`Date.UTC`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC) on MDN.
-
-## utcWithYMDH
-
-```res sig
-let utcWithYMDH: (~year: float, ~month: float, ~date: float, ~hours: float, unit) => float
-```
-Returns a float representing the number of milliseconds past the epoch for midnight of the given date of the given month and year, at zero minutes and seconds past the given hours in UTC. Fractional parts of arguments are ignored. See [`Date.UTC`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC) on MDN.
-
-## utcWithYMDHM
-
-```res sig
-let utcWithYMDHM: (
-  ~year: float,
-  ~month: float,
-  ~date: float,
-  ~hours: float,
-  ~minutes: float,
-  unit,
-) => float
-```
-Returns a float representing the number of milliseconds past the epoch for midnight of the given date of the given month and year, at zero seconds past the given number of minutes past the given hours in UTC. Fractional parts of arguments are ignored. See [`Date.UTC`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC) on MDN.
-
-## utcWithYMDHMS
-
-```res sig
-let utcWithYMDHMS: (
-  ~year: float,
-  ~month: float,
-  ~date: float,
-  ~hours: float,
-  ~minutes: float,
-  ~seconds: float,
-  unit,
-) => float
-```
-Returns a float representing the number of milliseconds past the epoch for midnight of the given date of the given month and year, at the given time in hours, minutes and seconds in UTC. Fractional parts of arguments are ignored. See [`Date.UTC`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC) on MDN.
-
-## now
-
-```res sig
-let now: unit => float
-```
-Returns the current time as number of milliseconds since Unix epoch.
-
-## parse
-
-```res sig
-let parse: string => t
-```
-Deprecated. Use [`fromString()`](#fromstring).
-
-## parseAsFloat
-
-```res sig
-let parseAsFloat: string => float
-```
-Returns a float with the number of milliseconds past the epoch represented by the given string. The string can be in “IETF-compliant RFC 2822 timestamps, and also strings in a version of ISO8601.” Returns `NaN` if given an invalid date string. According to the [`Date.parse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/parse) documentation on MDN, its use is discouraged. Returns `NaN` if passed invalid date string.
-
-## getDate
-
-```res sig
-let getDate: t => float
-```
-Returns the day of the month for its argument. The argument is evaluated in the current time zone. See [`Date.getDate`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getDate) on MDN.
-
-```res example
-Js.Date.getDate(exampleDate) == 29.0
-```
-
-## getDay
-
-```res sig
-let getDay: t => float
-```
-Returns the day of the week (0.0-6.0) for its argument, where 0.0 represents Sunday. The argument is evaluated in the current time zone.  See [`Date.getDay`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getDay) on MDN.
-
-```res example
-Js.Date.getDay(exampleDate) == 4.0
-```
-
-## getFullYear
-
-```res sig
-let getFullYear: t => float
-```
-Returns the full year (as opposed to the range 0-99) for its argument. The argument is evaluated in the current time zone. See [`Date.getFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getFullYear) on MDN.
-
-```res example
-Js.Date.getFullYear(exampleDate) == 1973.0
-```
-
-## getHours
-
-```res sig
-let getHours: t => float
-```
-Returns the hours for its argument, evaluated in the current time zone. See [`Date.getHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getHours) on MDN.
-
-```res example
-Js.Date.getHours(exampleDate) == 22.0 // Vienna is in GMT+01:00
-```
-
-## getMilliseconds
-
-```res sig
-let getMilliseconds: t => float
-```
-Returns the number of milliseconds for its argument, evaluated in the current time zone. See [`Date.getMilliseconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds) on MDN.
-
-```res example
-Js.Date.getMilliseconds(exampleDate) == 321.0
-```
-
-## getMinutes
-
-```res sig
-let getMinutes: t => float
-```
-Returns the number of minutes for its argument, evaluated in the current time zone. See [`Date.getMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMinutes) on MDN.
-
-```res example
-Js.Date.getMinutes(exampleDate) == 30.0
-```
-
-## getMonth
-
-```res sig
-let getMonth: t => float
-```
-Returns the month (0.0-11.0) for its argument, evaluated in the current time zone. January is month zero.  See [`Date.getMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMonth) on MDN.
-
-```res example
-Js.Date.getMonth(exampleDate) == 10.0
-```
-
-## getSeconds
-
-```res sig
-let getSeconds: t => float
-```
-Returns the seconds for its argument, evaluated in the current time zone. See [`Date.getSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getSeconds) on MDN.
-
-```res example
-Js.Date.getSeconds(exampleDate) == 54.0
-```
-
-## getTime
-
-```res sig
-let getTime: t => float
-```
-Returns the number of milliseconds since Unix epoch, evaluated in UTC.  See [`Date.getTime`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTime) on MDN.
-
-```res example
-Js.Date.getTime(exampleDate) == 123456654321.0
-```
-
-## getTimezoneOffset
-
-```res sig
-let getTimezoneOffset: t => float
-```
-
-Returns the time zone offset in minutes from the current time zone to UTC. See [`Date.getTimezoneOffset`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset) on MDN.
-
-```res example
-Js.Date.getTimezoneOffset(exampleDate) == -60.0
-```
-
-## getUTCDate
-
-```res sig
-let getUTCDate: t => float
-```
-Returns the day of the month of the argument, evaluated in UTC. See [`Date.getUTCDate`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCDate) on MDN.
-
-```res example
-Js.Date.getUTCDate(exampleDate) == 29.0
-```
-
-## getUTCDay
-
-```res sig
-let getUTCDay: t => float
-```
-Returns the day of the week of the argument, evaluated in UTC. The range of the return value is 0.0-6.0, where Sunday is zero. See [`Date.getUTCDay`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCDay) on MDN.
-
-```res example
-Js.Date.getUTCDay(exampleDate) == 4.0
-```
-
-## getUTCFullYear
-
-```res sig
-let getUTCFullYear: t => float
-```
-Returns the full year (as opposed to the range 0-99) for its argument. The argument is evaluated in UTC.  See [`Date.getUTCFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear) on MDN.
-
-```res example
-Js.Date.getUTCFullYear(exampleDate) == 1973.0
-```
-
-## getUTCHours
-
-```res sig
-let getUTCHours: t => float
-```
-Returns the hours for its argument, evaluated in the current time zone. See [`Date.getUTCHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCHours) on MDN.
-
-```res example
-Js.Date.getUTCHours(exampleDate) == 21.0
-```
-
-## getUTCMilliseconds
-
-```res sig
-let getUTCMilliseconds: t => float
-```
-Returns the number of milliseconds for its argument, evaluated in UTC. See [`Date.getUTCMilliseconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds) on MDN.
-
-```res example
-Js.Date.getUTCMilliseconds(exampleDate) == 321.0
-```
-
-## getUTCMinutes
-
-```res sig
-let getUTCMinutes: t => float
-```
-Returns the number of minutes for its argument, evaluated in UTC. See [`Date.getUTCMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes) on MDN.
-
-```res example
-Js.Date.getUTCMinutes(exampleDate) == 30.0
-```
-
-## getUTCMonth
-
-```res sig
-let getUTCMonth: t => float
-```
-Returns the month (0.0-11.0) for its argument, evaluated in UTC. January is month zero. See [`Date.getUTCMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth) on MDN.
-
-```res example
-Js.Date.getUTCMonth(exampleDate) == 10.0
-```
-
-## getUTCSeconds
-
-```res sig
-let getUTCSeconds: t => float
-```
-Returns the seconds for its argument, evaluated in UTC. See [`Date.getUTCSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds) on MDN.
-
-```res example
-Js.Date.getUTCSeconds(exampleDate) == 54.0
-```
-
-## getYear
-
-```res sig
-let getYear: t => float
-```
-Deprecated. Use `getFullYear()` instead.
-
-## setDate
-
-```res sig
-let setDate: (t, float) => float
-```
-Sets the given `Date`’s day of month to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setDate`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setDate) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let twoWeeksBefore = Js.Date.setDate(date1, 15.0)
-date1 == Js.Date.fromString("1973-11-15T21:30:54.321Z00:00")
-twoWeeksBefore == Js.Date.getTime(date1)
-```
-
-## setFullYear
-
-```res sig
-let setFullYear: (t, float) => float
-```
-Sets the given `Date`’s year to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setFullYear) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let nextYear = Js.Date.setFullYear(date1, 1974.0)
-date1 == Js.Date.fromString("1974-11-15T21:30:54.321Z00:00")
-nextYear == Js.Date.getTime(date1)
-```
-
-## setFullYearM
-
-```res sig
-let setFullYearM: (t, ~year: float, ~month: float, unit) => float
-```
-
-Sets the given `Date`’s year and month to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setFullYear) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let future = Js.Date.setFullYearM(date1, ~year=1974.0, ~month=0.0, ())
-date1 == Js.Date.fromString("1974-01-22T21:30:54.321Z00:00")
-future == Js.Date.getTime(date1)
-```
-
-## setFullYearMD
-
-```res sig
-let setFullYearMD: (t, ~year: float, ~month: float, ~date: float, unit) => float
-```
-Sets the given `Date`’s year, month, and day of month to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setFullYear) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let future = Js.Date.setFullYearMD(date1, ~year=1974.0, ~month=0.0, ~date=7.0, ())
-date1 == Js.Date.fromString("1974-01-07T21:30:54.321Z00:00")
-future == Js.Date.getTime(date1)
-```
-
-## setHours
-
-```res sig
-let setHours: (t, float) => float
-```
-Sets the given `Date`’s hours to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setHours) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let nextHour = Js.Date.setHours(date1, 22.0)
-date1 == Js.Date.fromString("1973-11-29T22:30:54.321Z00:00")
-nextHour == Js.Date.getTime(date1)
-```
-
-## setHoursM
-
-```res sig
-let setHoursM: (t, ~hours: float, ~minutes: float, unit) => float
-```
-Sets the given `Date`’s hours and minutes to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setHours) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setHoursM(date1, ~hours=22.0, ~minutes=46.0, ())
-date1 == Js.Date.fromString("1973-11-29T22:46:54.321Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setHoursMS
-
-```res sig
-let setHoursMS: (t, ~hours: float, ~minutes: float, ~seconds: float, unit) => float
-```
-Sets the given `Date`’s hours, minutes, and seconds to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setHours) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setHoursMS(date1, ~hours=22.0, ~minutes=46.0, ~seconds=37.0, ())
-date1 == Js.Date.fromString("1973-11-29T22:46:37.321Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setHoursMSMs
-
-```res sig
-let setHoursMSMs: (
-  t,
-  ~hours: float,
-  ~minutes: float,
-  ~seconds: float,
-  ~milliseconds: float,
-  unit,
-) => float
-```
-Sets the given `Date`’s hours, minutes, seconds, and milliseconds to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setHours) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setHoursMSMs(
-  date1,
-  ~hours=22.0,
-  ~minutes=46.0,
-  ~seconds=37.0,
-  ~milliseconds=494.0,
-  (),
-)
-date1 == Js.Date.fromString("1973-11-29T22:46:37.494Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setMilliseconds
-
-```res sig
-let setMilliseconds: (t, float) => float
-```
-Sets the given `Date`’s milliseconds to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMilliseconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMilliseconds(date1, 494.0)
-date1 == Js.Date.fromString("1973-11-29T21:30:54.494Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setMinutes
-
-```res sig
-let setMinutes: (t, float) => float
-```
-Sets the given `Date`’s minutes to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMinutes) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMinutes(date1, 34.0)
-date1 == Js.Date.fromString("1973-11-29T21:34:54.494Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setMinutesS
-
-```res sig
-let setMinutesS: (t, ~minutes: float, ~seconds: float, unit) => float
-```
-Sets the given `Date`’s minutes and seconds to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMinutes) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMinutesS(date1, ~minutes=34.0, ~seconds=56.0, ())
-date1 == Js.Date.fromString("1973-11-29T21:34:56.494Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setMinutesSMs
-
-```res sig
-let setMinutesSMs: (t, ~minutes: float, ~seconds: float, ~milliseconds: float, unit) => float
-```
-Sets the given `Date`’s minutes, seconds, and milliseconds to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMinutes) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMinutesSMs(
-  date1,
-  ~minutes=34.0,
-  ~seconds=56.0,
-  ~milliseconds=789.0,
-  (),
-)
-date1 == Js.Date.fromString("1973-11-29T21:34:56.789Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setMonth
-
-```res sig
-let setMonth: (t, float) => float
-```
-Sets the given `Date`’s month to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMonth) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMonth(date1, 11.0)
-date1 == Js.Date.fromString("1973-12-29T21:34:56.789Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setMonthD
-
-```res sig
-let setMonthD: (t, ~month: float, ~date: float, unit) => float
-```
-Sets the given `Date`’s month and day of month to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMonth) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setMonthD(date1, ~month=11.0, ~date=8.0, ())
-date1 == Js.Date.fromString("1973-12-08T21:34:56.789Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setSeconds
-
-```res sig
-let setSeconds: (t, float) => float
-```
-Sets the given `Date`’s seconds to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setSeconds) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setSeconds(date1, 56.0)
-date1 == Js.Date.fromString("1973-12-29T21:30:56.321Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setSecondsMs
-
-```res sig
-let setSecondsMs: (t, ~seconds: float, ~milliseconds: float, unit) => float
-```
-Sets the given `Date`’s seconds and milliseconds to the values in the labeled arguments according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setSeconds) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setSecondsMs(date1, ~seconds=56.0, ~milliseconds=789.0, ())
-date1 == Js.Date.fromString("1973-12-29T21:30:56.789Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setTime
-
-```res sig
-let setTime: (t, float) => float
-```
-Sets the given `Date`’s value in terms of milliseconds since the epoch. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setTime`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setTime) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setTime(date1, 198765432101.0)
-
-date1 == Js.Date.fromString("1976-04-19T12:37:12.101Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCDate
-
-```res sig
-let setUTCDate: (t, float) => float
-```
-Sets the given `Date`’s day of month to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCDate`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCDate) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let twoWeeksBefore = Js.Date.setUTCDate(date1, 15.0)
-date1 == Js.Date.fromString("1973-11-15T21:30:54.321Z00:00")
-twoWeeksBefore == Js.Date.getTime(date1)
-```
-
-## setUTCFullYear
-
-```res sig
-let setUTCFullYear: (t, float) => float
-```
-Sets the given `Date`’s year to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let nextYear = Js.Date.setUTCFullYear(date1, 1974.0)
-date1 == Js.Date.fromString("1974-11-15T21:30:54.321Z00:00")
-nextYear == Js.Date.getTime(date1)
-```
-
-## setUTCFullYearM
-
-```res sig
-let setUTCFullYearM: (t, ~year: float, ~month: float, unit) => float
-```
-Sets the given `Date`’s year and month to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let future = Js.Date.setUTCFullYearM(date1, ~year=1974.0, ~month=0.0, ())
-date1 == Js.Date.fromString("1974-01-22T21:30:54.321Z00:00")
-future == Js.Date.getTime(date1)
-```
-
-## setUTCFullYearMD
-
-```res sig
-let setUTCFullYearMD: (t, ~year: float, ~month: float, ~date: float, unit) => float
-```
-Sets the given `Date`’s year, month, and day of month to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCFullYear`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let future = Js.Date.setUTCFullYearMD(date1, ~year=1974.0, ~month=0.0, ~date=7.0, ())
-date1 == Js.Date.fromString("1974-01-07T21:30:54.321Z00:00")
-future == Js.Date.getTime(date1)
-```
-
-## setUTCHours
-
-```res sig
-let setUTCHours: (t, float) => float
-```
-Sets the given `Date`’s hours to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCHours) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let nextHour = Js.Date.setUTCHours(date1, 22.0)
-date1 == Js.Date.fromString("1973-11-29T22:30:54.321Z00:00")
-nextHour == Js.Date.getTime(date1)
-```
-
-## setUTCHoursM
-
-```res sig
-let setUTCHoursM: (t, ~hours: float, ~minutes: float, unit) => float
-```
-Sets the given `Date`’s hours and minutes to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCHours) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCHoursM(date1, ~hours=22.0, ~minutes=46.0, ())
-date1 == Js.Date.fromString("1973-11-29T22:46:54.321Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCHoursMS
-
-```res sig
-let setUTCHoursMS: (t, ~hours: float, ~minutes: float, ~seconds: float, unit) => float
-```
-Sets the given `Date`’s hours, minutes, and seconds to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCHours) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCHoursMS(date1, ~hours=22.0, ~minutes=46.0, ~seconds=37.0, ())
-date1 == Js.Date.fromString("1973-11-29T22:46:37.321Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCHoursMSMs
-
-```res sig
-let setUTCHoursMSMs: (
-  t,
-  ~hours: float,
-  ~minutes: float,
-  ~seconds: float,
-  ~milliseconds: float,
-  unit,
-) => float
-```
-Sets the given `Date`’s hours, minutes, seconds, and milliseconds to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCHours`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCHours) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCHoursMSMs(
-  date1,
-  ~hours=22.0,
-  ~minutes=46.0,
-  ~seconds=37.0,
-  ~milliseconds=494.0,
-  (),
-)
-date1 == Js.Date.fromString("1973-11-29T22:46:37.494Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCMilliseconds
-
-```res sig
-let setUTCMilliseconds: (t, float) => float
-```
-Sets the given `Date`’s milliseconds to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMilliseconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMilliseconds(date1, 494.0)
-date1 == Js.Date.fromString("1973-11-29T21:30:54.494Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCMinutes
-
-```res sig
-let setUTCMinutes: (t, float) => float
-```
-Sets the given `Date`’s minutes to the value in the second argument according to the current time zone. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMinutes(date1, 34.0)
-date1 == Js.Date.fromString("1973-11-29T21:34:54.494Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCMinutesS
-
-```res sig
-let setUTCMinutesS: (t, ~minutes: float, ~seconds: float, unit) => float
-```
-Sets the given `Date`’s minutes and seconds to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMinutesS(date1, ~minutes=34.0, ~seconds=56.0, ())
-date1 == Js.Date.fromString("1973-11-29T21:34:56.494Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCMinutesSMs
-
-```res sig
-let setUTCMinutesSMs: (t, ~minutes: float, ~seconds: float, ~milliseconds: float, unit) => float
-```
-Sets the given `Date`’s minutes, seconds, and milliseconds to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMinutes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMinutesSMs(
-  date1,
-  ~minutes=34.0,
-  ~seconds=56.0,
-  ~milliseconds=789.0,
-  (),
-)
-date1 == Js.Date.fromString("1973-11-29T21:34:56.789Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCMonth
-
-```res sig
-let setUTCMonth: (t, float) => float
-```
-Sets the given `Date`’s month to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMonth(date1, 11.0)
-date1 == Js.Date.fromString("1973-12-29T21:34:56.789Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCMonthD
-
-```res sig
-let setUTCMonthD: (t, ~month: float, ~date: float, unit) => float
-```
-Sets the given `Date`’s month and day of month to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCMonth`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCMonthD(date1, ~month=11.0, ~date=8.0, ())
-date1 == Js.Date.fromString("1973-12-08T21:34:56.789Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCSeconds
-
-```res sig
-let setUTCSeconds: (t, float) => float
-```
-Sets the given `Date`’s seconds to the value in the second argument according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCSeconds(date1, 56.0)
-date1 == Js.Date.fromString("1973-12-29T21:30:56.321Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCSecondsMs
-
-```res sig
-let setUTCSecondsMs: (t, ~seconds: float, ~milliseconds: float, unit) => float
-```
-Sets the given `Date`’s seconds and milliseconds to the values in the labeled arguments according to UTC. Returns the number of milliseconds since the epoch of the updated `Date`. *This function modifies the original `Date`.* See [`Date.setUTCSeconds`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds) on MDN.
-
-```res example
-let date1 = Js.Date.fromFloat(123456654321.0) // 29 November 1973 21:30:54.321 GMT
-let futureTime = Js.Date.setUTCSecondsMs(date1, ~seconds=56.0, ~milliseconds=789.0, ())
-date1 == Js.Date.fromString("1973-12-29T21:30:56.789Z00:00")
-futureTime == Js.Date.getTime(date1)
-```
-
-## setUTCTime
-
-```res sig
-let setUTCTime: (t, float) => float
-```
-Same as [`setTime()`](#settime).
-
-## setYear
-
-```res sig
-let setYear: (t, float) => float
-```
-Deprecated. Use [`setFullYear()`](#setfullyear) instead.
-
-## toDateString
-
-```res sig
-let toDateString: t => string
-```
-Returns the date (day of week, year, month, and day of month) portion of a `Date` in English. See [`Date.toDateString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toDateString) on MDN.
-
-```res example
-Js.Date.toDateString(exampleDate) == "Thu Nov 29 1973"
-```
-
-## toGMTString
-
-```res sig
-let toGMTString: t => string
-```
-Deprecated. Use [`toUTCString()`](#toutcstring) instead.
-
-## toISOString
-
-```res sig
-let toISOString: t => string
-```
-Returns a simplified version of the ISO 8601 format for the date. See [`Date.toISOString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) on MDN.
-
-```res example
-Js.Date.toISOString(exampleDate) == "1973-11-29T21:30:54.321Z"
-```
-
-## toJSON
-
-```res sig
-let toJSON: t => string
-```
-Deprecated. This method is unsafe. It will be changed to return `option` in a future release. Please use `toJSONUnsafe()` instead.
-
-## toJSONUnsafe
-
-```res sig
-let toJSONUnsafe: t => string
-```
-Returns a string representation of the given date. See [`Date.toJSON`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toJSON) on MDN.
-
-```res example
-Js.Date.toJSONUnsafe(exampleDate) == "1973-11-29T21:30:54.321Z"
-```
-
-## toLocaleDateString
-
-```res sig
-let toLocaleDateString: t => string
-```
-
-Returns the year, month, and day for the given `Date` in the current locale format. See [`Date.toLocaleDateString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString) on MDN.
-
-```res example
-Js.Date.toLocaleDateString(exampleDate) == "11/29/1973" // for en_US.utf8
-Js.Date.toLocaleDateString(exampleDate) == "29.11.73" // for de_DE.utf8
-```
-
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-Returns the time and date for the given `Date` in the current locale format. See [`Date.toLocaleString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString) on MDN.
-
-```res example
-Js.Date.toLocaleString(exampleDate) == "11/29/1973, 10:30:54 PM" // for en_US.utf8
-Js.Date.toLocaleString(exampleDate) == "29.11.1973, 22:30:54" // for de_DE.utf8
-```
-
-## toLocaleTimeString
-
-```res sig
-let toLocaleTimeString: t => string
-```
-Returns the time of day for the given `Date` in the current locale format. See [`Date.toLocaleTimeString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString) on MDN.
-
-```res example
-Js.Date.toLocaleString(exampleDate) == "10:30:54 PM" // for en_US.utf8
-Js.Date.toLocaleString(exampleDate) == "22:30:54" // for de_DE.utf8
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-Returns a string representing the date and time of day for the given `Date` in the current locale and time zone. See [`Date.toString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toString) on MDN.
-
-```res example
-Js.Date.toString(
-  exampleDate,
-) == "Thu Nov 29 1973 22:30:54 GMT+0100 (Central European Standard Time)"
-```
-
-## toTimeString
-
-```res sig
-let toTimeString: t => string
-```
-
-Returns a string representing the time of day for the given `Date` in the current locale and time zone.  See [`Date.toTimeString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toTimeString) on MDN.
-
-```res example
-Js.Date.toTimeString(exampleDate) == "22:30:54 GMT+0100 (Central European Standard Time)"
-```
-
-## toUTCString
-
-```res sig
-let toUTCString: t => string
-```
-
-Returns a string representing the date and time of day for the given `Date` in the current locale and UTC (GMT time zone). See [`Date.toUTCString`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toUTCString) on MDN.
-
-```res example
-Js.Date.toUTCString(exampleDate) == "Thu, 29 Nov 1973 21:30:54 GMT"
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/dict.mdx b/pages/docs/manual/v9.0.0/api/js/dict.mdx
deleted file mode 100644
index 881527a9e..000000000
--- a/pages/docs/manual/v9.0.0/api/js/dict.mdx
+++ /dev/null
@@ -1,164 +0,0 @@
-# Dict
-
-<Intro>
-
-Provide utilities for JS dictionary object.
-
-**Note:** This module's examples will assume this predeclared dictionary:
-
-```res prelude
-let ages = Js.Dict.fromList(list{("Maria", 30), ("Vinh", 22), ("Fred", 49)})
-```
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a>
-```
-
-Dictionary type (ie an '{ }' JS object). However it is restricted to hold a single type; therefore values must have the same type.
-This Dictionary type is mostly used with the Js_json.t type.
-
-## key
-
-```res prelude
-type key = string
-```
-
-The type for dictionary keys. This means that dictionaries *must* use `string`s as their keys.
-
-## get
-
-```res sig
-let get: (t<'a>, key) => option<'a>
-```
-
-`Js.Dict.get(key)` returns `None` if the key is not found in the dictionary, `Some(value)` otherwise.
-
-```res example
-Js.Dict.get(ages, "Vinh") == Some(22)
-Js.Dict.get(ages, "Paul") == None
-```
-
-## unsafeGet
-
-```res sig
-let unsafeGet: (t<'a>, key) => 'a
-```
-`Js.Dict.unsafeGet(key)` returns the value if the key exists, otherwise an `undefined` value is returned. Use this only when you are sure the key exists (i.e. when having used the `keys()` function to check that the key is valid).
-
-```res example
-Js.Dict.unsafeGet(ages, "Fred") == 49
-Js.Dict.unsafeGet(ages, "Paul") // returns undefined
-```
-
-## set
-
-```res sig
-let set: (t<'a>, key, 'a) => unit
-```
-
-`Js.Dict.set(dict, key, value)` sets the key/value in the dictionary `dict`. If the key does not exist, and entry will be created for it. *This function modifies the original dictionary.*
-
-```res example
-Js.Dict.set(ages, "Maria", 31)
-Js.log(ages == Js.Dict.fromList(list{("Maria", 31), ("Vinh", 22), ("Fred", 49)}))
-
-Js.Dict.set(ages, "David", 66)
-Js.log(ages == Js.Dict.fromList(list{("Maria", 31), ("Vinh", 22), ("Fred", 49), ("David", 66)}))
-```
-
-## keys
-
-```res sig
-let keys: t<'a> => array<string>
-```
-
-Returns all the keys in the dictionary `dict`.
-
-```res example
-Js.Dict.keys(ages) == ["Maria", "Vinh", "Fred"]
-```
-
-## empty
-
-```res sig
-let empty: unit => t<'a>
-```
-
-Returns an empty dictionary.
-
-## unsafeDeleteKey
-
-```res sig
-let unsafeDeleteKey: (. t<string>, string) => unit
-```
-
-Experimental internal function
-
-## entries
-
-```res sig
-let entries: t<'a> => array<(key, 'a)>
-```
-
-Returns an array of key/value pairs in the given dictionary (ES2017).
-
-```res example
-Js.Dict.entries(ages) == [("Maria", 30), ("Vinh", 22), ("Fred", 49)]
-```
-
-## values
-
-```res sig
-let values: t<'a> => array<'a>
-```
-
-Returns the values in the given dictionary (ES2017).
-
-```res example
-Js.Dict.values(ages) == [30, 22, 49]
-```
-
-## fromList
-
-```res sig
-let fromList: list<(key, 'a)> => t<'a>
-```
-
-Creates a new dictionary containing each (key, value) pair in its list argument.
-
-```res example
-let capitals = Js.Dict.fromList(list{("Japan", "Tokyo"), ("France", "Paris"), ("Egypt", "Cairo")})
-```
-
-## fromArray
-
-```res sig
-let fromArray: array<(key, 'a)> => t<'a>
-```
-
-Creates a new dictionary containing each (key, value) pair in its array argument.
-
-```res example
-let capitals2 = Js.Dict.fromArray([("Germany", "Berlin"), ("Burkina Faso", "Ouagadougou")])
-```
-
-## map
-
-```res sig
-let map: ((. 'a) => 'b, t<'a>) => t<'b>
-```
-
-`map(f, dict)` maps `dict` to a new dictionary with the same keys, using the function `f` to map each value.
-
-```res example
-let prices = Js.Dict.fromList(list{("pen", 1.00), ("book", 5.00), ("stapler", 7.00)})
-
-let discount = (. price) => price *. 0.90
-let salePrices = Js.Dict.map(discount, prices)
-
-salePrices == Js.Dict.fromList(list{("pen", 0.90), ("book", 4.50), ("stapler", 6.30)})
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/exn.mdx b/pages/docs/manual/v9.0.0/api/js/exn.mdx
deleted file mode 100644
index 730a4b2ed..000000000
--- a/pages/docs/manual/v9.0.0/api/js/exn.mdx
+++ /dev/null
@@ -1,103 +0,0 @@
-# Exn
-
-<Intro>
-
-Provide utilities for dealing with JS exceptions.
-
-</Intro>
-
-## t
-
-```res prelude
-type t
-```
-
-## exn
-
-```res sig
-type exn +=
-  private
-  | Error(t)
-```
-
-## asJsExn
-
-```res sig
-let asJsExn: exn => option<t>
-```
-
-## stack
-
-```res sig
-let stack: t => option<string>
-```
-
-## message
-
-```res sig
-let message: t => option<string>
-```
-
-## name
-
-```res sig
-let name: t => option<string>
-```
-
-## fileName
-
-```res sig
-let fileName: t => option<string>
-```
-
-## isCamlExceptionOrOpenVariant
-
-```res sig
-let isCamlExceptionOrOpenVariant: 'a => bool
-```
-
-Internal use only.
-
-## raiseError
-
-```res sig
-let raiseError: string => 'a
-```
-
-Raise Js exception Error object with stacktrace.
-
-## raiseEvalError
-
-```res sig
-let raiseEvalError: string => 'a
-```
-
-## raiseRangeError
-
-```res sig
-let raiseRangeError: string => 'a
-```
-
-## raiseReferenceError
-
-```res sig
-let raiseReferenceError: string => 'a
-```
-
-## raiseSyntaxError
-
-```res sig
-let raiseSyntaxError: string => 'a
-```
-
-## raiseTypeError
-
-```res sig
-let raiseTypeError: string => 'a
-```
-
-## raiseUriError
-
-```res sig
-let raiseUriError: string => 'a
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/float.mdx b/pages/docs/manual/v9.0.0/api/js/float.mdx
deleted file mode 100644
index 1da019985..000000000
--- a/pages/docs/manual/v9.0.0/api/js/float.mdx
+++ /dev/null
@@ -1,282 +0,0 @@
-# Float
-
-<Intro>
-
-Provide utilities for JS float.
-
-</Intro>
-
-## _NaN
-
-```res sig
-let _NaN: float
-```
-The special value "Not a Number".
-
-## isNaN
-
-```res sig
-let isNaN: float => bool
-```
-
-Tests if the given value is _NaN.
-Note that both `_NaN == _NaN` and `_NaN === _NaN` will return false. `isNaN` is therefore necessary to test for `_NaN`.
-
-Returns true if the given value is `_NaN`, false otherwise.
-
-## isFinite
-
-```res sig
-let isFinite: float => bool
-```
-
-Tests if the given value is finite.
-Returns true if the given value is a finite number, false otherwise.
-
-```res example
-/* returns [false] */
-Js.Float.isFinite(infinity)
-```
-
-```res example
-/* returns [false] */
-Js.Float.isFinite(neg_infinity)
-```
-
-```res example
-/* returns [false] */
-Js.Float.isFinite(Js.Float._NaN)
-```
-
-```res example
-/* returns [true] */
-Js.Float.isFinite(1234.)
-```
-
-## toExponential
-
-```res sig
-let toExponential: float => string
-```
-
-Formats a float using exponential (scientific) notation.
-Returns a string representing the given value in exponential notation.
-Raises `RangeError` if `digits` is not in the range \[0, 20\] (inclusive).
-
-```res example
-/* prints "7.71234e+1" */
-Js.Float.toExponential(77.1234)->Js.log
-```
-
-```res example
-/* prints "7.7e+1" */
-Js.Float.toExponential(77.)->Js.log
-```
-
-## toExponentialWithPrecision
-
-```res sig
-let toExponentialWithPrecision: (float, ~digits: int) => string
-```
-
-Formats a `float` using exponential (scientific) notation.
-`digits` specifies how many digits should appear after the decimal point. The value must be in the range \[0, 20\] (inclusive).
-
-Returns a `string` representing the given value in exponential notation.
-
-The output will be rounded or padded with zeroes if necessary.
-Raises `RangeError` if `digits` is not in the range \[0, 20\] (inclusive).
-
-```res example
-/* prints "7.71e+1" */
-Js.Float.toExponentialWithPrecision(77.1234, ~digits=2)->Js.log
-```
-
-## toFixed
-
-```res sig
-let toFixed: float => string
-```
-
-Formats a `float` using fixed point notation.
-Returns a `string` representing the given value in fixed-point notation (usually).
-Raises `RangeError` if `digits` is not in the range \[0, 20\] (inclusive).
-
-```res example
-/* prints "12346" (note the rounding) */
-Js.Float.toFixed(12345.6789)->Js.log
-```
-
-```res example
-/* print "1.2e+21" */
-Js.Float.toFixed(1.2e21)->Js.log
-```
-
-## toFixedWithPrecision
-
-```res sig
-let toFixedWithPrecision: (float, ~digits: int) => string
-```
-
-Formats a `float` using fixed point notation.
-`digits` specifies how many digits should appear after the decimal point. The value must be in the range \[0, 20\] (inclusive). Defaults to 0.
-
-Returns a `string` representing the given value in fixed-point notation (usually).
-
-The output will be rounded or padded with zeroes if necessary.
-Raises `RangeError` if `digits` is not in the range \[0, 20\] (inclusive).
-
-```res example
-/* prints "12345.7" (note the rounding) */
-Js.Float.toFixedWithPrecision(12345.6789, ~digits=1)->Js.log
-```
-
-```res example
-/* prints "0.00" (note the added zeroes) */
-Js.Float.toFixedWithPrecision(0., ~digits=2)->Js.log
-```
-
-## toPrecision
-
-```res sig
-let toPrecision: float => string
-```
-
-Formats a `float` using some fairly arbitrary rules.
-Returns a `string` representing the given value in fixed-point (usually).
-
-`toPrecision` differs from `toFixed` in that the former will format the number with full precision, while the latter will not output any digits after the decimal point.
-Raises `RangeError` if `digits` is not in the range accepted by this function.
-
-```res example
-/* prints "12345.6789" */
-Js.Float.toPrecision(12345.6789)->Js.log
-```
-
-```res example
-/* print "1.2e+21" */
-Js.Float.toPrecision(1.2e21)->Js.log
-```
-
-## toPrecisionWithPrecision
-
-```res sig
-let toPrecisionWithPrecision: (float, ~digits: int) => string
-```
-
-Formats a `float` using some fairly arbitrary rules.
-`digits` specifies how many digits should appear in total. The value must be between 0 and some arbitrary number that's hopefully at least larger than 20 (for Node it's 21. Why? Who knows).
-
-Returns a `string` representing the given value in fixed-point or scientific notation.
-
-The output will be rounded or padded with zeroes if necessary.
-
-`toPrecisionWithPrecision` differs from `toFixedWithPrecision` in that the former will count all digits against the precision, while the latter will count only the digits after the decimal point.
-`toPrecisionWithPrecision` will also use scientific notation if the specified precision is less than the number for digits before the decimal point.
-Raises `RangeError` if `digits` is not in the range accepted by this function.
-
-```res example
-/* prints "1e+4" */
-Js.Float.toPrecisionWithPrecision(12345.6789, ~digits=1)->Js.log
-```
-
-```res example
-/* prints "0.0" */
-Js.Float.toPrecisionWithPrecision(0., ~digits=2)->Js.log
-```
-
-## toString
-
-```res sig
-let toString: float => string
-```
-
-Formats a `float` as a `string`.
-Returns a `string` representing the given value in fixed-point (usually).
-
-```res example
-/* prints "12345.6789" */
-Js.Float.toString(12345.6789)->Js.log
-```
-
-## toStringWithRadix
-
-```res sig
-let toStringWithRadix: (float, ~radix: int) => string
-```
-
-Formats a `float` as a `string`.
-`radix` specifies the radix base to use for the formatted number. The value must be in the range \[2, 36\] (inclusive).
-
-Returns a `string` representing the given value in fixed-point (usually).
-Raises `RangeError` if `radix` is not in the range \[2, 36\] (inclusive).
-
-```res example
-/* prints "110" */
-Js.Float.toStringWithRadix(6., ~radix=2)->Js.log
-```
-
-```res example
-/* prints "11.001000111101011100001010001111010111000010100011111" */
-Js.Float.toStringWithRadix(3.14, ~radix=2)->Js.log
-```
-
-```res example
-/* prints "deadbeef" */
-Js.Float.toStringWithRadix(3735928559., ~radix=16)->Js.log
-
-```
-
-```res example
-/* prints "3f.gez4w97ry0a18ymf6qadcxr" */
-Js.Float.toStringWithRadix(123.456, ~radix=36)->Js.log
-```
-
-## fromString
-
-```res sig
-let fromString: string => float
-```
-
-Parses the given `string` into a `float` using JavaScript semantics.
-Returns the number as a `float` if successfully parsed, `_NaN` otherwise.
-
-```res example
-/* returns 123 */
-Js.Float.fromString("123")
-```
-
-```res example
-/* returns 12.3 */
-Js.Float.fromString("12.3")
-```
-
-```res example
-/* returns 0 */
-Js.Float.fromString("")
-```
-
-```res example
-/* returns 17 */
-Js.Float.fromString("0x11")
-```
-
-```res example
-/* returns 3 */
-Js.Float.fromString("0b11")
-```
-
-```res example
-/* returns 9 */
-Js.Float.fromString("0o11")
-```
-
-```res example
-/* returns [_NaN] */
-Js.Float.fromString("hello")
-```
-
-```res example
-/* returns [_NaN] */
-Js.Float.fromString("100a")
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/global.mdx b/pages/docs/manual/v9.0.0/api/js/global.mdx
deleted file mode 100644
index 7bba67610..000000000
--- a/pages/docs/manual/v9.0.0/api/js/global.mdx
+++ /dev/null
@@ -1,179 +0,0 @@
-# Global
-
-<Intro>
-
-Provide bindings to JS global functions in global namespace.
-
-</Intro>
-
-```res prelude
-type intervalId
-```
-
-Identify an interval started by `Js.Global.setInterval`.
-
-```res prelude
-type timeoutId
-```
-
-Identify timeout started by `Js.Global.setTimeout`.
-
-## clearInterval
-
-```res sig
-let clearInterval: intervalId => unit
-```
-
-Clear an interval started by `Js.Global.setInterval`
-
-```res example
-/* API for a somewhat aggressive snoozing alarm clock */
-
-let punchSleepyGuy = () => Js.log("Punch")
-
-let interval = ref(Js.Nullable.null)
-
-let remind = () => {
-  Js.log("Wake Up!")
-  punchSleepyGuy()
-}
-
-let snooze = mins =>
-  interval := Js.Nullable.return(Js.Global.setInterval(remind, mins * 60 * 1000))
-
-let cancel = () =>
-  Js.Nullable.iter(interval.contents, (. intervalId) => Js.Global.clearInterval(intervalId))
-```
-
-## clearTimeout
-
-```res sig
-let clearTimeout: timeoutId => unit
-```
-
-Clear a timeout started by `Js.Global.setTimeout`.
-
-```res example
-/* A simple model of a code monkey's brain */
-
-let closeHackerNewsTab = () => Js.log("close")
-
-let timer = ref(Js.Nullable.null)
-
-let work = () => closeHackerNewsTab()
-
-let procrastinate = mins => {
-  Js.Nullable.iter(timer.contents, (. timer) => Js.Global.clearTimeout(timer))
-  timer := Js.Nullable.return(Js.Global.setTimeout(work, mins * 60 * 1000))
-}
-```
-
-## setInterval
-
-```res sig
-let setInterval: (unit => unit, int) => intervalId
-```
-
-Repeatedly executes a callback with a specified interval (in milliseconds) between calls.
-Returns a `Js.Global.intervalId` that can be passed to `Js.Global.clearInterval` to cancel the timeout.
-
-```res example
-/* Will count up and print the count to the console every second */
-
-let count = ref(0)
-
-let tick = () => {
-  count := count.contents + 1
-  Js.log(Belt.Int.toString(count.contents))
-}
-
-Js.Global.setInterval(tick, 1000)
-```
-
-## setIntervalFloat
-
-```res sig
-let setIntervalFloat: (unit => unit, float) => intervalId
-```
-
-Repeatedly executes a callback with a specified interval (in milliseconds) between calls.
-Returns a `Js.Global.intervalId` that can be passed to `Js.Global.clearInterval` to cancel the timeout.
-
-```res example
-/* Will count up and print the count to the console every second */
-
-let count = ref(0)
-
-let tick = () => {
-  count := count.contents + 1
-  Js.log(Belt.Int.toString(count.contents))
-}
-
-Js.Global.setIntervalFloat(tick, 1000.0)
-```
-
-## setTimeout
-
-```res sig
-let setTimeout: (unit => unit, int) => timeoutId
-```
-
-Execute a callback after a specified delay (in milliseconds).
-Returns a `Js.Global.timeoutId` that can be passed to `Js.Global.clearTimeout` to cancel the timeout.
-
-```res example
-/* Prints "Timed out!" in the console after one second */
-
-let message = "Timed out!"
-
-Js.Global.setTimeout(() => Js.log(message), 1000)
-```
-
-## setTimeoutFloat
-
-```res sig
-let setTimeoutFloat: (unit => unit, float) => timeoutId
-```
-
-Execute a callback after a specified delay (in milliseconds).
-Returns a `Js.Global.timeoutId` that can be passed to `Js.Global.clearTimeout` to cancel the timeout.
-
-```res example
-/* Prints "Timed out!" in the console after one second */
-
-let message = "Timed out!"
-
-Js.Global.setTimeoutFloat(() => Js.log(message), 1000.0)
-```
-
-## encodeURI
-
-```res sig
-let encodeURI: string => string
-```
-
-URL-encodes a string.
-
-## decodeURI
-
-```res sig
-let decodeURI: string => string
-```
-
-Decodes a URL-enmcoded string produced by encodeURI.
-
-## encodeURIComponent
-
-```res sig
-let encodeURIComponent: string => string
-```
-
-URL-encodes a string, including characters with special meaning in a URI.
-
-## decodeURIComponent
-
-```res sig
-let decodeURIComponent: string => string
-```
-
-Decodes a URL-enmcoded string produced by encodeURIComponent
diff --git a/pages/docs/manual/v9.0.0/api/js/int.mdx b/pages/docs/manual/v9.0.0/api/js/int.mdx
deleted file mode 100644
index 1fc48b47a..000000000
--- a/pages/docs/manual/v9.0.0/api/js/int.mdx
+++ /dev/null
@@ -1,146 +0,0 @@
-# Int
-
-<Intro>
-
-Provide utilities for handling `int`.
-
-</Intro>
-
-## toExponential
-
-```res sig
-let toExponential: int => string
-```
-
-Formats an `int` using exponential (scientific) notation.
-Returns a `string` representing the given value in exponential notation.
-Raises `RangeError` if digits is not in the range \[0, 20\] (inclusive).
-
-```res example
-/* prints "7.7e+1" */
-Js.log(Js.Int.toExponential(77))
-```
-
-## toExponentialWithPrecision
-
-```res sig
-let toExponentialWithPrecision: (int, ~digits: int) => string
-```
-
-Formats an `int` using exponential (scientific) notation.
-`digits` specifies how many digits should appear after the decimal point. The value must be in the range \[0, 20\] (inclusive).
-
-Returns a `string` representing the given value in exponential notation.
-
-The output will be rounded or padded with zeroes if necessary.
-Raises `RangeError` if `digits` is not in the range \[0, 20\] (inclusive).
-
-```res example
-/* prints "7.70e+1" */
-Js.log(Js.Int.toExponentialWithPrecision(77, ~digits=2))
-
-/* prints "5.68e+3" */
-Js.log(Js.Int.toExponentialWithPrecision(5678, ~digits=2))
-```
-
-## toPrecision
-
-```res sig
-let toPrecision: int => string
-```
-
-Formats an `int` using some fairly arbitrary rules.
-Returns a `string` representing the given value in fixed-point (usually).
-
-`toPrecision` differs from `toFixed` in that the former will format the number with full precision, while the latter will not output any digits after the decimal point.
-Raises `RangeError` if `digits` is not in the range accepted by this function.
-
-```res example
-/* prints "123456789" */
-Js.log(Js.Int.toPrecision(123456789))
-```
-
-## toPrecisionWithPrecision
-
-```res sig
-let toPrecisionWithPrecision: (int, ~digits: int) => string
-```
-
-Formats an `int` using some fairly arbitrary rules.
-`digits` specifies how many digits should appear in total. The value must between 0 and some arbitrary number that's hopefully at least larger than 20 (for Node it's 21. Why? Who knows).
-
-Returns a `string` representing the given value in fixed-point or scientific notation.
-
-The output will be rounded or padded with zeroes if necessary.
-
-`toPrecisionWithPrecision` differs from `toFixedWithPrecision` in that the former will count all digits against the precision, while the latter will count only the digits after the decimal point.
-`toPrecisionWithPrecision` will also use scientific notation if the specified precision is less than the number of digits before the decimal point.
-Raises `RangeError` if `digits` is not in the range accepted by this function.
-
-```res example
-/* prints "1.2e+8" */
-Js.log(Js.Int.toPrecisionWithPrecision(123456789, ~digits=2))
-
-/* prints "0.0" */
-Js.log(Js.Int.toPrecisionWithPrecision(0, ~digits=2))
-```
-
-## toString
-
-```res sig
-let toString: int => string
-```
-
-Formats an `int` as a `string`.
-Returns a `string` representing the given value in fixed-point (usually).
-
-```res example
-/* prints "123456789" */
-Js.log(Js.Int.toString(123456789))
-```
-
-## toStringWithRadix
-
-```res sig
-let toStringWithRadix: (int, ~radix: int) => string
-```
-
-Formats an `int` as a `string`.
-`radix` specifies the radix base to use for the formatted number. The value must be in the range \[2, 36\] (inclusive).
-Returns a `string` representing the given value in fixed-point (usually).
-Raises `RangeError` if `radix` is not in the range \[2, 36\] (inclusive).
-
-```res example
-/* prints "110" */
-Js.log(Js.Int.toStringWithRadix(6, ~radix=2))
-
-/* prints "deadbeef" */
-Js.log(Js.Int.toStringWithRadix(3735928559, ~radix=16))
-
-/* prints "2n9c" */
-Js.log(Js.Int.toStringWithRadix(123456, ~radix=36))
-```
-
-## toFloat
-
-```res sig
-let toFloat: int => float
-```
-
-## equal
-
-```res sig
-let equal: (int, int) => bool
-```
-
-## max
-
-```res sig
-let max: int
-```
-
-## min
-
-```res sig
-let min: int
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/json.mdx b/pages/docs/manual/v9.0.0/api/js/json.mdx
deleted file mode 100644
index ca48da776..000000000
--- a/pages/docs/manual/v9.0.0/api/js/json.mdx
+++ /dev/null
@@ -1,293 +0,0 @@
-# Json
-
-<Intro>
-
-Provide utilities for JSON.
-
-</Intro>
-
-## t
-
-```res prelude
-type t
-```
-
-The JSON data structure.
-
-## kind
-
-```res prelude
-type rec kind<'a> =
-  | String: kind<Js_string.t>
-  | Number: kind<float>
-  | Object: kind<Js_dict.t<t>>
-  | Array: kind<array<t>>
-  | Boolean: kind<bool>
-  | Null: kind<Js_types.null_val>
-```
-
-Underlying type of a JSON value.
-
-## tagged_t
-
-```res prelude
-type tagged_t =
-  | JSONFalse
-  | JSONTrue
-  | JSONNull
-  | JSONString(string)
-  | JSONNumber(float)
-  | JSONObject(Js_dict.t<t>)
-  | JSONArray(array<t>)
-```
-
-
-## classify
-
-```res sig
-let classify: t => tagged_t
-```
-
-## test
-
-```res sig
-let test: ('a, kind<'b>) => bool
-```
-
-`test(v, kind)` returns `true` if `v` is of `kind`.
-
-## decodeString
-
-```res sig
-let decodeString: t => option<Js_string.t>
-```
-
-`decodeString(json)` returns `Some(s)` if `json` is a `string`, `None` otherwise.
-
-## decodeNumber
-
-```res sig
-let decodeNumber: t => option<float>
-```
-
-`decodeNumber(json)` returns `Some(n)` if `json` is a `number`, `None` otherwise.
-
-## decodeObject
-
-```res sig
-let decodeObject: t => option<Js_dict.t<t>>
-```
-
-`decodeObject(json)` returns `Some(o)` if `json` is an `object`, `None` otherwise.
-
-## decodeArray
-
-```res sig
-let decodeArray: t => option<array<t>>
-```
-
-`decodeArray(json)` returns `Some(a)` if `json` is an `array`, `None` otherwise.
-
-## decodeBoolean
-
-```res sig
-let decodeBoolean: t => option<bool>
-```
-
-`decodeBoolean(json)` returns `Some(b)` if `json` is a `boolean`, `None` otherwise.
-
-## decodeNull
-
-```res sig
-let decodeNull: t => option<Js_null.t<'a>>
-```
-
-`decodeNull(json)` returns `Some(null)` if `json` is a `null`, `None` otherwise.
-
-## null
-
-```res sig
-let null: t
-```
-
-`null` is the singleton null JSON value.
-
-## string
-
-```res sig
-let string: string => t
-```
-
-`string(s)` makes a JSON string of the `string` `s`.
-
-## number
-
-```res sig
-let number: float => t
-```
-
-`number(n)` makes a JSON number of the `float` `n`.
-
-## boolean
-
-```res sig
-let boolean: bool => t
-```
-
-`boolean(b)` makes a JSON boolean of the `bool` `b`.
-
-## object_
-
-```res sig
-let object_: Js_dict.t<t> => t
-```
-
-`object_(dict)` makes a JSON object of the `Js.Dict.t` `dict`.
-
-## array
-
-```res sig
-let array: array<t> => t
-```
-
-`array_(a)` makes a JSON array of the `Js.Json.t` array `a`.
-
-## stringArray
-
-```res sig
-let stringArray: array<string> => t
-```
-
-`stringArray(a)` makes a JSON array of the `string` array `a`.
-
-## numberArray
-
-```res sig
-let numberArray: array<float> => t
-```
-
-`numberArray(a)` makes a JSON array of the `float` array `a`.
-
-## booleanArray
-
-```res sig
-let booleanArray: array<bool> => t
-```
-
-`booleanArray(a)` makes a JSON array of the `bool` array `a`.
-
-## objectArray
-
-```res sig
-let objectArray: array<Js_dict.t<t>> => t
-```
-
-`objectArray(a) makes a JSON array of the `JsDict.t` array `a`.
-
-## parseExn
-
-```res sig
-let parseExn: string => t
-```
-
-`parseExn(s)` parses the `string` `s` into a JSON data structure.
-Returns a JSON data structure.
-Raises `SyntaxError` if the given string is not a valid JSON. Note: `SyntaxError` is a JavaScript exception.
-
-```res example
-/* parse a simple JSON string */
-
-let json = try Js.Json.parseExn(` "hello" `) catch {
-| _ => failwith("Error parsing JSON string")
-}
-
-switch Js.Json.classify(json) {
-| Js.Json.JSONString(value) => Js.log(value)
-| _ => failwith("Expected a string")
-}
-```
-
-```res example
-/* parse a complex JSON string */
-
-let getIds = s => {
-  let json = try Js.Json.parseExn(s) catch {
-  | _ => failwith("Error parsing JSON string")
-  }
-
-  switch Js.Json.classify(json) {
-  | Js.Json.JSONObject(value) =>
-    /* In this branch, compiler infer value : Js.Json.t Js.Dict.t */
-    switch Js.Dict.get(value, "ids") {
-    | Some(ids) =>
-      switch Js.Json.classify(ids) {
-      | Js.Json.JSONArray(ids) => /* In this branch compiler infer ids : Js.Json.t array */
-        ids
-      | _ => failwith("Expected an array")
-      }
-    | None => failwith("Expected an `ids` property")
-    }
-  | _ => failwith("Expected an object")
-  }
-}
-
-/* prints `1, 2, 3` */
-Js.log(getIds(` { "ids" : [1, 2, 3 ] } `))
-```
-
-## stringify
-
-```res sig
-let stringify: t => string
-```
-
-`stringify(json)` formats the JSON data structure as a `string`.
-Returns the string representation of a given JSON data structure.
-
-```res example
-/* Creates and stringifies a simple JS object */
-
-{
-  let dict = Js.Dict.empty()
-  Js.Dict.set(dict, "name", Js.Json.string("John Doe"))
-  Js.Dict.set(dict, "age", Js.Json.number(30.0))
-  Js.Dict.set(dict, "likes", Js.Json.stringArray(["bucklescript", "ocaml", "js"]))
-
-  Js.log(Js.Json.stringify(Js.Json.object_(dict)))
-}
-```
-
-## stringifyWithSpace
-
-```res sig
-let stringifyWithSpace: (t, int) => string
-```
-
-`stringify(json)` formats the JSON data structure as a `string`.
-Returns the string representation of a given JSON data structure with spacing.
-
-```res example
-/* Creates and stringifies a simple JS object with spacing */
-
-{
-  let dict = Js.Dict.empty()
-  Js.Dict.set(dict, "name", Js.Json.string("John Doe"))
-  Js.Dict.set(dict, "age", Js.Json.number(30.0))
-  Js.Dict.set(dict, "likes", Js.Json.stringArray(["bucklescript", "ocaml", "js"]))
-
-  Js.log(Js.Json.stringifyWithSpace(Js.Json.object_(dict), 2))
-}
-```
-
-## stringifyAny
-
-```res sig
-let stringifyAny: 'a => option<string>
-```
-
-`stringifyAny(value)` formats any value into a JSON string.
-
-```res example
-/* prints `["hello", "world"]` */
-Js.log(Js.Json.stringifyAny(["hello", "world"]))
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/list.mdx b/pages/docs/manual/v9.0.0/api/js/list.mdx
deleted file mode 100644
index 72b908489..000000000
--- a/pages/docs/manual/v9.0.0/api/js/list.mdx
+++ /dev/null
@@ -1,143 +0,0 @@
-# List
-
-<Intro>
-
-Provide utilities for list.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a> = list<'a>
-```
-
-## length
-
-```res sig
-let length: t<'a> => int
-```
-
-## cons
-
-```res sig
-let cons: ('a, t<'a>) => t<'a>
-```
-
-## isEmpty
-
-```res sig
-let isEmpty: t<'a> => bool
-```
-
-## hd
-
-```res sig
-let hd: t<'a> => option<'a>
-```
-
-## tl
-
-```res sig
-let tl: t<'a> => option<t<'a>>
-```
-
-## nth
-
-```res sig
-let nth: (t<'a>, int) => option<'a>
-```
-
-## revAppend
-
-```res sig
-let revAppend: (t<'a>, t<'a>) => t<'a>
-```
-
-## rev
-
-```res sig
-let rev: t<'a> => t<'a>
-```
-
-## mapRev
-
-```res sig
-let mapRev: ((. 'a) => 'b, t<'a>) => t<'b>
-```
-
-## map
-
-```res sig
-let map: ((. 'a) => 'b, t<'a>) => t<'b>
-```
-
-## iter
-
-```res sig
-let iter: ((. 'a) => unit, t<'a>) => unit
-```
-
-## iteri
-
-```res sig
-let iteri: ((. int, 'a) => unit, t<'a>) => unit
-```
-
-## foldLeft
-
-```res sig
-let foldLeft: ((. 'a, 'b) => 'a, 'a, list<'b>) => 'a
-```
-
-Application order is left to right, tail-recurisve.
-
-## foldRight
-
-```res sig
-let foldRight: ((. 'a, 'b) => 'b, list<'a>, 'b) => 'b
-```
-
-Application order is right to left, tail-recursive.
-
-## flatten
-
-```res sig
-let flatten: t<t<'a>> => t<'a>
-```
-
-## filter
-
-```res sig
-let filter: ((. 'a) => bool, t<'a>) => t<'a>
-```
-
-## filterMap
-
-```res sig
-let filterMap: ((. 'a) => option<'b>, t<'a>) => t<'b>
-```
-
-## countBy
-
-```res sig
-let countBy: ((. 'a) => bool, list<'a>) => int
-```
-
-## init
-
-```res sig
-let init: (int, (. int) => 'a) => t<'a>
-```
-
-## toVector
-
-```res sig
-let toVector: t<'a> => Js_vector.t<'a>
-```
-
-## equal
-
-```res sig
-let equal: ((. 'a, 'a) => bool, list<'a>, list<'a>) => bool
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/math.mdx b/pages/docs/manual/v9.0.0/api/js/math.mdx
deleted file mode 100644
index 90592d361..000000000
--- a/pages/docs/manual/v9.0.0/api/js/math.mdx
+++ /dev/null
@@ -1,628 +0,0 @@
-# Math
-
-<Intro>
-
-Provide utilities for JS Math. Note: The constants `_E`, `_LN10`, `_LN2`, `_LOG10E`, `_LOG2E`, `_PI`, `_SQRT1_2`, and `_SQRT2` begin with an underscore because ReasonML variable names cannot begin with a capital letter. (Module names begin with upper case.)
-
-</Intro>
-
-## _E
-
-```res sig
-let _E: float
-```
-
-Euler's number; ≈ 2.718281828459045. See [`Math.E`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/E) on MDN.
-
-## _LN2
-
-```res sig
-let _LN2: float
-```
-
-Natural logarithm of 2; ≈ 0.6931471805599453. See [`Math.LN2`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/LN2) on MDN.
-
-## _LN10
-
-```res sig
-let _LN10: float
-```
-
-Natural logarithm of 10; ≈ 2.302585092994046. See [`Math.LN10`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/LN10) on MDN.
-
-## _LOG2E
-
-```res sig
-let _LOG2E: float
-```
-
-Base 2 logarithm of E; ≈ 1.4426950408889634. See [`Math.LOG2E`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/LOG2E) on MDN.
-
-## _LOG10E
-
-```res sig
-let _LOG10E: float
-```
-
-Base 10 logarithm of E; ≈ 0.4342944819032518. See [`Math.LOG10E`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/LOG10E) on MDN.
-
-## _PI
-
-```res sig
-let _PI: float
-```
-
-Pi - ratio of the circumference to the diameter of a circle; ≈ 3.141592653589793. See [`Math.PI`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/PI) on MDN.
-
-## _SQRT1_2
-
-```res sig
-let _SQRT1_2: float
-```
-
-Square root of 1/2; ≈ 0.7071067811865476. See [`Math.SQRT1_2`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2) on MDN.
-
-## _SQRT2
-
-```res sig
-let _SQRT2: float
-```
-
-Square root of 2; ≈ 1.4142135623730951. See [`Math.SQRT2`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/SQRT2) on MDN.
-
-## abs_int
-
-```res sig
-let abs_int: int => int
-```
-
-Absolute value for integer argument. See [`Math.abs`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/abs) on MDN.
-
-## abs_float
-
-```res sig
-let abs_float: float => float
-```
-
-Absolute value for float argument. See [`Math.abs`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/abs) on MDN.
-
-## acos
-
-```res sig
-let acos: float => float
-```
-
-Arccosine (in radians) of argument; returns `NaN` if the argument is outside the range [-1.0, 1.0]. See [`Math.acos`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acos) on MDN.
-
-## acosh
-
-```res sig
-let acosh: float => float
-```
-
-Hyperbolic arccosine (in radians) of argument; returns `NaN` if the argument is less than 1.0. See [`Math.acosh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acosh) on MDN.
-
-## asin
-
-```res sig
-let asin: float => float
-```
-
-Arcsine (in radians) of argument; returns `NaN` if the argument is outside the range [-1.0, 1.0]. See [`Math.asin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asin) on MDN.
-
-## asinh
-
-```res sig
-let asinh: float => float
-```
-
-Hyperbolic arcsine (in radians) of argument. See [`Math.asinh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asinh) on MDN.
-
-## atan
-
-```res sig
-let atan: float => float
-```
-
-Arctangent (in radians) of argument. See [`Math.atan`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan) on MDN.
-
-## atanh
-
-```res sig
-let atanh: float => float
-```
-
-Hyperbolic arctangent (in radians) of argument; returns `NaN` if the argument is is outside the range [-1.0, 1.0]. Returns `-Infinity` and `Infinity` for arguments -1.0 and 1.0. See [`Math.atanh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atanh) on MDN.
-
-## atan2
-
-```res sig
-let atan2: (~y: float, ~x: float, unit) => float
-```
-
-Returns the angle (in radians) of the quotient `y /. x`. It is also the angle between the *x*-axis and point (*x*, *y*). See [`Math.atan2`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2) on MDN.
-
-```res example
-Js.Math.atan2(~y=0.0, ~x=10.0, ()) == 0.0
-Js.Math.atan2(~x=5.0, ~y=5.0, ()) == Js.Math._PI /. 4.0
-Js.Math.atan2(~x=-5.0, ~y=5.0, ())
-Js.Math.atan2(~x=-5.0, ~y=5.0, ()) == 3.0 *. Js.Math._PI /. 4.0
-Js.Math.atan2(~x=-0.0, ~y=-5.0, ()) == -.Js.Math._PI /. 2.0
-```
-
-## cbrt
-
-```res sig
-let cbrt: float => float
-```
-
-Cube root. See [`Math.cbrt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cbrt) on MDN
-
-## unsafe_ceil_int
-
-```res sig
-let unsafe_ceil_int: float => int
-```
-
-Returns the smallest integer greater than or equal to the argument. This function may return values not representable by `int`, whose range is -2147483648 to 2147483647. This is because, in JavaScript, there are only 64-bit floating point numbers, which can represent integers in the range ±(2<sup>53</sup>-1) exactly. See [`Math.ceil`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil) on MDN.
-
-```res example
-Js.Math.unsafe_ceil_int(3.1) == 4
-Js.Math.unsafe_ceil_int(3.0) == 3
-Js.Math.unsafe_ceil_int(-3.1) == -3
-Js.Math.unsafe_ceil_int(1.0e15) // result is outside range of int datatype
-```
-
-## unsafe_ceil
-
-```res sig
-let unsafe_ceil: float => int
-```
-Deprecated; please use [`unsafe_ceil_int`](#unsafe_ceil_int) instead.
-
-## ceil_int
-
-```res sig
-let ceil_int: float => int
-```
-
-Returns the smallest `int` greater than or equal to the argument; the result is pinned to the range of the `int` data type: -2147483648 to 2147483647. See [`Math.ceil`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil) on MDN.
-
-```res example
-Js.Math.ceil_int(3.1) == 4
-Js.Math.ceil_int(3.0) == 3
-Js.Math.ceil_int(-3.1) == -3
-Js.Math.ceil_int(-1.0e15) == -2147483648
-Js.Math.ceil_int(1.0e15) == 2147483647
-```
-
-## ceil
-
-```res sig
-let ceil: float => int
-```
-
-Deprecated; please use [`ceil_int`](#ceil_int) instead.
-
-## ceil_float
-
-```res sig
-let ceil_float: float => float
-```
-
-Returns the smallest integral value greater than or equal to the argument. The result is a `float` and is not restricted to the `int` data type range. See [`Math.ceil`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil) on MDN.
-
-```res example
-Js.Math.ceil_float(3.1) == 4.0
-Js.Math.ceil_float(3.0) == 3.0
-Js.Math.ceil_float(-3.1) == -3.0
-Js.Math.ceil_float(2_150_000_000.3) == 2_150_000_001.0
-```
-
-## clz32
-
-```res sig
-let clz32: int => int
-```
-
-Number of leading zero bits of the argument's 32 bit int representation. See [`Math.clz32`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32) on MDN.
-
-```res example
-Js.Math.clz32(0) == 32
-Js.Math.clz32(-1) == 0
-Js.Math.clz32(255) == 24
-```
-
-## cos
-
-```res sig
-let cos: float => float
-```
-
-Cosine of argument, which must be specified in radians. See [`Math.cos`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cos) on MDN.
-
-## cosh
-
-```res sig
-let cosh: float => float
-```
-
-Hyperbolic cosine of argument, which must be specified in radians. See [`Math.cosh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cosh) on MDN.
-
-## exp
-
-```res sig
-let exp: float => float
-```
-
-Natural exponentional; returns *e* (the base of natural logarithms) to the power of the given argument. See [`Math.exp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/exp) on MDN.
-
-## expm1
-
-```res sig
-let expm1: float => float
-```
-
-Returns *e* (the base of natural logarithms) to the power of the given argument minus 1. See [`Math.expm1`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/expm1) on MDN.
-
-## unsafe_floor_int
-
-```res sig
-let unsafe_floor_int: float => int
-```
-
-Returns the largest integer less than or equal to the argument. This function may return values not representable by `int`, whose range is -2147483648 to 2147483647. This is because, in JavaScript, there are only 64-bit floating point numbers, which can represent integers in the range ±(2<sup>53</sup>-1) exactly. See [`Math.floor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor) on MDN.
-
-```res example
-Js.Math.unsafe_floor_int(3.7) == 3
-Js.Math.unsafe_floor_int(3.0) == 3
-Js.Math.unsafe_floor_int(-3.7) == -4
-Js.Math.unsafe_floor_int(1.0e15) // result is outside range of int datatype
-```
-
-## unsafe_floor
-
-```res sig
-let unsafe_floor: float => int
-```
-
-Deprecated; please use [`unsafe_floor_int`](#unsafe_floor_int) instead.
-
-## floor_int
-
-```res sig
-let floor_int: float => int
-```
-
-Returns the largest `int` less than or equal to the argument; the result is pinned to the range of the `int` data type: -2147483648 to 2147483647. See [`Math.floor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor) on MDN.
-
-```res example
-Js.Math.floor_int(3.7) == 3
-Js.Math.floor_int(3.0) == 3
-Js.Math.floor_int(-3.1) == -4
-Js.Math.floor_int(-1.0e15) == -2147483648
-Js.Math.floor_int(1.0e15) == 2147483647
-```
-
-## floor
-
-```res sig
-let floor: float => int
-```
-
-Deprecated; please use [`floor_int`](#floor_int) instead.
-
-## floor_float
-
-```res sig
-let floor_float: float => float
-```
-
-Returns the largest integral value less than or equal to the argument. The result is a `float` and is not restricted to the `int` data type range. See [`Math.floor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor) on MDN.
-
-```res example
-Js.Math.floor_float(3.7) == 3.0
-Js.Math.floor_float(3.0) == 3.0
-Js.Math.floor_float(-3.1) == -4.0
-Js.Math.floor_float(2_150_000_000.3) == 2_150_000_000.0
-```
-## fround
-
-```res sig
-let fround: float => float
-```
-
-Round to nearest single precision float. See [`Math.fround`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround) on MDN.
-
-```res example
-Js.Math.fround(5.5) == 5.5
-Js.Math.fround(5.05) == 5.050000190734863
-```
-
-## hypot
-
-```res sig
-let hypot: (float, float) => float
-```
-
-Returns the square root of the sum of squares of its two arguments (the Pythagorean formula). See [`Math.hypot`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/hypot) on MDN.
-
-## hypotMany
-
-```res sig
-let hypotMany: array<float> => float
-```
-
-Returns the square root of the sum of squares of the numbers in the array argument (generalized Pythagorean equation). Using an array allows you to have more than two items. See [`Math.hypot`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/hypot) on MDN.
-
-```res example
-Js.Math.hypotMany([3.0, 4.0, 12.0]) == 13.0
-```
-
-## imul
-
-```res sig
-let imul: (int, int) => int
-```
-
-32-bit integer multiplication. Use this only when you need to optimize performance of multiplication of numbers stored as 32-bit integers. See [`Math.imul`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul) on MDN.
-
-## log
-
-```res sig
-let log: float => float
-```
-
-Returns the natural logarithm of its argument; this is the number *x* such that *e*<sup>*x*</sup> equals the argument. Returns `NaN` for negative arguments. See [`Math.log`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log) on MDN.
-
-```res example
-Js.Math.log(Js.Math._E) == 1.0
-Js.Math.log(100.0) == 4.605170185988092
-```
-
-## log1p
-
-```res sig
-let log1p: float => float
-```
-
-Returns the natural logarithm of one plus the argument. Returns `NaN` for arguments less than -1. See [`Math.log1p`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log1p) on MDN.
-
-```res example
-Js.Math.log1p(Js.Math._E -. 1.0) == 1.0
-Js.Math.log1p(99.0) == 4.605170185988092
-```
-
-## log10
-
-```res sig
-let log10: float => float
-```
-
-Returns the base 10 logarithm of its argument. Returns `NaN` for negative arguments. See [`Math.log10`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log10) on MDN.
-
-```res example
-Js.Math.log10(1000.0) == 3.0
-Js.Math.log10(0.01) == -2.0
-Js.Math.log10(Js.Math.sqrt(10.0)) == 0.5
-```
-
-## log2
-
-```res sig
-let log2: float => float
-```
-
-Returns the base 2 logarithm of its argument. Returns `NaN` for negative arguments. See [`Math.log2`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log2) on MDN.
-
-```res example
-Js.Math.log2(512.0) == 9.0
-Js.Math.log2(0.125) == -3.0
-Js.Math.log2(Js.Math._SQRT2) == 0.5000000000000001 // due to precision
-```
-
-
-## max_int
-
-```res sig
-let max_int: (int, int) => int
-```
-
-Returns the maximum of its two integer arguments.  See [`Math.max`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max) on MDN.
-
-## maxMany_int
-
-```res sig
-let maxMany_int: array<int> => int
-```
-
-Returns the maximum of the integers in the given array.  See [`Math.max`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max) on MDN.
-
-## max_float
-
-```res sig
-let max_float: (float, float) => float
-```
-
-Returns the maximum of its two floating point arguments. See [`Math.max`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max) on MDN.
-
-## maxMany_float
-
-```res sig
-let maxMany_float: array<float> => float
-```
-
-Returns the maximum of the floating point values in the given array. See [`Math.max`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max) on MDN.
-
-## min_int
-
-```res sig
-let min_int: (int, int) => int
-```
-
-Returns the minimum of its two integer arguments. See [`Math.min`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min) on MDN.
-
-
-## minMany_int
-
-```res sig
-let minMany_int: array<int> => int
-```
-
-Returns the minimum of the integers in the given array. See [`Math.min`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min) on MDN.
-
-## min_float
-
-```res sig
-let min_float: (float, float) => float
-```
-
-Returns the minimum of its two floating point arguments. See [`Math.min`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min) on MDN.
-
-## minMany_float
-
-```res sig
-let minMany_float: array<float> => float
-```
-
-Returns the minimum of the floating point values in the given array. See [`Math.min`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min) on MDN.
-
-
-## pow_int
-
-```res sig
-let pow_int: (~base: int, ~exp: int) => int
-```
-
-Raises the given base to the given exponent. (Arguments and result are integers.) See [`Math.pow`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/pow) on MDN.
-
-```res example
-Js.Math.pow_int(~base=3, ~exp=4) == 81
-```
-
-
-## pow_float
-
-```res sig
-let pow_float: (~base: float, ~exp: float) => float
-```
-
-Raises the given base to the given exponent. (Arguments and result are floats.) Returns `NaN` if the result would be imaginary. See [`Math.pow`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/pow) on MDN.
-
-```res example
-Js.Math.pow_float(~base=3.0, ~exp=4.0) == 81.0
-Js.Math.pow_float(~base=4.0, ~exp=-2.0) == 0.0625
-Js.Math.pow_float(~base=625.0, ~exp=0.5) == 25.0
-Js.Math.pow_float(~base=625.0, ~exp=-0.5) == 0.04
-Js.Float.isNaN(Js.Math.pow_float(~base=-2.0, ~exp=0.5)) == true
-```
-
-## random
-
-```res sig
-let random: unit => float
-```
-
-Returns a random number in the half-closed interval [0,1). See [`Math.random`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random) on MDN.
-
-## random_int
-
-```res sig
-let random_int: (int, int) => int
-```
-
-A call to `random_int(minVal, maxVal)` returns a random number in the half-closed interval [minVal, maxVal). See [`Math.random`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random) on MDN.
-
-## unsafe_round
-
-```res sig
-let unsafe_round: float => int
-```
-
-Rounds its argument to nearest integer. For numbers with a fractional portion of exactly 0.5, the argument is rounded to the next integer in the direction of positive infinity.  This function may return values not representable by `int`, whose range is -2147483648 to 2147483647. This is because, in JavaScript, there are only 64-bit floating point numbers, which can represent integers in the range ±(2<sup>53</sup>-1) exactly. See [`Math.round`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round) on MDN.
-
-```res example
-Js.Math.unsafe_round(3.7) == 4
-Js.Math.unsafe_round(-3.5) == -3
-Js.Math.unsafe_round(2_150_000_000_000.3) // out of range for int
-```
-
-## round
-
-```res sig
-let round: float => float
-```
-
-Rounds to nearest integral value (expressed as a float). See [`Math.round`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round) on MDN.
-
-
-## sign_int
-
-```res sig
-let sign_int: int => int
-```
-
-Returns the sign of its integer argument: -1 if negative, 0 if zero, 1 if positive. See [`Math.sign`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign) on MDN.
-
-## sign_float
-
-```res sig
-let sign_float: float => float
-```
-Returns the sign of its float argument: -1.0 if negative, 0.0 if zero, 1.0 if positive. See [`Math.sign`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign) on MDN.
-
-## sin
-
-```res sig
-let sin: float => float
-```
-
-Sine of argument, which must be specified in radians. See [`Math.sin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sin) on MDN.
-
-## sinh
-
-```res sig
-let sinh: float => float
-```
-
-Hyperbolic sine of argument, which must be specified in radians. See [`Math.sinh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sinh) on MDN.
-
-## sqrt
-
-```res sig
-let sqrt: float => float
-```
-
-Square root. If the argument is negative, this function returns `NaN`. See [`Math.sqrt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sqrt) on MDN.
-
-## tan
-
-```res sig
-let tan: float => float
-```
-
-Tangent of argument, which must be specified in radians. Returns `NaN` if the argument is positive infinity or negative infinity. See [`Math.cos`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cos) on MDN.
-
-## tanh
-
-```res sig
-let tanh: float => float
-```
-
-Hyperbolic tangent of argument, which must be specified in radians. See [`Math.tanh`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/tanh) on MDN.
-
-## unsafe_trunc
-
-```res sig
-let unsafe_trunc: float => int
-```
-
-Truncates its argument; i.e., removes fractional digits. This function may return values not representable by `int`, whose range is -2147483648 to 2147483647. This is because, in JavaScript, there are only 64-bit floating point numbers, which can represent integers in the range ±(2<sup>53</sup>-1) exactly. See [`Math.trunc`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc) on MDN.
-
-## trunc
-
-```res sig
-let trunc: float => float
-```
-
-Truncates its argument; i.e., removes fractional digits. See [`Math.trunc`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc) on MDN.
diff --git a/pages/docs/manual/v9.0.0/api/js/null-undefined.mdx b/pages/docs/manual/v9.0.0/api/js/null-undefined.mdx
deleted file mode 100644
index ad7c1a3fe..000000000
--- a/pages/docs/manual/v9.0.0/api/js/null-undefined.mdx
+++ /dev/null
@@ -1,114 +0,0 @@
-# Null_undefined
-
-<Intro>
-
-Provide utilities around `Js.null_undefined`.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a> = Js.null_undefined<'a>
-```
-
-Local alias for `Js.null_undefined('a)`.
-
-## return
-
-```res sig
-let return: 'a => t<'a>
-```
-
-Constructs a value of `Js.null_undefined('a)` containing a value of `'a`.
-
-## test
-
-```res sig
-let test: t<'a> => bool
-```
-
-## isNullable
-
-```res sig
-let isNullable: t<'a> => bool
-```
-
-Returns `true` if the given value is null or undefined, `false` otherwise.
-
-## null
-
-```res sig
-let null: t<'a>
-```
-
-The null value of type `Js.null_undefined('a)`.
-
-## undefined
-
-```res sig
-let undefined: t<'a>
-```
-
-The undefined value of type `Js.null_undefined('a)`.
-
-## bind
-
-```res sig
-let bind: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-Maps the contained value using the given function.
-If `Js.null_undefined('a)` contains a value, that value is unwrapped, mapped to a `'b` using the given function `a' => 'b`, then wrapped back up and returned as `Js.null_undefined('b)`.
-
-```res example
-let maybeGreetWorld = (maybeGreeting: Js.null_undefined<string>) =>
-  Js.Null_undefined.bind(maybeGreeting, (. greeting) => greeting ++ " world!")
-```
-
-## iter
-
-```res sig
-let iter: (t<'a>, (. 'a) => unit) => unit
-```
-
-Iterates over the contained value with the given function.
-If `Js.null_undefined('a)` contains a value, that value is unwrapped and applied to the given function.
-
-```res example
-let maybeSay = (maybeMessage: Js.null_undefined<string>) =>
-  Js.Null_undefined.iter(maybeMessage, (. message) => Js.log(message))
-```
-
-## fromOption
-
-```res sig
-let fromOption: option<'a> => t<'a>
-```
-
-Maps `option('a)` to `Js.null_undefined('a)`.
-`Some(a)` => `a`
-`None` => `undefined`
-
-## from_opt
-
-```res sig
-let from_opt: option<'a> => t<'a>
-```
-
-## toOption
-
-```res sig
-let toOption: t<'a> => option<'a>
-```
-
-Maps `Js.null_undefined('a)` to `option('a)`.
-`a` => `Some(a)`
-`undefined` => `None`
-`null` => `None`
-
-## to_opt
-
-```res sig
-let to_opt: t<'a> => option<'a>
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/null.mdx b/pages/docs/manual/v9.0.0/api/js/null.mdx
deleted file mode 100644
index 79cae6737..000000000
--- a/pages/docs/manual/v9.0.0/api/js/null.mdx
+++ /dev/null
@@ -1,107 +0,0 @@
-# Null
-
-<Intro>
-
-Provide utilities around `null('a)`.
-
-</Intro>
-
-```res prelude
-type t<'a> = Js.null<'a>
-```
-
-Local alias for `Js.null('a)`.
-
-```res sig
-let return: 'a => t<'a>
-```
-
-Constructs a value of `Js.null('a)` containing a value of `'a`.
-
-## test
-
-```res sig
-let test: t<'a> => bool
-```
-
-Returns `true` if the given value is empty (`null`), `false` otherwise.
-
-## empty
-
-```res sig
-let empty: t<'a>
-```
-
-The empty value, `null`.
-
-## getUnsafe
-
-```res sig
-let getUnsafe: t<'a> => 'a
-```
-
-## getExn
-
-```res sig
-let getExn: t<'a> => 'a
-```
-
-## bind
-
-```res sig
-let bind: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-Maps the contained value using the given function.
-If `Js.null('a)` contains a value, that value is unwrapped, mapped to a `'b` using the given function `'a => 'b`, then wrapped back up and returned as `Js.null('b)`.
-
-```res example
-let maybeGreetWorld = (maybeGreeting: Js.null<string>) =>
-  Js.Null.bind(maybeGreeting, (. greeting) => greeting ++ " world!")
-```
-
-## iter
-
-```res sig
-let iter: (t<'a>, (. 'a) => unit) => unit
-```
-
-Iterates over the contained value with the given function.
-If `Js.null('a)` contains a value, that value is unwrapped and applied to the given function.
-
-```res example
-let maybeSay = (maybeMessage: Js.null<string>) =>
-  Js.Null.iter(maybeMessage, (. message) => Js.log(message))
-```
-
-## fromOption
-
-```res sig
-let fromOption: option<'a> => t<'a>
-```
-
-Maps `option('a)` to `Js.null('a)`.
-`Some(a)` => `a`
-`None` => `empty`
-
-## from_opt
-
-```res sig
-let from_opt: option<'a> => t<'a>
-```
-
-## toOption
-
-```res sig
-let toOption: t<'a> => option<'a>
-```
-
-Maps `Js.null('a)` to `option('a)`.
-`a` => `Some(a)`
-`empty` => `None`
-
-## to_opt
-
-```res sig
-let to_opt: t<'a> => option<'a>
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/nullable.mdx b/pages/docs/manual/v9.0.0/api/js/nullable.mdx
deleted file mode 100644
index 0c9976668..000000000
--- a/pages/docs/manual/v9.0.0/api/js/nullable.mdx
+++ /dev/null
@@ -1,114 +0,0 @@
-# Nullable
-
-<Intro>
-
-Provide utilities around `Js.null_undefined`.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a> = Js.null_undefined<'a>
-```
-
-Local alias for `Js.null_undefined('a)`.
-
-## return
-
-```res sig
-let return: 'a => t<'a>
-```
-
-Constructs a value of `Js.null_undefined('a)` containing a value of `'a`.
-
-## test
-
-```res sig
-let test: t<'a> => bool
-```
-
-## isNullable
-
-```res sig
-let isNullable: t<'a> => bool
-```
-
-Returns `true` if the given value is null or undefined, `false` otherwise.
-
-## null
-
-```res sig
-let null: t<'a>
-```
-
-The null value of type `Js.null_undefined('a)`.
-
-## undefined
-
-```res sig
-let undefined: t<'a>
-```
-
-The undefined value of type `Js.null_undefined('a)`.
-
-## bind
-
-```res sig
-let bind: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-Maps the contained value using the given function.
-If `Js.null_undefined('a)` contains a value, that value is unwrapped, mapped to a `'b` using the given function `a' => 'b`, then wrapped back up and returned as `Js.null_undefined('b)`.
-
-```res example
-let maybeGreetWorld = (maybeGreeting: Js.null_undefined<string>) =>
-  Js.Nullable.bind(maybeGreeting, (. greeting) => greeting ++ " world!")
-```
-
-## iter
-
-```res sig
-let iter: (t<'a>, (. 'a) => unit) => unit
-```
-
-Iterates over the contained value with the given function.
-If `Js.null_undefined('a)` contains a value, that value is unwrapped and applied to the given function.
-
-```res example
-let maybeSay = (maybeMessage: Js.null_undefined<string>) =>
-  Js.Nullable.iter(maybeMessage, (. message) => Js.log(message))
-```
-
-## fromOption
-
-```res sig
-let fromOption: option<'a> => t<'a>
-```
-
-Maps `option('a)` to `Js.null_undefined('a)`.
-`Some(a)` => `a`
-`None` => `undefined`
-
-## from_opt
-
-```res sig
-let from_opt: option<'a> => t<'a>
-```
-
-## toOption
-
-```res sig
-let toOption: t<'a> => option<'a>
-```
-
-Maps `Js.null_undefined('a)` to `option('a)`.
-`a` => `Some(a)`
-`undefined` => `None`
-`null` => `None`
-
-## to_opt
-
-```res sig
-let to_opt: t<'a> => option<'a>
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/obj.mdx b/pages/docs/manual/v9.0.0/api/js/obj.mdx
deleted file mode 100644
index 8c1ce8a54..000000000
--- a/pages/docs/manual/v9.0.0/api/js/obj.mdx
+++ /dev/null
@@ -1,57 +0,0 @@
-# Obj
-
-<Intro>
-
-Provide utilities for Js.t.
-
-</Intro>
-
-## empty
-
-```res sig
-let empty: unit => {..}
-```
-
-`empty()` returns the empty object `{}`.
-
-## assign
-
-```res sig
-let assign: ({..}, {..}) => {..}
-```
-
-`assign(target, source)` copies properties from source to target.
-Properties in `target` will be overwritten by properties in `source` if they have the same key.
-Returns `target`.
-
-```res example
-/* Copy an object */
-
-let obj = {"a": 1}
-
-let copy = Js.Obj.assign(Js.Obj.empty(), obj)
-
-/* prints "{ a: 1 }" */
-Js.log(copy)
-
-/* Merge objects with same properties */
-
-let target = {"a": 1, "b": 1}
-let source = {"b": 2}
-
-let obj = Js.Obj.assign(target, source)
-
-/* prints "{ a: 1, b: 2 }" */
-Js.log(obj)
-
-/* prints "{ a: 1, b: 2 }", target is modified */
-Js.log(target)
-```
-
-## keys
-
-```res sig
-let keys: Js.t<'a> => array<string>
-```
-
-`keys(obj)` returns an `array` of the keys of `obj`'s own enumerable properties.
diff --git a/pages/docs/manual/v9.0.0/api/js/option.mdx b/pages/docs/manual/v9.0.0/api/js/option.mdx
deleted file mode 100644
index ed23e8a64..000000000
--- a/pages/docs/manual/v9.0.0/api/js/option.mdx
+++ /dev/null
@@ -1,170 +0,0 @@
-# Option
-
-<Intro>
-
-Provide utilities for handling `option`.
-
-</Intro>
-
-## t
-
-```res sig
-type t<'a> = option<'a>
-```
-
-## some
-
-```res sig
-let some: 'a => option<'a>
-```
-Wraps the given value in `Some()`
-
-```res example
-Js.Option.some(1066) == Some(1066)
-```
-
-## isSome
-
-```res sig
-let isSome: option<'a> => bool
-```
-
-Returns `true` if the argument is `Some(value)`; `false` if the argument is `None`.
-
-## isSomeValue
-
-```res sig
-let isSomeValue: ((. 'a, 'a) => bool, 'a, option<'a>) => bool
-```
-
-The first argument to `isSomeValue` is an uncurried function `eq()` that takes two arguments and returns `true` if they are considered to be equal. It is used to compare a plain value `v1`(the second argument) with an `option` value. If the `option` value is `None`, `isSomeValue()` returns `false`; if the third argument is `Some(v2)`, `isSomeValue()` returns the result of calling `eq(v1, v2)`.
-
-```res example
-let clockEqual = (. a, b) => mod(a, 12) == mod(b, 12)
-Js.Option.isSomeValue(clockEqual, 3, Some(15)) == true
-Js.Option.isSomeValue(clockEqual, 3, Some(4)) == false
-Js.Option.isSomeValue(clockEqual, 3, None) == false
-```
-
-## isNone
-
-```res sig
-let isNone: option<'a> => bool
-```
-
-Returns `true` if the argument is `None`; `false` otherwise.
-
-## getExn
-
-```res sig
-let getExn: option<'a> => 'a
-```
-
-If the argument to `getExn()` is of the form `Some(value)`, returns `value`. If given `None`, it throws a `getExn` exception.
-
-## equal
-
-```res sig
-let equal: ((. 'a, 'b) => bool, option<'a>, option<'b>) => bool
-```
-
-The first argument to `equal` is an uncurried function `eq()` that takes two arguments and returns `true` if they are considered to be equal. The second and third arguments are `option` values.
-
-If the second and third arguments are of the form:
-
-* `Some(v1)` and `Some(v2)`: returns `eq(v1, v2)`
-* `Some(v1)` and `None`: returns `false`
-* `None` and `Some(v2)`: returns `false`
-* `None` and `None`: returns `true`
-
-```res example
-let clockEqual = (. a, b) => mod(a, 12) == mod(b, 12)
-Js.Option.equal(clockEqual, Some(3), Some(15)) == true
-Js.Option.equal(clockEqual, Some(3), Some(16)) == false
-Js.Option.equal(clockEqual, Some(3), None) == false
-Js.Option.equal(clockEqual, None, Some(15)) == false
-Js.Option.equal(clockEqual, None, None) == true
-```
-
-## andThen
-
-```res sig
-let andThen: ((. 'a) => option<'b>, option<'a>) => option<'b>
-```
-
-The first argument to `andThen()` is an uncurried function `f()` that takes a plain value and returns an `option` result. The second argument is an `option` value. If the second argument is `None`, the return value is `None`. If the second argument is `Some(v)`, the return value is `f(v)`.
-
-```res example
-let reciprocal = (. x) => x == 0 ? None : Some(1.0 /. Belt.Int.toFloat(x))
-Js.Option.andThen(reciprocal, Some(5)) == Some(0.2)
-Js.Option.andThen(reciprocal, Some(0)) == None
-Js.Option.andThen(reciprocal, None) == None
-```
-
-## map
-
-```res sig
-let map: ((. 'a) => 'b, option<'a>) => option<'b>
-```
-
-The first argument to `map()` is an uncurried function `f()` that takes a plain value and returns a plain result. The second argument is an `option` value. If it is of the form `Some(v)`, `map()` returns `Some(f(v))`; if it is `None`, the return value is `None`, and function `f()` is not called.
-
-```res example
-let square = (. x) => x * x
-Js.Option.map(square, Some(3)) == Some(9)
-Js.Option.map(square, None) == None
-```
-
-## getWithDefault
-
-```res sig
-let getWithDefault: ('a, option<'a>) => 'a
-```
-
-The first argument to `getWithDefault()` is a default value. If the second argument is of the form `Some(v)`, `getWithDefault()` returns `v`; if the second argument is `None`, the return value is the default value.
-
-```res example
-Js.Option.getWithDefault(1066, Some(15)) == 15
-Js.Option.getWithDefault(1066, None) == 1066
-```
-
-## default
-
-```res sig
-let default: ('a, option<'a>) => 'a
-```
-
-**See:** [getWithDefault](#getWithDefault)
-
-## filter
-
-```res sig
-let filter: ((. 'a) => bool, option<'a>) => option<'a>
-```
-
-The first argument to `filter()` is an uncurried function that takes a plain value and returns a boolean. The second argument is an `option` value.
-
-If the second argument is of the form `Some(v)` and `f(v)` is `true`,
-the return value is `Some(v)`. Otherwise, the return value is `None`.
-
-```res example
-let isEven = (. x) => mod(x, 2) == 0
-Js.Option.filter(isEven, Some(2)) == Some(2)
-Js.Option.filter(isEven, Some(3)) == None
-Js.Option.filter(isEven, None) == None
-```
-
-## firstSome
-
-```res sig
-let firstSome: (option<'a>, option<'a>) => option<'a>
-```
-
-The `firstSome()` function takes two `option` values; if the first is of the form `Some(v1)`, that is the return value. Otherwise, `firstSome()` returns the second value.
-
-```res example
-Js.Option.firstSome(Some("one"), Some("two")) == Some("one")
-Js.Option.firstSome(Some("one"), None) == Some("one")
-Js.Option.firstSome(None, Some("two")) == Some("two")
-Js.Option.firstSome(None, None) == None
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/promise.mdx b/pages/docs/manual/v9.0.0/api/js/promise.mdx
deleted file mode 100644
index 52d06c41d..000000000
--- a/pages/docs/manual/v9.0.0/api/js/promise.mdx
+++ /dev/null
@@ -1,91 +0,0 @@
-# Promise
-
-<Intro>
-
-Provide bindings to JS promise.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<+'a>
-```
-
-## error
-
-```res prelude
-type error
-```
-
-## make
-
-```res sig
-let make: ((~resolve: (. 'a) => unit, ~reject: (. exn) => unit) => unit) => t<'a>
-```
-
-## resolve
-
-```res sig
-let resolve: 'a => t<'a>
-```
-
-## reject
-
-```res sig
-let reject: exn => t<'a>
-```
-
-## all
-
-```res sig
-let all: array<t<'a>> => t<array<'a>>
-```
-
-## all2
-
-```res sig
-let all2: ((t<'a0>, t<'a1>)) => t<('a0, 'a1)>
-```
-
-## all3
-
-```res sig
-let all3: ((t<'a0>, t<'a1>, t<'a2>)) => t<('a0, 'a1, 'a2)>
-```
-
-## all4
-
-```res sig
-let all4: ((t<'a0>, t<'a1>, t<'a2>, t<'a3>)) => t<('a0, 'a1, 'a2, 'a3)>
-```
-
-## all5
-
-```res sig
-let all5: ((t<'a0>, t<'a1>, t<'a2>, t<'a3>, t<'a4>)) => t<('a0, 'a1, 'a2, 'a3, 'a4)>
-```
-
-## all6
-
-```res sig
-let all6: ((t<'a0>, t<'a1>, t<'a2>, t<'a3>, t<'a4>, t<'a5>)) => t<('a0, 'a1, 'a2, 'a3, 'a4, 'a5)>
-```
-
-## race
-
-```res sig
-let race: array<t<'a>> => t<'a>
-```
-
-## then_
-
-```res sig
-let then_: ('a => t<'b>, t<'a>) => t<'b>
-```
-
-## catch
-
-```res sig
-let catch: (error => t<'a>, t<'a>) => t<'a>
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/re.mdx b/pages/docs/manual/v9.0.0/api/js/re.mdx
deleted file mode 100644
index 665eb7a2d..000000000
--- a/pages/docs/manual/v9.0.0/api/js/re.mdx
+++ /dev/null
@@ -1,238 +0,0 @@
-# Re
-
-<Intro>
-
-Provide bindings to JS regular expressions (RegExp).
-
-</Intro>
-
-## t
-
-```res prelude
-type t
-```
-
-The RegExp object.
-
-## result
-
-```res prelude
-type result
-```
-
-The result of a executing a RegExp on a string.
-
-## captures
-
-```res sig
-let captures: result => array<Js.nullable<string>>
-```
-
-An `array` of the match and captures, the first is the full match and the remaining are the substring captures.
-
-## matches
-
-```res sig
-let matches: result => array<string>
-```
-
-Deprecated. Use captures instead.
-An `array` of the matches, the first is the full match and the remaining are the substring matches.
-
-## index
-
-```res sig
-let index: result => int
-```
-
-0-based index of the match in the input string.
-
-## input
-
-```res sig
-let input: result => string
-```
-
-The original input string.
-
-## fromString
-
-```res sig
-let fromString: string => t
-```
-
-Constructs a RegExp object (Js.Re.t) from a `string`.
-Regex literals `%re("/.../")` should generally be preferred, but `fromString` is useful when you need to dynamically construct a regex using strings, exactly like when you do so in JavaScript.
-
-```res example
-let firstReScriptFileExtension = (filename, content) => {
-  let result = Js.Re.fromString(filename ++ "\.(res|resi)")->Js.Re.exec_(content)
-  switch result {
-  | Some(r) => Js.Nullable.toOption(Js.Re.captures(r)[1])
-  | None => None
-  }
-}
-
-// outputs "res"
-firstReScriptFileExtension("School", "School.res School.resi Main.js School.bs.js")
-```
-
-## fromStringWithFlags
-
-```res sig
-let fromStringWithFlags: (string, ~flags: string) => t
-```
-
-Constructs a RegExp object (`Js.Re.t`) from a string with the given flags.
-See `Js.Re.fromString`.
-
-Valid flags:
-
-g global
-i ignore case
-m multiline
-u unicode (es2015)
-y sticky (es2015)
-
-## flags
-
-```res sig
-let flags: t => string
-```
-
-Returns the enabled flags as a string.
-
-## global
-
-```res sig
-let global: t => bool
-```
-
-Returns a `bool` indicating whether the global flag is set.
-
-## ignoreCase
-
-```res sig
-let ignoreCase: t => bool
-```
-
-Returns a `bool` indicating whether the ignoreCase flag is set.
-
-## lastIndex
-
-```res sig
-let lastIndex: t => int
-```
-
-Returns the index where the next match will start its search.
-This property will be modified when the RegExp object is used, if the global ("g") flag is set.
-
-```res example
-let re = %re("/ab*/g")
-let str = "abbcdefabh"
-
-let break = ref(false)
-while !break.contents {
-  switch Js.Re.exec_(re, str) {
-  | Some(result) => Js.Nullable.iter(Js.Re.captures(result)[0], (. match_) => {
-      let next = Belt.Int.toString(Js.Re.lastIndex(re))
-      Js.log("Found " ++ (match_ ++ (". Next match starts at " ++ next)))
-    })
-  | None => break := true
-  }
-}
-```
-
-## setLastIndex
-
-```res sig
-let setLastIndex: (t, int) => unit
-```
-
-Sets the index at which the next match will start its search from.
-
-## multiline
-
-```res sig
-let multiline: t => bool
-```
-
-Returns a `bool` indicating whether the multiline flag is set.
-
-## source
-
-```res sig
-let source: t => string
-```
-
-Returns the pattern as a `string`.
-
-## sticky
-
-```res sig
-let sticky: t => bool
-```
-
-Returns a `bool` indicating whether the sticky flag is set.
-
-## unicode
-
-```res sig
-let unicode: t => bool
-```
-
-Returns a `bool` indicating whether the unicode flag is set.
-
-## exec\_
-
-```res sig
-let exec_: (t, string) => option<result>
-```
-
-Executes a search on a given string using the given RegExp object.
-Returns `Some(Js.Re.result)` if a match is found, `None` otherwise.
-
-```res example
-/* Match "quick brown" followed by "jumps", ignoring characters in between
- * Remember "brown" and "jumps"
- * Ignore case
- */
-
-let re = %re("/quick\s(brown).+?(jumps)/ig")
-let result = Js.Re.exec_(re, "The Quick Brown Fox Jumps Over The Lazy Dog")
-```
-
-## exec
-
-```res sig
-let exec: (string, t) => option<result>
-```
-
-Deprecated. please use `Js.Re.exec_` instead.
-
-## test\_
-
-```res sig
-let test_: (t, string) => bool
-```
-
-Tests whether the given RegExp object will match a given `string`.
-Returns true if a match is found, false otherwise.
-
-```res example
-/* A simple implementation of Js.String.startsWith */
-
-let str = "hello world!"
-
-let startsWith = (target, substring) => Js.Re.fromString("^" ++ substring)->Js.Re.test_(target)
-
-Js.log(str->startsWith("hello")) /* prints "true" */
-```
-
-## test
-
-```res sig
-let test: (string, t) => bool
-```
-
-Deprecated. please use `Js.Re.test_` instead.
diff --git a/pages/docs/manual/v9.0.0/api/js/result.mdx b/pages/docs/manual/v9.0.0/api/js/result.mdx
deleted file mode 100644
index b9a747f95..000000000
--- a/pages/docs/manual/v9.0.0/api/js/result.mdx
+++ /dev/null
@@ -1,15 +0,0 @@
-# Result
-
-<Intro>
-
-Define the interface for result.
-
-</Intro>
-
-## t
-
-```res sig
-type t<'good, 'bad> =
-  | Ok('good)
-  | Error('bad)
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/string-2.mdx b/pages/docs/manual/v9.0.0/api/js/string-2.mdx
deleted file mode 100644
index 7d88129c4..000000000
--- a/pages/docs/manual/v9.0.0/api/js/string-2.mdx
+++ /dev/null
@@ -1,793 +0,0 @@
-# String2
-
-<Intro>
-
-Provide bindings to JS string. Optimized for pipe-first.
-
-</Intro>
-
-## t
-
-```res prelude
-type t = string
-```
-
-## make
-
-```res sig
-let make: 'a => t
-```
-
-`make(value)` converts the given value to a `string`.
-
-```res example
-Js.String2.make(3.5) == "3.5"
-Js.String2.make([1, 2, 3]) == "1,2,3"
-```
-
-## fromCharCode
-
-```res sig
-let fromCharCode: int => t
-```
-
-`fromCharCode(n)` creates a `string` containing the character corresponding to that number; `n` ranges from 0 to 65535.
-If out of range, the lower 16 bits of the value are used. Thus, `fromCharCode(0x1F63A)` gives the same result as `fromCharCode(0xF63A)`. See [`String.fromCharCode`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode) on MDN.
-
-```res example
-Js.String2.fromCharCode(65) == "A"
-Js.String2.fromCharCode(0x3c8) == `ψ`
-Js.String2.fromCharCode(0xd55c) == `한`
-Js.String2.fromCharCode(-64568) == `ψ`
-```
-
-## fromCharCodeMany
-
-```res sig
-let fromCharCodeMany: array<int> => t
-```
-
-`fromCharCodeMany([n1, n2, n3])` creates a `string` from the characters corresponding to the given numbers, using the same rules as `fromCharCode`. See [`String.fromCharCode`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode) on MDN.
-
-## fromCodePoint
-
-```res sig
-let fromCodePoint: int => t
-```
-
-`fromCodePoint(n)` creates a `string` containing the character corresponding to that numeric code point.
-If the number is not a valid code point, it raises `RangeError`.
-Thus, `fromCodePoint(0x1F63A)` will produce a correct value, unlike `fromCharCode(0x1F63A)`, and `fromCodePoint(-5)` will raise a `RangeError`. See [`String.fromCodePoint`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint) on MDN.
-
-```res example
-Js.String2.fromCodePoint(65) == "A"
-Js.String2.fromCodePoint(0x3c8) == `ψ`
-Js.String2.fromCodePoint(0xd55c) == `한`
-Js.String2.fromCodePoint(0x1f63a) == `😺`
-```
-
-## fromCodePointMany
-
-```res sig
-let fromCodePointMany: array<int> => t
-```
-
-`fromCodePointMany([n1, n2, n3])` creates a `string` from the characters corresponding to the given code point numbers, using the same rules as `fromCodePoint`. See [`String.fromCodePoint`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint) on MDN.
-
-```res example
-Js.String2.fromCodePointMany([0xd55c, 0xae00, 0x1f63a]) == `한글😺`
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-`length(s)` returns the length of the given `string`. See [`String.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length) on MDN.
-
-```res example
-Js.String2.length("abcd") == 4
-```
-
-## get
-
-```res sig
-let get: (t, int) => t
-```
-
-`get(s, n)` returns as a `string` the character at the given index number.
-If `n` is out of range, this function returns `undefined`,so at some point this function may be modified to return `option(string)`.
-
-```res example
-Js.String2.get("Reason", 0) == "R"
-Js.String2.get("Reason", 4) == "o"
-Js.String2.get(`Rẽasöń`, 5) == `ń`
-```
-
-## charAt
-
-```res sig
-let charAt: (t, int) => t
-```
-
-`charAt(s, n)` gets the character at index `n` within string `s`.
-If `n` is negative or greater than the length of `s`, it returns the empty string.
-If the string contains characters outside the range \u0000-\uffff, it will return the first 16-bit value at that position in the string. See [`String.charAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charAt) on MDN.
-
-```res example
-Js.String2.charAt("Reason", 0) == "R"
-Js.String2.charAt("Reason", 12) == ""
-Js.String2.charAt(`Rẽasöń`, 5) == `ń`
-```
-
-## charCodeAt
-
-```res sig
-let charCodeAt: (t, int) => float
-```
-
-`charCodeAt(s, n)` returns the character code at position `n` in string `s`; the result is in the range 0-65535, unlke `codePointAt`, so it will not work correctly for characters with code points greater than or equal to 0x10000.
-The return type is `float` because this function returns NaN if `n` is less than zero or greater than the length of the string. See [`String.charCodeAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charCodeAt) on MDN.
-
-```res example
-Js.String2.charCodeAt(`😺`, 0) == 0xd83d->Belt.Int.toFloat
-Js.String2.codePointAt(`😺`, 0) == Some(0x1f63a)
-```
-
-## codePointAt
-
-```res sig
-let codePointAt: (t, int) => option<int>
-```
-
-`codePointAt(s, n)` returns the code point at position `n` within string `s` as a `Some(value)`.
-The return value handles code points greater than or equal to 0x10000.
-If there is no code point at the given position, the function returns `None`. See [`String.codePointAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/codePointAt) on MDN.
-
-```res example
-Js.String2.codePointAt(`¿😺?`, 1) == Some(0x1f63a)
-Js.String2.codePointAt("abc", 5) == None
-```
-
-## concat
-
-```res sig
-let concat: (t, t) => t
-```
-
-`concat(original, append)` returns a new `string` with `append` added after `original`. See [`String.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat) on MDN.
-
-```res example
-Js.String2.concat("cow", "bell") == "cowbell"
-```
-
-## concatMany
-
-```res sig
-let concatMany: (t, array<t>) => t
-```
-
-`concat(original, arr)` returns a new `string` consisting of each item of an array of strings added to the `original` string. See [`String.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat) on MDN.
-
-```res example
-Js.String2.concatMany("1st", ["2nd", "3rd", "4th"]) == "1st2nd3rd4th"
-```
-
-## endsWith
-
-```res sig
-let endsWith: (t, t) => bool
-```
-
-ES2015: `endsWith(str, substr)` returns `true` if the `str` ends with `substr`, `false` otherwise. See [`String.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith) on MDN.
-
-```res example
-Js.String2.endsWith("BuckleScript", "Script") == true
-Js.String2.endsWith("BuckleShoes", "Script") == false
-```
-
-## endsWithFrom
-
-```res sig
-let endsWithFrom: (t, t, int) => bool
-```
-
-`endsWithFrom(str, ending, len)` returns `true` if the first len characters of `str` end with `ending`, `false` otherwise.
-If `len` is greater than or equal to the length of `str`, then it works like `endsWith`. (Honestly, this should have been named endsWithAt, but oh well.) See [`String.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith) on MDN.
-
-```res example
-Js.String2.endsWithFrom("abcd", "cd", 4) == true
-Js.String2.endsWithFrom("abcde", "cd", 3) == false
-Js.String2.endsWithFrom("abcde", "cde", 99) == true
-Js.String2.endsWithFrom("example.dat", "ple", 7) == true
-```
-
-## includes
-
-```res sig
-let includes: (t, t) => bool
-```
-
-ES2015: `includes(str, searchValue)` returns `true` if `searchValue` is found anywhere within `str`, false otherwise. See [`String.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes) on MDN.
-
-```res example
-Js.String2.includes("programmer", "gram") == true
-Js.String2.includes("programmer", "er") == true
-Js.String2.includes("programmer", "pro") == true
-Js.String2.includes("programmer.dat", "xyz") == false
-```
-
-## includesFrom
-
-```res sig
-let includesFrom: (t, t, int) => bool
-```
-
-ES2015: `includes(str, searchValue start)` returns `true` if `searchValue` is found anywhere within `str` starting at character number `start` (where 0 is the first character), `false` otherwise. See [`String.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes) on MDN.
-
-```res example
-Js.String2.includesFrom("programmer", "gram", 1) == true
-Js.String2.includesFrom("programmer", "gram", 4) == false
-Js.String2.includesFrom(`대한민국`, `한`, 1) == true
-```
-
-## indexOf
-
-```res sig
-let indexOf: (t, t) => int
-```
-
-ES2015: `indexOf(str, searchValue)` returns the position at which `searchValue` was first found within `str`, or -1 if `searchValue` is not in `str`. See [`String.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf) on MDN.
-
-```res example
-Js.String2.indexOf("bookseller", "ok") == 2
-Js.String2.indexOf("bookseller", "sell") == 4
-Js.String2.indexOf("beekeeper", "ee") == 1
-Js.String2.indexOf("bookseller", "xyz") == -1
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (t, t, int) => int
-```
-`indexOfFrom(str, searchValue, start)` returns the position at which `searchValue` was found within `str` starting at character position `start`, or -1 if `searchValue` is not found in that portion of `str`.
-The return value is relative to the beginning of the string, no matter where the search started from. See [`String.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf) on MDN.
-
-```res example
-Js.String2.indexOfFrom("bookseller", "ok", 1) == 2
-Js.String2.indexOfFrom("bookseller", "sell", 2) == 4
-Js.String2.indexOfFrom("bookseller", "sell", 5) == -1
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (t, t) => int
-```
-
-`lastIndexOf(str, searchValue)` returns the position of the last occurrence of `searchValue` within `str`, searching backwards from the end of the string.
-Returns -1 if `searchValue` is not in `str`. The return value is always relative to the beginning of the string. See [`String.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf) on MDN.
-
-```res example
-Js.String2.lastIndexOf("bookseller", "ok") == 2
-Js.String2.lastIndexOf("beekeeper", "ee") == 4
-Js.String2.lastIndexOf("abcdefg", "xyz") == -1
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (t, t, int) => int
-```
-
-`lastIndexOfFrom(str, searchValue, start)` returns the position of the last occurrence of `searchValue` within `str`, searching backwards from the given start position.
-Returns -1 if `searchValue` is not in `str`. The return value is always relative to the beginning of the string. See [`String.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf) on MDN.
-
-```res example
-Js.String2.lastIndexOfFrom("bookseller", "ok", 6) == 2
-Js.String2.lastIndexOfFrom("beekeeper", "ee", 8) == 4
-Js.String2.lastIndexOfFrom("beekeeper", "ee", 3) == 1
-Js.String2.lastIndexOfFrom("abcdefg", "xyz", 4) == -1
-```
-
-## localeCompare
-
-```res sig
-let localeCompare: (t, t) => float
-```
-
-`localeCompare(reference, comparison)` returns
-- a negative value if reference comes before comparison in sort order
-- zero if reference and comparison have the same sort order
-- a positive value if reference comes after comparison in sort order
-
-See [`String.localeCompare`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare) on MDN.
-
-```res example
-Js.String2.localeCompare("zebra", "ant") > 0.0
-Js.String2.localeCompare("ant", "zebra") < 0.0
-Js.String2.localeCompare("cat", "cat") == 0.0
-Js.String2.localeCompare("CAT", "cat") > 0.0
-```
-
-## match
-
-```res sig
-let match_: (t, Js_re.t) => option<array<t>>
-```
-
-`match(str, regexp)` matches a `string` against the given `regexp`. If there is no match, it returns `None`. For regular expressions without the g modifier, if there is a match, the return value is `Some(array)` where the array contains:
-- The entire matched string
-- Any capture groups if the regexp had parentheses
-For regular expressions with the g modifier, a matched expression returns `Some(array)` with all the matched substrings and no capture groups. See [`String.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match) on MDN.
-
-```res example
-Js.String2.match_("The better bats", %re("/b[aeiou]t/")) == Some(["bet"])
-Js.String2.match_("The better bats", %re("/b[aeiou]t/g")) == Some(["bet", "bat"])
-Js.String2.match_("Today is 2018-04-05.", %re("/(\d+)-(\d+)-(\d+)/")) ==
-  Some(["2018-04-05", "2018", "04", "05"])
-Js.String2.match_("The large container.", %re("/b[aeiou]g/")) == None
-```
-
-## normalize
-
-```res sig
-let normalize: t => t
-```
-
-`normalize(str)` returns the normalized Unicode string using Normalization Form Canonical (NFC) Composition.
-Consider the character ã, which can be represented as the single codepoint \u00e3 or the combination of a lower case letter A \u0061 and a combining tilde \u0303.
-Normalization ensures that both can be stored in an equivalent binary representation. See [`String.normalize`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize) on MDN. See also [Unicode technical report #15](https://unicode.org/reports/tr15/) for details.
-
-## normalizeByForm
-
-```res sig
-let normalizeByForm: (t, t) => t
-```
-
-ES2015: `normalize(str, form)` returns the normalized Unicode string using the specified form of normalization, which may be one of:
-- "NFC" — Normalization Form Canonical Composition.
-- "NFD" — Normalization Form Canonical Decomposition.
-- "NFKC" — Normalization Form Compatibility Composition.
-- "NFKD" — Normalization Form Compatibility Decomposition.
-
-See [`String.normalize`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize) on MDN. See also [Unicode technical report #15](https://unicode.org/reports/tr15/) for details..
-
-## repeat
-
-```res sig
-let repeat: (t, int) => t
-```
-
-`repeat(str, n)` returns a `string` that consists of `n` repetitions of `str`. Raises `RangeError` if `n` is negative. See [`String.repeat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat) on MDN.
-
-```res example
-Js.String2.repeat("ha", 3) == "hahaha"
-Js.String2.repeat("empty", 0) == ""
-```
-
-## replace
-
-```res sig
-let replace: (t, t, t) => t
-```
-
-ES2015: `replace(str, substr, newSubstr)` returns a new `string` which is identical to `str` except with the first matching instance of `substr` replaced by `newSubstr`.
-`substr` is treated as a verbatim string to match, not a regular expression. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-Js.String2.replace("old string", "old", "new") == "new string"
-Js.String2.replace("the cat and the dog", "the", "this") == "this cat and the dog"
-```
-
-## replaceByRe
-
-```res sig
-let replaceByRe: (t, Js_re.t, t) => t
-```
-
-`replaceByRe(str, regex, replacement)` returns a new `string` where occurrences matching regex have been replaced by `replacement`. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-Js.String2.replaceByRe("vowels be gone", %re("/[aeiou]/g"), "x") == "vxwxls bx gxnx"
-Js.String2.replaceByRe("Juan Fulano", %re("/(\w+) (\w+)/"), "$2, $1") == "Fulano, Juan"
-```
-
-## unsafeReplaceBy0
-
-```res sig
-let unsafeReplaceBy0: (t, Js_re.t, (t, int, t) => t) => t
-```
-
-Returns a new `string` with some or all matches of a pattern with no capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-let str = "beautiful vowels"
-let re = %re("/[aeiou]/g")
-let matchFn = (matchPart, _offset, _wholeString) => Js.String2.toUpperCase(matchPart)
-
-Js.String2.unsafeReplaceBy0(str, re, matchFn) == "bEAUtIfUl vOwEls"
-```
-
-## unsafeReplaceBy1
-
-```res sig
-let unsafeReplaceBy1: (t, Js_re.t, (t, t, int, t) => t) => t
-```
-
-Returns a new `string` with some or all matches of a pattern with one set of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured string, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-let str = "Jony is 40"
-let re = %re("/(Jony is )\d+/g")
-let matchFn = (_match, part1, _offset, _wholeString) => {
-  part1 ++ "41"
-}
-
-Js.String2.unsafeReplaceBy1(str, re, matchFn) == "Jony is 41"
-```
-
-## unsafeReplaceBy2
-
-```res sig
-let unsafeReplaceBy2: (t, Js_re.t, (t, t, t, int, t) => t) => t
-```
-
-Returns a new `string` with some or all matches of a pattern with two sets of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured strings, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-let str = "7 times 6"
-let re = %re("/(\d+) times (\d+)/")
-let matchFn = (_match, p1, p2, _offset, _wholeString) => {
-  switch (Belt.Int.fromString(p1), Belt.Int.fromString(p2)) {
-  | (Some(x), Some(y)) => Belt.Int.toString(x * y)
-  | _ => "???"
-  }
-}
-
-Js.String2.unsafeReplaceBy2(str, re, matchFn) == "42"
-```
-
-## unsafeReplaceBy3
-
-```res sig
-let unsafeReplaceBy3: (t, Js_re.t, (t, t, t, t, int, t) => t) => t
-```
-
-Returns a new `string` with some or all matches of a pattern with three sets of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured strings, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-## search
-
-```res sig
-let search: (t, Js_re.t) => int
-```
-
-`search(str, regexp)` returns the starting position of the first match of `regexp` in the given `str`, or -1 if there is no match. See [`String.search`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/search) on MDN.
-
-```res example
-Js.String2.search("testing 1 2 3", %re("/\d+/")) == 8
-Js.String2.search("no numbers", %re("/\d+/")) == -1
-```
-
-## slice
-
-```res sig
-let slice: (t, ~from: int, ~to_: int) => t
-```
-
-`slice(str, from:n1, to_:n2)` returns the substring of `str` starting at character `n1` up to but not including `n2`.
-- If either `n1` or `n2` is negative, then it is evaluated as `length(str - n1)` or `length(str - n2)`.
-- If `n2` is greater than the length of `str`, then it is treated as `length(str)`.
-- If `n1` is greater than `n2`, slice returns the empty string.
-
-See [`String.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice) on MDN.
-
-```res example
-Js.String2.slice("abcdefg", ~from=2, ~to_=5) == "cde"
-Js.String2.slice("abcdefg", ~from=2, ~to_=9) == "cdefg"
-Js.String2.slice("abcdefg", ~from=-4, ~to_=-2) == "de"
-Js.String2.slice("abcdefg", ~from=5, ~to_=1) == ""
-```
-
-## sliceToEnd
-
-```res sig
-let sliceToEnd: (t, ~from: int) => t
-```
-
-`sliceToEnd(str, from:n)` returns the substring of `str` starting at character `n` to the end of the string.
-- If `n` is negative, then it is evaluated as `length(str - n)`.
-- If `n` is greater than the length of `str`, then sliceToEnd returns the empty string.
-
-See [`String.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice) on MDN.
-
-```res example
-Js.String2.sliceToEnd("abcdefg", ~from=4) == "efg"
-Js.String2.sliceToEnd("abcdefg", ~from=-2) == "fg"
-Js.String2.sliceToEnd("abcdefg", ~from=7) == ""
-```
-
-## split
-
-```res sig
-let split: (t, t) => array<t>
-```
-
-`split(str, delimiter)` splits the given `str` at every occurrence of `delimiter` and returns an array of the resulting substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```res example
-Js.String2.split("2018-01-02", "-") == ["2018", "01", "02"]
-Js.String2.split("a,b,,c", ",") == ["a", "b", "", "c"]
-Js.String2.split("good::bad as great::awful", "::") == ["good", "bad as great", "awful"]
-Js.String2.split("has-no-delimiter", ";") == ["has-no-delimiter"]
-```
-
-## splitAtMost
-
-```res sig
-let splitAtMost: (t, t, ~limit: int) => array<t>
-```
-
-`splitAtMost(str, delimiter, ~limit:n)` splits the given `str` at every occurrence of `delimiter` and returns an array of the first `n` resulting substrings.
-If `n` is negative or greater than the number of substrings, the array will contain all the substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```res example
-Js.String2.splitAtMost("ant/bee/cat/dog/elk", "/", ~limit=3) == ["ant", "bee", "cat"]
-Js.String2.splitAtMost("ant/bee/cat/dog/elk", "/", ~limit=0) == []
-Js.String2.splitAtMost("ant/bee/cat/dog/elk", "/", ~limit=9) == [
-    "ant",
-    "bee",
-    "cat",
-    "dog",
-    "elk",
-  ]
-```
-
-## splitByRe
-
-```res sig
-let splitByRe: (t, Js_re.t) => array<option<t>>
-```
-
-`splitByRe(str, regex)` splits the given `str` at every occurrence of `regex` and returns an array of the resulting substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```res example
-Js.String2.splitByRe("art; bed , cog ;dad", %re("/\s*[,;]\s*/")) == [
-    Some("art"),
-    Some("bed"),
-    Some("cog"),
-    Some("dad"),
-  ]
-```
-
-## splitByReAtMost
-
-```res sig
-let splitByReAtMost: (t, Js_re.t, ~limit: int) => array<option<t>>
-```
-
-`splitByReAtMost(str, regex, ~limit:n)` splits the given `str` at every occurrence of `regex` and returns an array of the first `n` resulting substrings.
-If `n` is negative or greater than the number of substrings, the array will contain all the substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```res example
-Js.String2.splitByReAtMost("one: two: three: four", %re("/\s*:\s*/"), ~limit=3) == [
-    Some("one"),
-    Some("two"),
-    Some("three"),
-  ]
-
-Js.String2.splitByReAtMost("one: two: three: four", %re("/\s*:\s*/"), ~limit=0) == []
-
-Js.String2.splitByReAtMost("one: two: three: four", %re("/\s*:\s*/"), ~limit=8) == [
-    Some("one"),
-    Some("two"),
-    Some("three"),
-    Some("four"),
-  ]
-```
-
-## startsWith
-
-```res sig
-let startsWith: (t, t) => bool
-```
-
-ES2015: `startsWith(str, substr)` returns `true` if the `str` starts with `substr`, `false` otherwise. See [`String.startsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith) on MDN.
-
-```res example
-Js.String2.startsWith("BuckleScript", "Buckle") == true
-Js.String2.startsWith("BuckleScript", "") == true
-Js.String2.startsWith("JavaScript", "Buckle") == false
-```
-
-## startsWithFrom
-
-```res sig
-let startsWithFrom: (t, t, int) => bool
-```
-
-ES2015: `startsWithFrom(str, substr, n)` returns `true` if the `str` starts with `substr` starting at position `n`, false otherwise.
-If `n` is negative, the search starts at the beginning of `str`. See [`String.startsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith) on MDN.
-
-```res example
-Js.String2.startsWithFrom("BuckleScript", "kle", 3) == true
-Js.String2.startsWithFrom("BuckleScript", "", 3) == true
-Js.String2.startsWithFrom("JavaScript", "Buckle", 2) == false
-```
-
-## substr
-
-```res sig
-let substr: (t, ~from: int) => t
-```
-
-`substr(str, ~from:n)` returns the substring of `str` from position `n` to the end of the string.
-- If `n` is less than zero, the starting position is the length of `str - n`.
-- If `n` is greater than or equal to the length of `str`, returns the empty string.
-
-JavaScript’s `String.substr()` is a legacy function. When possible, use `substring()` instead. See [`String.substr`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr) on MDN.
-
-```res example
-Js.String2.substr("abcdefghij", ~from=3) == "defghij"
-Js.String2.substr("abcdefghij", ~from=-3) == "hij"
-Js.String2.substr("abcdefghij", ~from=12) == ""
-```
-
-## substrAtMost
-
-```res sig
-let substrAtMost: (t, ~from: int, ~length: int) => t
-```
-
-`substrAtMost(str, ~from: pos, ~length: n)` returns the substring of `str` of length `n` starting at position `pos`.
-- If `pos` is less than zero, the starting position is the length of `str - pos`.
-- If `pos` is greater than or equal to the length of `str`, returns the empty string.
-- If `n` is less than or equal to zero, returns the empty string.
-
-JavaScript’s `String.substr()` is a legacy function. When possible, use `substring()` instead. See [`String.substr`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr) on MDN.
-
-```res example
-Js.String2.substrAtMost("abcdefghij", ~from=3, ~length=4) == "defg"
-Js.String2.substrAtMost("abcdefghij", ~from=-3, ~length=4) == "hij"
-Js.String2.substrAtMost("abcdefghij", ~from=12, ~length=2) == ""
-```
-
-## substring
-
-```res sig
-let substring: (t, ~from: int, ~to_: int) => t
-```
-
-`substring(str, ~from: start, ~to_: finish)` returns characters `start` up to but not including finish from `str`.
-- If `start` is less than zero, it is treated as zero.
-- If `finish` is zero or negative, the empty string is returned.
-- If `start` is greater than `finish`, the `start` and `finish` points are swapped.
-
-See [`String.substring`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring) on MDN.
-
-```res example
-Js.String2.substring("playground", ~from=3, ~to_=6) == "ygr"
-Js.String2.substring("playground", ~from=6, ~to_=3) == "ygr"
-Js.String2.substring("playground", ~from=4, ~to_=12) == "ground"
-```
-
-## substringToEnd
-
-```res sig
-let substringToEnd: (t, ~from: int) => t
-```
-
-`substringToEnd(str, ~from: start)` returns the substring of `str` from position `start` to the end.
-- If `start` is less than or equal to zero, the entire string is returned.
-- If `start` is greater than or equal to the length of `str`, the empty string is returned.
-
-See [`String.substring`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring) on MDN.
-
-```res example
-Js.String2.substringToEnd("playground", ~from=4) == "ground"
-Js.String2.substringToEnd("playground", ~from=-3) == "playground"
-Js.String2.substringToEnd("playground", ~from=12) == ""
-```
-
-## toLowerCase
-
-```res sig
-let toLowerCase: t => t
-```
-
-`toLowerCase(str)` converts `str` to lower case using the locale-insensitive case mappings in the Unicode Character Database.
-Notice that the conversion can give different results depending upon context, for example with the Greek letter sigma, which has two different lower case forms; one when it is the last character in a string and another when it is not. See [`String.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase) on MDN.
-
-```res example
-Js.String2.toLowerCase("ABC") == "abc"
-Js.String2.toLowerCase(`ΣΠ`) == `σπ`
-Js.String2.toLowerCase(`ΠΣ`) == `πς`
-```
-
-## toLocaleLowerCase
-
-```res sig
-let toLocaleLowerCase: t => t
-```
-
-`toLocaleLowerCase(str)` converts `str` to lower case using the current locale. See [`String.toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase) on MDN.
-
-## toUpperCase
-
-```res sig
-let toUpperCase: t => t
-```
-
-`toUpperCase(str)` converts `str` to upper case using the locale-insensitive case mappings in the Unicode Character Database.
-Notice that the conversion can expand the number of letters in the result; for example the German ß capitalizes to two Ses in a row. See [`String.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) on MDN.
-
-```res example
-Js.String2.toUpperCase("abc") == "ABC"
-Js.String2.toUpperCase(`Straße`) == `STRASSE`
-Js.String2.toUpperCase(`πς`) == `ΠΣ`
-```
-
-## toLocaleUpperCase
-
-```res sig
-let toLocaleUpperCase: t => t
-```
-
-`toLocaleUpperCase(str)` converts `str` to upper case using the current locale. See [`String.to:LocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase) on MDN.
-
-## trim
-
-```res sig
-let trim: t => t
-```
-
-`trim(str)` returns a string that is `str` with whitespace stripped from both ends. Internal whitespace is not removed. See [`String.trim`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trim) on MDN.
-
-```res example
-Js.String2.trim("   abc def   ") == "abc def"
-Js.String2.trim("\n\r\t abc def \n\n\t\r ") == "abc def"
-```
-
-## anchor
-
-```res sig
-let anchor: (t, t) => t
-```
-
-`anchor(anchorText, anchorName)` creates a string with an HTML `<a>` element with name attribute of `anchorName` and `anchorText` as its content. Please do not use this method, as it has been removed from the relevant web standards. See [`String.anchor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/anchor) on MDN.
-
-```res example
-Js.String2.anchor("Page One", "page1") == "<a name=\"page1\">Page One</a>"
-```
-
-## link
-
-```res sig
-let link: (t, t) => t
-```
-
-ES2015: `link(linkText, urlText)` creates a string with an HTML `<a>` element with href attribute of `urlText` and `linkText` as its content. Please do not use this method, as it has been removed from the relevant web standards. See [`String.link`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/link) on MDN.
-
-```res example
-Js.String2.link("Go to page two", "page2.html") == "<a href=\"page2.html\">Go to page two</a>"
-```
-
-## castToArrayLike
-
-```res sig
-let castToArrayLike: t => Js_array2.array_like<t>
-```
-
-Casts its argument to an `array_like` entity that can be processed by functions such as `Js.Array2.fromMap()`
-
-```res example
-let s = "abcde"
-let arr = Js.Array2.fromMap(Js.String2.castToArrayLike(s), x => x)
-arr == ["a", "b", "c", "d", "e"]
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/string.mdx b/pages/docs/manual/v9.0.0/api/js/string.mdx
deleted file mode 100644
index 7e4eb846d..000000000
--- a/pages/docs/manual/v9.0.0/api/js/string.mdx
+++ /dev/null
@@ -1,803 +0,0 @@
-# String
-
-<Intro>
-
-Provide bindings to JS string. Optimized for pipe-last.
-
-</Intro>
-
-## t
-
-```res prelude
-type t = string
-```
-
-## make
-
-```res sig
-let make: 'a => t
-```
-
-`make(value)` converts the given value to a `string`.
-
-```res example
-Js.String2.make(3.5) == "3.5"
-Js.String2.make([1, 2, 3]) == "1,2,3"
-```
-
-## fromCharCode
-
-```res sig
-let fromCharCode: int => t
-```
-
-`fromCharCode(n)` creates a `string` containing the character corresponding to that number; `n` ranges from 0 to 65535.
-If out of range, the lower 16 bits of the value are used. Thus, `fromCharCode(0x1F63A)` gives the same result as `fromCharCode(0xF63A)`. See [`String.fromCharCode`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode) on MDN.
-
-```res example
-Js.String2.fromCharCode(65) == "A"
-Js.String2.fromCharCode(0x3c8) == `ψ`
-Js.String2.fromCharCode(0xd55c) == `한`
-Js.String2.fromCharCode(-64568) == `ψ`
-```
-
-## fromCharCodeMany
-
-```res sig
-let fromCharCodeMany: array<int> => t
-```
-
-`fromCharCodeMany([n1, n2, n3])` creates a `string` from the characters corresponding to the given numbers, using the same rules as `fromCharCode`. See [`String.fromCharCode`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode) on MDN.
-
-## fromCodePoint
-
-```res sig
-let fromCodePoint: int => t
-```
-
-`fromCodePoint(n)` creates a `string` containing the character corresponding to that numeric code point.
-If the number is not a valid code point, it raises `RangeError`.
-Thus, `fromCodePoint(0x1F63A)` will produce a correct value, unlike `fromCharCode(0x1F63A)`, and `fromCodePoint(-5)` will raise a `RangeError`. See [`String.fromCodePoint`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint) on MDN.
-
-```res example
-Js.String2.fromCodePoint(65) == "A"
-Js.String2.fromCodePoint(0x3c8) == `ψ`
-Js.String2.fromCodePoint(0xd55c) == `한`
-Js.String2.fromCodePoint(0x1f63a) == `😺`
-```
-
-## fromCodePointMany
-
-```res sig
-let fromCodePointMany: array<int> => t
-```
-
-`fromCodePointMany([n1, n2, n3])` creates a `string` from the characters corresponding to the given code point numbers, using the same rules as `fromCodePoint`. See [`String.fromCodePoint`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint) on MDN.
-
-```res example
-Js.String2.fromCodePointMany([0xd55c, 0xae00, 0x1f63a]) == `한글😺`
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-`length(s)` returns the length of the given `string`. See [`String.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length) on MDN.
-
-```res example
-Js.String2.length("abcd") == 4
-```
-
-## get
-
-```res sig
-let get: (t, int) => t
-```
-
-`get(s, n)` returns as a `string` the character at the given index number.
-If `n` is out of range, this function returns `undefined`, so at some point this function may be modified to return `option(string)`.
-
-```res example
-Js.String2.get("Reason", 0) == "R"
-Js.String2.get("Reason", 4) == "o"
-Js.String2.get(`Rẽasöń`, 5) == `ń`
-```
-
-## charAt
-
-```res sig
-let charAt: (int, t) => t
-```
-
-`charAt(n, s)` gets the character at index `n` within string `s`.
-If `n` is negative or greater than the length of `s`, it returns the empty string.
-If the string contains characters outside the range \u0000-\uffff, it will return the first 16-bit value at that position in the string. See [`String.charAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charAt) on MDN.
-
-```res example
-Js.String.charAt(0, "Reason") == "R"
-Js.String.charAt(12, "Reason") == ""
-Js.String.charAt(5, `Rẽasöń`) == `ń`
-```
-
-## charCodeAt
-
-```res sig
-let charCodeAt: (int, t) => float
-```
-
-`charCodeAt(n, s)` returns the character code at position `n` in string `s`; the result is in the range 0-65535, unlke `codePointAt`, so it will not work correctly for characters with code points greater than or equal to 0x10000.
-The return type is `float` because this function returns NaN if `n` is less than zero or greater than the length of the string. See [`String.charCodeAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charCodeAt) on MDN.
-
-```res example
-Js.String.charCodeAt(0, `😺`) == 0xd83d->Belt.Int.toFloat
-Js.String.codePointAt(0, `😺`) == Some(0x1f63a)
-```
-
-## codePointAt
-
-```res sig
-let codePointAt: (int, t) => option<int>
-```
-
-`codePointAt(n, s)` returns the code point at position `n` within string `s` as a `Some(value)`.
-The return value handles code points greater than or equal to 0x10000.
-If there is no code point at the given position, the function returns `None`. See [`String.codePointAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/codePointAt) on MDN.
-
-```res example
-Js.String.codePointAt(1, `¿😺?`) == Some(0x1f63a)
-Js.String.codePointAt(5, "abc") == None
-```
-
-## concat
-
-```res sig
-let concat: (t, t) => t
-```
-
-`concat(append, original)` returns a new `string` with `append` added after `original`. See [`String.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat) on MDN.
-
-```res example
-Js.String.concat("bell", "cow") == "cowbell"
-```
-
-## concatMany
-
-```res sig
-let concatMany: (array<t>, t) => t
-```
-
-`concat(arr, original)` returns a new `string` consisting of each item of an array of strings added to the `original` string. See [`String.concat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat) on MDN.
-
-```res example
-Js.String.concatMany(["2nd", "3rd", "4th"], "1st") == "1st2nd3rd4th"
-```
-
-## endsWith
-
-```res sig
-let endsWith: (t, t) => bool
-```
-
-ES2015: `endsWith(substr, str)` returns `true` if the `str` ends with `substr`, `false` otherwise. See [`String.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith) on MDN.
-
-```res example
-Js.String.endsWith("Script", "BuckleScript") == true
-Js.String.endsWith("Script", "BuckleShoes") == false
-```
-
-## endsWithFrom
-
-```res sig
-let endsWithFrom: (t, int, t) => bool
-```
-
-`endsWithFrom(ending, len, str)` returns `true` if the first len characters of `str` end with `ending`, `false` otherwise.
-If `len` is greater than or equal to the length of `str`, then it works like `endsWith`. (Honestly, this should have been named endsWithAt, but oh well.) See [`String.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith) on MDN.
-
-```res example
-Js.String.endsWithFrom("cd", 4, "abcd") == true
-Js.String.endsWithFrom("cd", 3, "abcde") == false
-Js.String.endsWithFrom("cde", 99, "abcde") == true
-Js.String.endsWithFrom("ple", 7, "example.dat") == true
-```
-
-## includes
-
-```res sig
-let includes: (t, t) => bool
-```
-
-ES2015: `includes(searchValue, str)` returns `true` if `searchValue` is found anywhere within `str`, false otherwise. See [`String.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes) on MDN.
-
-```res example
-Js.String.includes("gram", "programmer") == true
-Js.String.includes("er", "programmer") == true
-Js.String.includes("pro", "programmer") == true
-Js.String.includes("xyz", "programmer.dat") == false
-```
-
-## includesFrom
-
-```res sig
-let includesFrom: (t, int, t) => bool
-```
-
-ES2015: `includes(searchValue start, str)` returns `true` if `searchValue` is found anywhere within `str` starting at character number `start` (where 0 is the first character), `false` otherwise. See [`String.includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes) on MDN.
-
-```res example
-Js.String.includesFrom("gram", 1, "programmer") == true
-Js.String.includesFrom("gram", 4, "programmer") == false
-Js.String.includesFrom(`한`, 1, `대한민국`) == true
-```
-
-## indexOf
-
-```res sig
-let indexOf: (t, t) => int
-```
-
-ES2015: `indexOf(searchValue, str)` returns the position at which `searchValue` was first found within `str`, or -1 if `searchValue` is not in `str`. See [`String.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf) on MDN.
-
-```res example
-Js.String.indexOf("ok", "bookseller") == 2
-Js.String.indexOf("sell", "bookseller") == 4
-Js.String.indexOf("ee", "beekeeper") == 1
-Js.String.indexOf("xyz", "bookseller") == -1
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (t, t, int) => int
-```
-`indexOfFrom(searchValue, start, str)` returns the position at which `searchValue` was found within `str` starting at character position `start`, or -1 if `searchValue` is not found in that portion of `str`.
-The return value is relative to the beginning of the string, no matter where the search started from. See [`String.indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf) on MDN.
-
-```res example
-Js.String.indexOfFrom("ok", 1, "bookseller") == 2
-Js.String.indexOfFrom("sell", 2, "bookseller") == 4
-Js.String.indexOfFrom("sell", 5, "bookseller") == -1
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (t, t) => int
-```
-
-`lastIndexOf(searchValue, str)` returns the position of the last occurrence of `searchValue` within `str`, searching backwards from the end of the string.
-Returns -1 if `searchValue` is not in `str`. The return value is always relative to the beginning of the string. See [`String.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf) on MDN.
-
-```res example
-Js.String.lastIndexOf("ok", "bookseller") == 2
-Js.String.lastIndexOf("ee", "beekeeper") == 4
-Js.String.lastIndexOf("xyz", "abcdefg") == -1
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (t, int, t) => int
-```
-
-`lastIndexOfFrom(searchValue, start, str)` returns the position of the last occurrence of `searchValue` within `str`, searching backwards from the given start position.
-Returns -1 if `searchValue` is not in `str`. The return value is always relative to the beginning of the string. See [`String.lastIndexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf) on MDN.
-
-```res example
-Js.String.lastIndexOfFrom("ok", 6, "bookseller") == 2
-Js.String.lastIndexOfFrom("ee", 8, "beekeeper") == 4
-Js.String.lastIndexOfFrom("ee", 3, "beekeeper") == 1
-Js.String.lastIndexOfFrom("xyz", 4, "abcdefg") == -1
-```
-
-## localeCompare
-
-```res sig
-let localeCompare: (t, t) => float
-```
-
-`localeCompare(comparison, reference)` returns
-- a negative value if reference comes before comparison in sort order
-- zero if reference and comparison have the same sort order
-- a positive value if reference comes after comparison in sort order
-
-See [`String.localeCompare`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare) on MDN.
-
-```res example
-Js.String.localeCompare("ant", "zebra") > 0.0
-Js.String.localeCompare("zebra", "ant") < 0.0
-Js.String.localeCompare("cat", "cat") == 0.0
-Js.String.localeCompare("cat", "CAT") > 0.0
-```
-
-## match
-
-```res sig
-let match_: (Js_re.t, t) => option<array<t>>
-```
-
-`match(regexp, str)` matches a `string` against the given `regexp`. If there is no match, it returns `None`. For regular expressions without the g modifier, if there is a match, the return value is `Some(array)` where the array contains:
-- The entire matched string
-- Any capture groups if the regexp had parentheses
-For regular expressions with the g modifier, a matched expression returns `Some(array)` with all the matched substrings and no capture groups. See [`String.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match) on MDN.
-
-```res example
-Js.String.match_(%re("/b[aeiou]t/"), "The better bats") == Some(["bet"])
-Js.String.match_(%re("/b[aeiou]t/g"), "The better bats") == Some(["bet", "bat"])
-Js.String.match_(%re("/(\d+)-(\d+)-(\d+)/"), "Today is 2018-04-05.") ==
-  Some(["2018-04-05", "2018", "04", "05"])
-Js.String.match_(%re("/b[aeiou]g/"), "The large container.") == None
-```
-
-## normalize
-
-```res sig
-let normalize: t => t
-```
-
-`normalize(str)` returns the normalized Unicode string using Normalization Form Canonical (NFC) Composition.
-Consider the character ã, which can be represented as the single codepoint \u00e3 or the combination of a lower case letter A \u0061 and a combining tilde \u0303.
-Normalization ensures that both can be stored in an equivalent binary representation. See [`String.normalize`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize) on MDN. See also [Unicode technical report #15](https://unicode.org/reports/tr15/) for details.
-
-## normalizeByForm
-
-```res sig
-let normalizeByForm: (t, t) => t
-```
-
-ES2015: `normalize(form, str)` returns the normalized Unicode string using the specified form of normalization, which may be one of:
-- "NFC" — Normalization Form Canonical Composition.
-- "NFD" — Normalization Form Canonical Decomposition.
-- "NFKC" — Normalization Form Compatibility Composition.
-- "NFKD" — Normalization Form Compatibility Decomposition.
-
-See [`String.normalize`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize) on MDN. See also [Unicode technical report #15](https://unicode.org/reports/tr15/) for details.
-
-## repeat
-
-```res sig
-let repeat: (t, int) => t
-```
-
-`repeat(n, str)` returns a `string` that consists of `n` repetitions of `str`. Raises `RangeError` if `n` is negative. See [`String.repeat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat) on MDN.
-
-```res example
-Js.String.repeat(3, "ha") == "hahaha"
-Js.String.repeat(0, "empty") == ""
-```
-
-## replace
-
-```res sig
-let replace: (t, t, t) => t
-```
-
-ES2015: `replace(substr, newSubstr, str)` returns a new `string` which is identical to `str` except with the first matching instance of `substr` replaced by `newSubstr`.
-`substr` is treated as a verbatim string to match, not a regular expression. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-Js.String.replace("old", "new", "old string") == "new string"
-Js.String.replace("the", "this", "the cat and the dog") == "this cat and the dog"
-```
-
-## replaceByRe
-
-```res sig
-let replaceByRe: (Js_re.t, t, t) => t
-```
-
-`replaceByRe(regex, replacement, str)` returns a new `string` where occurrences matching regex have been replaced by `replacement`. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-Js.String.replaceByRe(%re("/[aeiou]/g"), "x", "vowels be gone") == "vxwxls bx gxnx"
-Js.String.replaceByRe(%re("/(\w+) (\w+)/"), "$2, $1", "Juan Fulano") == "Fulano, Juan"
-```
-
-## unsafeReplaceBy0
-
-```res sig
-let unsafeReplaceBy0: (Js_re.t, (t, int, t) => t, t) => t
-```
-
-Returns a new `string` with some or all matches of a pattern with no capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-let str = "beautiful vowels"
-let re = %re("/[aeiou]/g")
-let matchFn = (matchPart, _offset, _wholeString) => Js.String.toUpperCase(matchPart)
-
-Js.String.unsafeReplaceBy0(re, matchFn, str) == "bEAUtIfUl vOwEls"
-```
-
-## unsafeReplaceBy1
-
-```res sig
-let unsafeReplaceBy1: (Js_re.t, (t, t, int, t) => t, t) => t
-```
-
-Returns a new `string` with some or all matches of a pattern with one set of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured string, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-let str = "Jony is 40"
-let re = %re("/(Jony is )\d+/g")
-let matchFn = (_match, part1, _offset, _wholeString) => {
-  part1 ++ "41"
-}
-
-Js.String.unsafeReplaceBy1(re, matchFn, str) == "Jony is 41"
-```
-
-## unsafeReplaceBy2
-
-```res sig
-let unsafeReplaceBy2: (Js_re.t, (t, t, t, int, t) => t, t) => t
-```
-
-Returns a new `string` with some or all matches of a pattern with two sets of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured strings, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-```res example
-let str = "7 times 6"
-let re = %re("/(\d+) times (\d+)/")
-let matchFn = (_match, p1, p2, _offset, _wholeString) => {
-  switch (Belt.Int.fromString(p1), Belt.Int.fromString(p2)) {
-  | (Some(x), Some(y)) => Belt.Int.toString(x * y)
-  | _ => "???"
-  }
-}
-
-Js.String.unsafeReplaceBy2(re, matchFn, str) == "42"
-```
-
-## unsafeReplaceBy3
-
-```res sig
-let unsafeReplaceBy3: (Js_re.t, (t, t, t, t, int, t) => t, t) => t
-```
-
-Returns a new `string` with some or all matches of a pattern with three sets of capturing parentheses replaced by the value returned from the given function.
-The function receives as its parameters the matched string, the captured strings, the offset at which the match begins, and the whole string being matched. See [`String.replace`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) on MDN.
-
-## search
-
-```res sig
-let search: (Js_re.t, t) => int
-```
-
-`search(regexp, str)` returns the starting position of the first match of `regexp` in the given `str`, or -1 if there is no match. See [`String.search`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/search) on MDN.
-
-```res example
-Js.String.search(%re("/\d+/"), "testing 1 2 3") == 8
-Js.String.search(%re("/\d+/"), "no numbers") == -1
-```
-
-## slice
-
-```res sig
-let slice: (~from: int, ~to_: int, t) => t
-```
-
-`slice(from:n1, to_:n2, str)` returns the substring of `str` starting at character `n1` up to but not including `n2`.
-- If either `n1` or `n2` is negative, then it is evaluated as `length(str - n1)` or `length(str - n2)`.
-- If `n2` is greater than the length of `str`, then it is treated as `length(str)`.
-- If `n1` is greater than `n2`, slice returns the empty string.
-
-See [`String.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice) on MDN.
-
-```res example
-Js.String.slice(~from=2, ~to_=5, "abcdefg") == "cde"
-Js.String.slice(~from=2, ~to_=9, "abcdefg") == "cdefg"
-Js.String.slice(~from=-4, ~to_=-2, "abcdefg") == "de"
-Js.String.slice(~from=5, ~to_=1, "abcdefg") == ""
-```
-
-## sliceToEnd
-
-```res sig
-let sliceToEnd: (~from: int, t) => t
-```
-
-`sliceToEnd(str, from:n)` returns the substring of `str` starting at character `n` to the end of the string.
-- If `n` is negative, then it is evaluated as `length(str - n)`.
-- If `n` is greater than the length of `str`, then sliceToEnd returns the empty string.
-
-See [`String.slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice) on MDN.
-
-```res example
-Js.String.sliceToEnd(~from=4, "abcdefg") == "efg"
-Js.String.sliceToEnd(~from=-2, "abcdefg") == "fg"
-Js.String.sliceToEnd(~from=7, "abcdefg") == ""
-```
-
-## split
-
-```res sig
-let split: (t, t) => array<t>
-```
-
-`split(delimiter, str)` splits the given `str` at every occurrence of `delimiter` and returns an array of the resulting substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```res example
-Js.String.split("-", "2018-01-02") == ["2018", "01", "02"]
-Js.String.split(",", "a,b,,c") == ["a", "b", "", "c"]
-Js.String.split("::", "good::bad as great::awful") == ["good", "bad as great", "awful"]
-Js.String.split(";", "has-no-delimiter") == ["has-no-delimiter"]
-```
-
-## splitAtMost
-
-```res sig
-let splitAtMost: (t, ~limit: int, t) => array<t>
-```
-
-`splitAtMost(delimiter, ~limit:n, str)` splits the given `str` at every occurrence of `delimiter` and returns an array of the first `n` resulting substrings.
-If `n` is negative or greater than the number of substrings, the array will contain all the substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```res example
-Js.String.splitAtMost("/", ~limit=3, "ant/bee/cat/dog/elk") == ["ant", "bee", "cat"]
-Js.String.splitAtMost("/", ~limit=0, "ant/bee/cat/dog/elk") == []
-Js.String.splitAtMost("/", ~limit=9, "ant/bee/cat/dog/elk") == ["ant", "bee", "cat", "dog", "elk"]
-```
-
-## splitLimited
-
-```res sig
-let splitLimited: (t, int, t) => array<t>
-```
-
-Deprecated - Please use splitAtMost.
-
-## splitByRe
-
-```res sig
-let splitByRe: (Js_re.t, t) => array<option<t>>
-```
-
-`splitByRe(regex, str)` splits the given `str` at every occurrence of `regex` and returns an array of the resulting substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```res example
-Js.String.splitByRe(%re("/\s*[,;]\s*/"), "art; bed , cog ;dad") == [
-    Some("art"),
-    Some("bed"),
-    Some("cog"),
-    Some("dad"),
-  ]
-```
-
-## splitByReAtMost
-
-```res sig
-let splitByReAtMost: (Js_re.t, ~limit: int, t) => array<option<t>>
-```
-
-`splitByReAtMost(regex, ~limit:n, str)` splits the given `str` at every occurrence of `regex` and returns an array of the first `n` resulting substrings.
-If `n` is negative or greater than the number of substrings, the array will contain all the substrings. See [`String.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split) on MDN.
-
-```res example
-Js.String.splitByReAtMost(%re("/\s*:\s*/"), ~limit=3, "one: two: three: four") == [
-    Some("one"),
-    Some("two"),
-    Some("three"),
-  ]
-
-Js.String.splitByReAtMost(%re("/\s*:\s*/"), ~limit=0, "one: two: three: four") == []
-
-Js.String.splitByReAtMost(%re("/\s*:\s*/"), ~limit=8, "one: two: three: four") == [
-    Some("one"),
-    Some("two"),
-    Some("three"),
-    Some("four"),
-  ]
-```
-
-## splitRegexpLimited
-
-```res sig
-let splitRegexpLimited: (Js_re.t, int, t) => array<t>
-```
-
-Deprecated - Please use splitByReAtMost.
-
-## startsWith
-
-```res sig
-let startsWith: (t, t) => bool
-```
-
-ES2015: `startsWith(substr, str)` returns `true` if the `str` starts with `substr`, `false` otherwise. See [`String.startsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith) on MDN.
-
-```res example
-Js.String.startsWith("Buckle", "BuckleScript") == true
-Js.String.startsWith("", "BuckleScript") == true
-Js.String.startsWith("Buckle", "JavaScript") == false
-```
-
-## startsWithFrom
-
-```res sig
-let startsWithFrom: (t, int, t) => bool
-```
-
-ES2015: `startsWithFrom(substr, n, str)` returns `true` if the `str` starts with `substr` starting at position `n`, false otherwise.
-If `n` is negative, the search starts at the beginning of `str`. See [`String.startsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith) on MDN.
-
-```res example
-Js.String.startsWithFrom("kle", 3, "BuckleScript") == true
-Js.String.startsWithFrom("", 3, "BuckleScript") == true
-Js.String.startsWithFrom("Buckle", 2, "JavaScript") == false
-```
-
-## substr
-
-```res sig
-let substr: (~from: int, t) => t
-```
-
-`substr(~from:n, str)` returns the substring of `str` from position `n` to the end of the string.
-- If `n` is less than zero, the starting position is the length of `str - n`.
-- If `n` is greater than or equal to the length of `str`, returns the empty string.
-
-JavaScript’s `String.substr()` is a legacy function. When possible, use `substring()` instead. See [`String.substr`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr) on MDN.
-
-```res example
-Js.String.substr(~from=3, "abcdefghij") == "defghij"
-Js.String.substr(~from=-3, "abcdefghij") == "hij"
-Js.String.substr(~from=12, "abcdefghij") == ""
-```
-
-## substrAtMost
-
-```res sig
-let substrAtMost: (~from: int, ~length: int, t) => t
-```
-
-`substrAtMost(~from: pos, ~length: n, str)` returns the substring of `str` of length `n` starting at position `pos`.
-- If `pos` is less than zero, the starting position is the length of `str - pos`.
-- If `pos` is greater than or equal to the length of `str`, returns the empty string.
-- If `n` is less than or equal to zero, returns the empty string.
-
-JavaScript’s `String.substr()` is a legacy function. When possible, use `substring()` instead. See [`String.substr`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr) on MDN.
-
-```res example
-Js.String.substrAtMost(~from=3, ~length=4, "abcdefghij") == "defg"
-Js.String.substrAtMost(~from=-3, ~length=4, "abcdefghij") == "hij"
-Js.String.substrAtMost(~from=12, ~length=2, "abcdefghij") == ""
-```
-
-## substring
-
-```res sig
-let substring: (~from: int, ~to_: int, t) => t
-```
-
-`substring(~from: start, ~to_: finish, str)` returns characters `start` up to but not including finish from `str`.
-- If `start` is less than zero, it is treated as zero.
-- If `finish` is zero or negative, the empty string is returned.
-- If `start` is greater than `finish`, the `start` and `finish` points are swapped.
-
-See [`String.substring`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring) on MDN.
-
-```res example
-Js.String.substring(~from=3, ~to_=6, "playground") == "ygr"
-Js.String.substring(~from=6, ~to_=3, "playground") == "ygr"
-Js.String.substring(~from=4, ~to_=12, "playground") == "ground"
-```
-
-## substringToEnd
-
-```res sig
-let substringToEnd: (~from: int, t) => t
-```
-
-`substringToEnd(~from: start, str)` returns the substring of `str` from position `start` to the end.
-- If `start` is less than or equal to zero, the entire string is returned.
-- If `start` is greater than or equal to the length of `str`, the empty string is returned.
-
-See [`String.substring`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring) on MDN.
-
-```res example
-Js.String.substringToEnd(~from=4, "playground") == "ground"
-Js.String.substringToEnd(~from=-3, "playground") == "playground"
-Js.String.substringToEnd(~from=12, "playground") == ""
-```
-
-## toLowerCase
-
-```res sig
-let toLowerCase: t => t
-```
-
-`toLowerCase(str)` converts `str` to lower case using the locale-insensitive case mappings in the Unicode Character Database.
-Notice that the conversion can give different results depending upon context, for example with the Greek letter sigma, which has two different lower case forms; one when it is the last character in a string and another when it is not. See [`String.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase) on MDN.
-
-```res example
-Js.String.toLowerCase("ABC") == "abc"
-Js.String.toLowerCase(`ΣΠ`) == `σπ`
-Js.String.toLowerCase(`ΠΣ`) == `πς`
-```
-
-## toLocaleLowerCase
-
-```res sig
-let toLocaleLowerCase: t => t
-```
-
-`toLocaleLowerCase(str)` converts `str` to lower case using the current locale. See [`String.toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase) on MDN.
-
-## toUpperCase
-
-```res sig
-let toUpperCase: t => t
-```
-
-`toUpperCase(str)` converts `str` to upper case using the locale-insensitive case mappings in the Unicode Character Database.
-Notice that the conversion can expand the number of letters in the result; for example the German ß capitalizes to two Ses in a row. See [`String.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) on MDN.
-
-```res example
-Js.String.toUpperCase("abc") == "ABC"
-Js.String.toUpperCase(`Straße`) == `STRASSE`
-Js.String.toUpperCase(`πς`) == `ΠΣ`
-```
-
-## toLocaleUpperCase
-
-```res sig
-let toLocaleUpperCase: t => t
-```
-
-`toLocaleUpperCase(str)` converts `str` to upper case using the current locale. See [`String.to:LocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase) on MDN.
-
-## trim
-
-```res sig
-let trim: t => t
-```
-
-`trim(str)` returns a string that is `str` with whitespace stripped from both ends. Internal whitespace is not removed. See [`String.trim`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trim) on MDN.
-
-```res example
-Js.String.trim("   abc def   ") == "abc def"
-Js.String.trim("\n\r\t abc def \n\n\t\r ") == "abc def"
-```
-
-## anchor
-
-```res sig
-let anchor: (t, t) => t
-```
-
-`anchor(anchorName, anchorText)` creates a string with an HTML `<a>` element with name attribute of `anchorName` and `anchorText` as its content. Please do not use this method, as it has been removed from the relevant web standards. See [`String.anchor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/anchor) on MDN.
-
-```res example
-Js.String.anchor("page1", "Page One") == "<a name=\"page1\">Page One</a>"
-```
-
-## link
-
-```res sig
-let link: (t, t) => t
-```
-
-ES2015: `link(urlText, linkText)` creates a string with an HTML `<a>` element with href attribute of `urlText` and `linkText` as its content. Please do not use this method, as it has been removed from the relevant web standards. See [`String.link`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/link) on MDN.
-
-```res example
-Js.String.link("page2.html", "Go to page two") == "<a href=\"page2.html\">Go to page two</a>"
-```
-
-## castToArrayLike
-
-```res sig
-let castToArrayLike: t => Js_array2.array_like<t>
-```
-
-Casts its argument to an `array_like` entity that can be processed by functions such as `Js.Array2.fromMap()`
-
-```res example
-let s = "abcde"
-let arr = Js.Array2.fromMap(Js.String.castToArrayLike(s), x => x)
-arr == ["a", "b", "c", "d", "e"]
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array-2.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array-2.mdx
deleted file mode 100644
index 617e9324d..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array-2.mdx
+++ /dev/null
@@ -1,31 +0,0 @@
-# TypedArray2
-
-<Intro>
-
-Provide bindings to JS typed array.
-
-</Intro>
-
-## array_buffer
-
-```res sig
-type array_buffer
-```
-
-## array_like
-
-```res sig
-type array_like<'a>
-```
-
-## module ArrayBuffer
-## module Int8Array
-## module Uint8Array
-## module Uint8ClampedArray
-## module Int16Array
-## module Uint16Array
-## module Int32Array
-## module Uint32Array
-## module Float32Array
-## module Float64Array
-## module DataView
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array-2_array-buffer.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array-2_array-buffer.mdx
deleted file mode 100644
index 5bef6f7e8..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array-2_array-buffer.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# TypedArray2.ArrayBuffer
-
-<Intro>
-
-Provide bindings to JS typed array ArrayBuffer.
-
-</Intro>
-
-## t
-
-```res prelude
-type t = Js_typed_array2.array_buffer
-```
-
-## make
-
-```res sig
-let make: int => t
-```
-
-Takes length. initializes elements to 0.
-
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## slice
-
-```res sig
-let slice: (t, ~start: int, ~end_: int) => Js_typed_array2.array_buffer
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (t, int) => Js_typed_array2.array_buffer
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array-2_data-view.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array-2_data-view.mdx
deleted file mode 100644
index 0b65c8da7..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array-2_data-view.mdx
+++ /dev/null
@@ -1,223 +0,0 @@
-# TypedArray2.DataView
-
-<Intro>
-
-Provide bindings to JS typed array DataView.
-
-</Intro>
-
-## t
-
-```res prelude
-type t
-```
-
-## make
-
-```res sig
-let make: Js_typed_array2.array_buffer => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## getInt8
-
-```res sig
-let getInt8: (t, int) => int
-```
-
-## getUint8
-
-```res sig
-let getUint8: (t, int) => int
-```
-
-## getInt16
-
-```res sig
-let getInt16: (t, int) => int
-```
-
-## getInt16LittleEndian
-
-```res sig
-let getInt16LittleEndian: (t, int) => int
-```
-
-## getUint16
-
-```res sig
-let getUint16: (t, int) => int
-```
-
-## getUint16LittleEndian
-
-```res sig
-let getUint16LittleEndian: (t, int) => int
-```
-
-## getInt32
-
-```res sig
-let getInt32: (t, int) => int
-```
-
-## getInt32LittleEndian
-
-```res sig
-let getInt32LittleEndian: (t, int) => int
-```
-
-## getUint32
-
-```res sig
-let getUint32: (t, int) => int
-```
-
-## getUint32LittleEndian
-
-```res sig
-let getUint32LittleEndian: (t, int) => int
-```
-
-## getFloat32
-
-```res sig
-let getFloat32: (t, int) => float
-```
-
-## getFloat32LittleEndian
-
-```res sig
-let getFloat32LittleEndian: (t, int) => float
-```
-
-## getFloat64
-
-```res sig
-let getFloat64: (t, int) => float
-```
-
-## getFloat64LittleEndian
-
-```res sig
-let getFloat64LittleEndian: (t, int) => float
-```
-
-## setInt8
-
-```res sig
-let setInt8: (t, int, int) => unit
-```
-
-## setUint8
-
-```res sig
-let setUint8: (t, int, int) => unit
-```
-
-## setInt16
-
-```res sig
-let setInt16: (t, int, int) => unit
-```
-
-## setInt16LittleEndian
-
-```res sig
-let setInt16LittleEndian: (t, int, int) => unit
-```
-
-## setUint16
-
-```res sig
-let setUint16: (t, int, int) => unit
-```
-
-## setUint16LittleEndian
-
-```res sig
-let setUint16LittleEndian: (t, int, int) => unit
-```
-
-## setInt32
-
-```res sig
-let setInt32: (t, int, int) => unit
-```
-
-## setInt32LittleEndian
-
-```res sig
-let setInt32LittleEndian: (t, int, int) => unit
-```
-
-## setUint32
-
-```res sig
-let setUint32: (t, int, int) => unit
-```
-
-## setUint32LittleEndian
-
-```res sig
-let setUint32LittleEndian: (t, int, int) => unit
-```
-
-## setFloat32
-
-```res sig
-let setFloat32: (t, int, float) => unit
-```
-
-## setFloat32LittleEndian
-
-```res sig
-let setFloat32LittleEndian: (t, int, float) => unit
-```
-
-## setFloat64
-
-```res sig
-let setFloat64: (t, int, float) => unit
-```
-
-## setFloat64LittleEndian
-
-```res sig
-let setFloat64LittleEndian: (t, int, float) => unit
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array-2_float-32-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array-2_float-32-array.mdx
deleted file mode 100644
index 2bfec4069..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array-2_float-32-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Float32Array
-
-<Intro>
-
-Provide bindings to JS typed array Float32Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = float
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array-2_float-64-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array-2_float-64-array.mdx
deleted file mode 100644
index 5cf59253b..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array-2_float-64-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Float64Array
-
-<Intro>
-
-Provide bindings to JS typed array Float64Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = float
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array-2_int-16-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array-2_int-16-array.mdx
deleted file mode 100644
index 6452ee5ef..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array-2_int-16-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Int16Array
-
-<Intro>
-
-Provide bindings to JS typed array Int16Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array-2_int-32-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array-2_int-32-array.mdx
deleted file mode 100644
index da230b64b..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array-2_int-32-array.mdx
+++ /dev/null
@@ -1,375 +0,0 @@
-# TypedArray2.Int32Array
-
-<Intro>
-
-Provide bindings to JS typed array Int32Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int32
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
-
-## create
-
-```res sig
-let create: array<elt> => t
-```
-
-## of_buffer
-
-```res sig
-let of_buffer: Js_typed_array2.array_buffer => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array-2_int-8-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array-2_int-8-array.mdx
deleted file mode 100644
index d0676dce3..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array-2_int-8-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Int8Array
-
-<Intro>
-
-Provide bindings to JS typed array Int8Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array-2_uint-16-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array-2_uint-16-array.mdx
deleted file mode 100644
index 67ad8e6db..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array-2_uint-16-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Uint16Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint16Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array-2_uint-32-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array-2_uint-32-array.mdx
deleted file mode 100644
index e27f5075f..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array-2_uint-32-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.UInt32Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint32Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array-2_uint-8-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array-2_uint-8-array.mdx
deleted file mode 100644
index 3af6a295d..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array-2_uint-8-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Uint8Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint8Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array-2_uint-8-clamped-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array-2_uint-8-clamped-array.mdx
deleted file mode 100644
index 4a015d3ba..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array-2_uint-8-clamped-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray2.Uint8ClampedArray
-
-<Intro>
-
-Provide bindings to JS typed array Uint8ClampedArray.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array2.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array2.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array2.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array2.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array2.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array.mdx
deleted file mode 100644
index b62f9e668..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# TypedArray
-
-<Intro>
-
-Provide bindings to JS typed array.
-
-</Intro>
-
-## array_buffer
-
-```res sig
-type array_buffer
-```
-
-## array_like
-
-```res sig
-type array_like<'a>
-```
-
-## module type Type
-
-```res sig
-module type Type = {
-  type t
-}
-```
-
-## module ArrayBuffer
-## module type S
-## module Int8Array
-## module Uint8Array
-## module Uint8ClampedArray
-## module Int16Array
-## module Uint16Array
-## module Int32Array
-## module Uint32Array
-## module Float32Array
-## module Float64Array
-## module DataView
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array_array-buffer.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array_array-buffer.mdx
deleted file mode 100644
index f5dbd3860..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array_array-buffer.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# TypedArray.ArrayBuffer
-
-<Intro>
-
-Provide bindings to JS typed array ArrayBuffer.
-
-</Intro>
-
-## t
-
-```res prelude
-type t = Js_typed_array.array_buffer
-```
-
-## make
-
-```res sig
-let make: int => t
-```
-
-Takes length. initializes elements to 0.
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => Js_typed_array.array_buffer
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => Js_typed_array.array_buffer
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array_data-view.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array_data-view.mdx
deleted file mode 100644
index 6a02034ff..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array_data-view.mdx
+++ /dev/null
@@ -1,223 +0,0 @@
-# TypedArray.DataView
-
-<Intro>
-
-Provide bindings to JS typed array DataView.
-
-</Intro>
-
-## t
-
-```res prelude
-type t = Js_typed_array2.DataView.t
-```
-
-## make
-
-```res sig
-let make: Js_typed_array.array_buffer => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## getInt8
-
-```res sig
-let getInt8: (t, int) => int
-```
-
-## getUint8
-
-```res sig
-let getUint8: (t, int) => int
-```
-
-## getInt16
-
-```res sig
-let getInt16: (t, int) => int
-```
-
-## getInt16LittleEndian
-
-```res sig
-let getInt16LittleEndian: (t, int) => int
-```
-
-## getUint16
-
-```res sig
-let getUint16: (t, int) => int
-```
-
-## getUint16LittleEndian
-
-```res sig
-let getUint16LittleEndian: (t, int) => int
-```
-
-## getInt32
-
-```res sig
-let getInt32: (t, int) => int
-```
-
-## getInt32LittleEndian
-
-```res sig
-let getInt32LittleEndian: (t, int) => int
-```
-
-## getUint32
-
-```res sig
-let getUint32: (t, int) => int
-```
-
-## getUint32LittleEndian
-
-```res sig
-let getUint32LittleEndian: (t, int) => int
-```
-
-## getFloat32
-
-```res sig
-let getFloat32: (t, int) => float
-```
-
-## getFloat32LittleEndian
-
-```res sig
-let getFloat32LittleEndian: (t, int) => float
-```
-
-## getFloat64
-
-```res sig
-let getFloat64: (t, int) => float
-```
-
-## getFloat64LittleEndian
-
-```res sig
-let getFloat64LittleEndian: (t, int) => float
-```
-
-## setInt8
-
-```res sig
-let setInt8: (t, int, int) => unit
-```
-
-## setUint8
-
-```res sig
-let setUint8: (t, int, int) => unit
-```
-
-## setInt16
-
-```res sig
-let setInt16: (t, int, int) => unit
-```
-
-## setInt16LittleEndian
-
-```res sig
-let setInt16LittleEndian: (t, int, int) => unit
-```
-
-## setUint16
-
-```res sig
-let setUint16: (t, int, int) => unit
-```
-
-## setUint16LittleEndian
-
-```res sig
-let setUint16LittleEndian: (t, int, int) => unit
-```
-
-## setInt32
-
-```res sig
-let setInt32: (t, int, int) => unit
-```
-
-## setInt32LittleEndian
-
-```res sig
-let setInt32LittleEndian: (t, int, int) => unit
-```
-
-## setUint32
-
-```res sig
-let setUint32: (t, int, int) => unit
-```
-
-## setUint32LittleEndian
-
-```res sig
-let setUint32LittleEndian: (t, int, int) => unit
-```
-
-## setFloat32
-
-```res sig
-let setFloat32: (t, int, float) => unit
-```
-
-## setFloat32LittleEndian
-
-```res sig
-let setFloat32LittleEndian: (t, int, float) => unit
-```
-
-## setFloat64
-
-```res sig
-let setFloat64: (t, int, float) => unit
-```
-
-## setFloat64LittleEndian
-
-```res sig
-let setFloat64LittleEndian: (t, int, float) => unit
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array_float-32-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array_float-32-array.mdx
deleted file mode 100644
index c10ae364d..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array_float-32-array.mdx
+++ /dev/null
@@ -1,375 +0,0 @@
-# TypedArray.Float32Array
-
-<Intro>
-
-Provide bindings to JS typed array Float32Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = float
-type typed_array<'a> = Js_typed_array2.Float32Array.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
-
-## create
-
-```res sig
-let create: array<elt> => t
-```
-
-## of_buffer
-
-```res sig
-let of_buffer: Js_typed_array.array_buffer => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array_float-64-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array_float-64-array.mdx
deleted file mode 100644
index d7222de99..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array_float-64-array.mdx
+++ /dev/null
@@ -1,375 +0,0 @@
-# TypedArray.Float64Array
-
-<Intro>
-
-Provide bindings to JS typed array Float64Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = float
-type typed_array<'a> = Js_typed_array2.Float64Array.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
-
-## create
-
-```res sig
-let create: array<elt> => t
-```
-
-## of_buffer
-
-```res sig
-let of_buffer: Js_typed_array.array_buffer => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array_int-16-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array_int-16-array.mdx
deleted file mode 100644
index f49f8162a..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array_int-16-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.Int16Array
-
-<Intro>
-
-Provide bindings to JS typed array Int16Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a> = Js_typed_array2.Int16Array.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array_int-32-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array_int-32-array.mdx
deleted file mode 100644
index 7147de119..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array_int-32-array.mdx
+++ /dev/null
@@ -1,375 +0,0 @@
-# TypedArray.Int32Array
-
-<Intro>
-
-Provide bindings to JS typed array Int32Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int32
-type typed_array<'a> = Js_typed_array2.Int32Array.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
-
-## create
-
-```res sig
-let create: array<elt> => t
-```
-
-## of_buffer
-
-```res sig
-let of_buffer: Js_typed_array.array_buffer => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array_int-8-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array_int-8-array.mdx
deleted file mode 100644
index 5336025ae..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array_int-8-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.Int8Array
-
-<Intro>
-
-Provide bindings to JS typed array Int8Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a> = Js_typed_array2.Int8Array.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array_type-s.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array_type-s.mdx
deleted file mode 100644
index d71e5dcd7..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array_type-s.mdx
+++ /dev/null
@@ -1,309 +0,0 @@
-# TypedArray type S
-
-<Intro>
-
-TODO
-
-</Intro>
-
-## t
-
-```res prelude
-type elt
-type typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array_uint-16-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array_uint-16-array.mdx
deleted file mode 100644
index 6ac15af3c..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array_uint-16-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.Uint16Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint16Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a> = Js_typed_array2.Uint16Array.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array_uint-32-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array_uint-32-array.mdx
deleted file mode 100644
index fbd25e7fa..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array_uint-32-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.UInt32Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint32Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a> = Js_typed_array2.Uint32Array.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array_uint-8-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array_uint-8-array.mdx
deleted file mode 100644
index 75bf7449a..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array_uint-8-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.Uint8Array
-
-<Intro>
-
-Provide bindings to JS typed array Uint8Array.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a> = Js_typed_array2.Uint8Array.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/typed-array_uint-8-clamped-array.mdx b/pages/docs/manual/v9.0.0/api/js/typed-array_uint-8-clamped-array.mdx
deleted file mode 100644
index 57f4a5288..000000000
--- a/pages/docs/manual/v9.0.0/api/js/typed-array_uint-8-clamped-array.mdx
+++ /dev/null
@@ -1,363 +0,0 @@
-# TypedArray.Uint8ClampedArray
-
-<Intro>
-
-Provide bindings to JS typed array Uint8ClampedArray.
-
-</Intro>
-
-## t
-
-```res prelude
-type elt = int
-type typed_array<'a> = Js_typed_array2.Uint8ClampedArray.typed_array<'a>
-type t = typed_array<elt>
-```
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t, int) => elt
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t, int, elt) => unit
-```
-
-## buffer
-
-```res sig
-let buffer: t => Js_typed_array.array_buffer
-```
-
-## byteLength
-
-```res sig
-let byteLength: t => int
-```
-
-## byteOffset
-
-```res sig
-let byteOffset: t => int
-```
-
-## setArray
-
-```res sig
-let setArray: (array<elt>, t) => unit
-```
-
-## setArrayOffset
-
-```res sig
-let setArrayOffset: (array<elt>, int, t) => unit
-```
-
-## length
-
-```res sig
-let length: t => int
-```
-
-## copyWithin
-
-```res sig
-let copyWithin: (~to_: int, t) => t
-```
-
-## copyWithinFrom
-
-```res sig
-let copyWithinFrom: (~to_: int, ~from: int, t) => t
-```
-
-## copyWithinFromRange
-
-```res sig
-let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t) => t
-```
-
-## fillInPlace
-
-```res sig
-let fillInPlace: (elt, t) => t
-```
-
-## fillFromInPlace
-
-```res sig
-let fillFromInPlace: (elt, ~from: int, t) => t
-```
-
-## fillRangeInPlace
-
-```res sig
-let fillRangeInPlace: (elt, ~start: int, ~end_: int, t) => t
-```
-
-## reverseInPlace
-
-```res sig
-let reverseInPlace: t => t
-```
-
-## sortInPlace
-
-```res sig
-let sortInPlace: t => t
-```
-
-## sortInPlaceWith
-
-```res sig
-let sortInPlaceWith: ((. elt, elt) => int, t) => t
-```
-
-## includes
-
-```res sig
-let includes: (elt, t) => bool
-```
-
-ES2016
-
-## indexOf
-
-```res sig
-let indexOf: (elt, t) => int
-```
-
-## indexOfFrom
-
-```res sig
-let indexOfFrom: (elt, ~from: int, t) => int
-```
-
-## join
-
-```res sig
-let join: t => string
-```
-
-## joinWith
-
-```res sig
-let joinWith: (string, t) => string
-```
-
-## lastIndexOf
-
-```res sig
-let lastIndexOf: (elt, t) => int
-```
-
-## lastIndexOfFrom
-
-```res sig
-let lastIndexOfFrom: (elt, ~from: int, t) => int
-```
-
-## slice
-
-```res sig
-let slice: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## copy
-
-```res sig
-let copy: t => t
-```
-
-## sliceFrom
-
-```res sig
-let sliceFrom: (int, t) => t
-```
-
-## subarray
-
-```res sig
-let subarray: (~start: int, ~end_: int, t) => t
-```
-
-`start` is inclusive, `end_` exclusive.
-
-## subarrayFrom
-
-```res sig
-let subarrayFrom: (int, t) => t
-```
-
-## toString
-
-```res sig
-let toString: t => string
-```
-
-## toLocaleString
-
-```res sig
-let toLocaleString: t => string
-```
-
-## every
-
-```res sig
-let every: ((. elt) => bool, t) => bool
-```
-
-## everyi
-
-```res sig
-let everyi: ((. elt, int) => bool, t) => bool
-```
-
-## filter
-
-```res sig
-let filter: ((. elt) => bool, t) => t
-```
-
-## filteri
-
-```res sig
-let filteri: ((. elt, int) => bool, t) => t
-```
-
-## find
-
-```res sig
-let find: ((. elt) => bool, t) => Js.undefined<elt>
-```
-
-## findi
-
-```res sig
-let findi: ((. elt, int) => bool, t) => Js.undefined<elt>
-```
-
-## findIndex
-
-```res sig
-let findIndex: ((. elt) => bool, t) => int
-```
-
-## findIndexi
-
-```res sig
-let findIndexi: ((. elt, int) => bool, t) => int
-```
-
-## forEach
-
-```res sig
-let forEach: ((. elt) => unit, t) => unit
-```
-
-## forEachi
-
-```res sig
-let forEachi: ((. elt, int) => unit, t) => unit
-```
-
-## map
-
-```res sig
-let map: ((. elt) => 'b, t) => typed_array<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. elt, int) => 'b, t) => typed_array<'b>
-```
-
-## reduce
-
-```res sig
-let reduce: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reducei
-
-```res sig
-let reducei: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## reduceRight
-
-```res sig
-let reduceRight: ((. 'b, elt) => 'b, 'b, t) => 'b
-```
-
-## reduceRighti
-
-```res sig
-let reduceRighti: ((. 'b, elt, int) => 'b, 'b, t) => 'b
-```
-
-## some
-
-```res sig
-let some: ((. elt) => bool, t) => bool
-```
-
-## somei
-
-```res sig
-let somei: ((. elt, int) => bool, t) => bool
-```
-
-## _BYTES_PER_ELEMENT
-
-```res sig
-let _BYTES_PER_ELEMENT: int
-```
-
-## make
-
-```res sig
-let make: array<elt> => t
-```
-
-## fromBuffer
-
-```res sig
-let fromBuffer: Js_typed_array.array_buffer => t
-```
-
-## fromBufferOffset
-
-```res sig
-let fromBufferOffset: (Js_typed_array.array_buffer, int) => t
-```
-
-Can throw an exception.
-
-## fromBufferRange
-
-```res sig
-let fromBufferRange: (Js_typed_array.array_buffer, ~offset: int, ~length: int) => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## fromLength
-
-```res sig
-let fromLength: int => t
-```
-
-Raises `Js.Exn.Error` raise Js exception.
-
-## from
-
-```res sig
-let from: Js_typed_array.array_like<elt> => t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/types.mdx b/pages/docs/manual/v9.0.0/api/js/types.mdx
deleted file mode 100644
index bf19e7d0b..000000000
--- a/pages/docs/manual/v9.0.0/api/js/types.mdx
+++ /dev/null
@@ -1,78 +0,0 @@
-# Types
-
-<Intro>
-
-Provide utilities for manipulating JS types.
-
-</Intro>
-
-## symbol
-
-```res prelude
-type symbol
-```
-
-## obj_val
-
-```res prelude
-type obj_val
-```
-
-## undefined_val
-
-```res prelude
-type undefined_val
-```
-
-## null_val
-
-```res prelude
-type null_val
-```
-
-## function_val
-
-```res prelude
-type function_val
-```
-
-## t
-
-```res prelude
-type rec t<'a> =
-  | Undefined: t<undefined_val>
-  | Null: t<null_val>
-  | Boolean: t<bool>
-  | Number: t<float>
-  | String: t<string>
-  | Function: t<function_val>
-  | Object: t<obj_val>
-  | Symbol: t<symbol>
-```
-
-## test
-
-```res sig
-let test: ('a, t<'b>) => bool
-```
-
-## tagged_t
-
-```res prelude
-type tagged_t =
-  | JSFalse
-  | JSTrue
-  | JSNull
-  | JSUndefined
-  | JSNumber(float)
-  | JSString(string)
-  | JSFunction(function_val)
-  | JSObject(obj_val)
-  | JSSymbol(symbol)
-```
-
-## classify
-
-```res sig
-let classify: 'a => tagged_t
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/undefined.mdx b/pages/docs/manual/v9.0.0/api/js/undefined.mdx
deleted file mode 100644
index b15b0cd26..000000000
--- a/pages/docs/manual/v9.0.0/api/js/undefined.mdx
+++ /dev/null
@@ -1,119 +0,0 @@
-# Undefined
-
-<Intro>
-
-Provide utilities around `Js.undefined`.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a> = Js.undefined<'a>
-```
-
-Local alias for 'a Js.undefined.
-
-## return
-
-```res sig
-let return: 'a => t<'a>
-```
-
-Constructs a value of `Js.undefined('a)` containing a value of `'a`.
-
-## test
-
-```res sig
-let test: t<'a> => bool
-```
-
-Returns `true` if the given value is empty (undefined), `false` otherwise.
-
-## testAny
-
-```res sig
-let testAny: 'a => bool
-```
-
-Since 1.6.1 Returns `true` if the given value is empty (undefined).
-
-## empty
-
-```res sig
-let empty: t<'a>
-```
-
-The empty value, `undefined`.
-
-## getUnsafe
-
-```res sig
-let getUnsafe: t<'a> => 'a
-```
-
-## getExn
-
-```res sig
-let getExn: t<'a> => 'a
-```
-
-## bind
-
-```res sig
-let bind: (t<'a>, (. 'a) => 'b) => t<'b>
-```
-
-Maps the contained value using the given function.
-If `Js.undefined('a)` contains a value, that value is unwrapped, mapped to a `'b` using the given function `a' => 'b`, then wrapped back up and returned as `Js.undefined('b)`.
-
-```res example
-let maybeGreetWorld = (maybeGreeting: Js.undefined<string>) =>
-  Js.Undefined.bind(maybeGreeting, (. greeting) => greeting ++ " world!")
-```
-
-## iter
-
-```res sig
-let iter: (t<'a>, (. 'a) => unit) => unit
-```
-
-Iterates over the contained value with the given function.
-If `Js.undefined('a)` contains a value, that value is unwrapped and applied to the given function.
-
-```res example
-let maybeSay = (maybeMessage: Js.undefined<string>) =>
-  Js.Undefined.iter(maybeMessage, (. message) => Js.log(message))
-```
-
-## fromOption
-
-```res sig
-let fromOption: option<'a> => t<'a>
-```
-
-Maps `option('a)` to `Js.undefined('a)`.
-`Some(a)` => `a`
-`None` => `empty`
-
-## from_opt
-
-```res sig
-let from_opt: option<'a> => t<'a>
-```
-
-## toOption
-
-```res sig
-let toOption: t<'a> => option<'a>
-```
-
-Maps `Js.undefined('a)` to `option('a)`
-`a` => `Some(a)`
-`empty` => `None`
-
-## to_opt
-
-```res sig
-let to_opt: t<'a> => option<'a>
-```
diff --git a/pages/docs/manual/v9.0.0/api/js/vector.mdx b/pages/docs/manual/v9.0.0/api/js/vector.mdx
deleted file mode 100644
index cefea9a87..000000000
--- a/pages/docs/manual/v9.0.0/api/js/vector.mdx
+++ /dev/null
@@ -1,157 +0,0 @@
-# Vector
-
-<Intro>
-
-Provide vector utilities.
-
-</Intro>
-
-## t
-
-```res prelude
-type t<'a> = array<'a>
-```
-
-## filterInPlace
-
-```res sig
-let filterInPlace: ((. 'a) => bool, t<'a>) => unit
-```
-
-p : predicate
-a : array
-
-## empty
-
-```res sig
-let empty: t<'a> => unit
-```
-
-## pushBack
-
-```res sig
-let pushBack: ('a, t<'a>) => unit
-```
-
-## copy
-
-```res sig
-let copy: t<'a> => t<'a>
-```
-
-Create a shallow copy of a vector.
-
-## memByRef
-
-```res sig
-let memByRef: ('a, t<'a>) => bool
-```
-
-Find by JS (===) equality.
-
-## iter
-
-```res sig
-let iter: ((. 'a) => unit, t<'a>) => unit
-```
-
-## iteri
-
-```res sig
-let iteri: ((. int, 'a) => unit, t<'a>) => unit
-```
-
-## toList
-
-```res sig
-let toList: t<'a> => list<'a>
-```
-
-## map
-
-```res sig
-let map: ((. 'a) => 'b, t<'a>) => t<'b>
-```
-
-## mapi
-
-```res sig
-let mapi: ((. int, 'a) => 'b, t<'a>) => t<'b>
-```
-
-## foldLeft
-
-```res sig
-let foldLeft: ((. 'a, 'b) => 'a, 'a, t<'b>) => 'a
-```
-
-## foldRight
-
-```res sig
-let foldRight: ((. 'b, 'a) => 'a, t<'b>, 'a) => 'a
-```
-
-## length
-
-```res sig
-let length: t<'a> => int
-```
-
-Return the length (number of elements) of the given array.
-
-## get
-
-```res sig
-let get: (t<'a>, int) => 'a
-```
-
-`Vector.get(a, n)` returns the element number `n` of vector `a`. The first element has number 0. The last element has number `Vector.length(a) - 1`. You can also write `a[n]` instead of `Vector.get(a, n)`.
-Raise `Invalid_argument "index out of bounds"` if `n` is outside the range 0 to (`Array.length(a) - 1`).
-
-## set
-
-```res sig
-let set: (t<'a>, int, 'a) => unit
-```
-
-`Vector.set(a, n, x)` modifies vector `a` in place, replacing element number `n` with `x`.
-Raise `Invalid_argument "index out of bounds"` if `n` is outside the range 0 to `Array.length(a) - 1`.
-
-## make
-
-```res sig
-let make: (int, 'a) => t<'a>
-```
-
-`Vector.make(n, x)` returns a fresh vector of length `n`, initialized with `x`. All the elements of this new vector are initially physically equal to `x` (in the sense of the `==` predicate).
-Consequently, if `x` is mutable, it is shared among all elements of the array, and modifying `x` through one of the array entries will modify all other entries at the same time.
-Raise `Invalid_argument` if `n < 0` or `n > Sys.max_array_length`. If the value of `x` is a floating-point number, then the maximum size is only `Sys.max_array_length / 2`.
-
-## init
-
-```res sig
-let init: (int, (. int) => 'a) => t<'a>
-```
-
-Raises `RangeError` when n is negative.
-n : size
-
-## append
-
-```res sig
-let append: ('a, t<'a>) => t<'a>
-```
-
-`append(x, a)` returns a fresh vector with `x` appended to `a`.
-
-## unsafe_get
-
-```res sig
-let unsafe_get: (t<'a>, int) => 'a
-```
-
-## unsafe_set
-
-```res sig
-let unsafe_set: (t<'a>, int, 'a) => unit
-```
diff --git a/pages/docs/manual/v9.0.0/array-and-list.mdx b/pages/docs/manual/v9.0.0/array-and-list.mdx
deleted file mode 100644
index 143b60479..000000000
--- a/pages/docs/manual/v9.0.0/array-and-list.mdx
+++ /dev/null
@@ -1,149 +0,0 @@
----
-title: "Array & List"
-description: "Arrays and List data structures"
-canonical: "/docs/manual/latest/array-and-list"
----
-
-# Array and List
-
-## Array
-
-Arrays are our main ordered data structure. They work the same way as JavaScript arrays: they can be randomly accessed, dynamically resized, updated, etc.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myArray = ["hello", "world", "how are you"]
-```
-```js
-var myArray = ["hello", "world", "how are you"];
-```
-
-</CodeTab>
-
-ReScript arrays' items must have the same type, i.e. homogeneous.
-
-### Usage
-
-See the [Js.Array](api/js/array) API.
-
-Access & update an array item like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myArray = ["hello", "world", "how are you"]
-
-let firstItem = myArray[0] // "hello"
-
-myArray[0] = "hey" // now ["hey", "world", "how are you"]
-
-let pushedValue = Js.Array2.push(myArray, "bye")
-```
-```js
-var myArray = ["hello", "world", "how are you"];
-
-var firstItem = myArray[0];
-
-myArray[0] = "hey";
-
-var pushedValue = myArray.push("bye");
-```
-
-</CodeTab>
-
-## List
-
-ReScript provides a singly linked list too. Lists are:
-
-- immutable
-- fast at prepending items
-- fast at getting the tail
-- slow at everything else
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myList = list{1, 2, 3}
-```
-```js
-var myList = {
-  hd: 1,
-  tl: {
-    hd: 2,
-    tl: {
-      hd: 3,
-      tl: 0
-    }
-  }
-};
-```
-
-</CodeTab>
-
-Like arrays, lists' items need to be of the same type.
-
-### Usage
-
-You'd use list for its resizability, its fast prepend (adding at the head), and its fast split, all of which are immutable and relatively efficient.
-
-Do **not** use list if you need to randomly access an item or insert at non-head position. Your code would end up obtuse and/or slow.
-
-The standard lib provides a [List module](api/belt/list).
-
-#### Immutable Prepend
-
-Use the spread syntax:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let myList = list{1, 2, 3}
-let anotherList = list{0, ...myList}
-```
-```js
-var myList = {
-  hd: 1,
-  tl: {
-    hd: 2,
-    tl: {
-      hd: 3,
-      tl: 0
-    }
-  }
-};
-
-var anotherList = {
-  hd: 0,
-  tl: myList
-};
-```
-
-</CodeTab>
-
-`myList` didn't mutate. `anotherList` is now `list{0, 1, 2, 3}`. This is efficient (constant time, not linear). `anotherList`'s last 3 elements are shared with `myList`!
-
-**Note that `list{a, ...b, ...c}` is a syntax error**. We don't support multiple spread for a list. That'd be an accidental linear operation (`O(b)`), since each item of b would be one-by-one added to the head of `c`. You can use `List.concat` for this, but we highly discourage it.
-
-Updating an arbitrary item in the middle of a list is also discouraged, since its performance and allocation overhead would be linear (`O(n)`).
-
-#### Access
-
-`switch` (described in the [pattern matching section](pattern-matching-destructuring.md)) is usually used to access list items:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let message =
-  switch myList {
-  | list{} => "This list is empty"
-  | list{a, ...rest} => "The head of the list is the string " ++ Js.Int.toString(a)
-  }
-```
-```js
-var message = myList
-  ? "The head of the list is the string " + (1).toString()
-  : "This list is empty";
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v9.0.0/attribute.mdx b/pages/docs/manual/v9.0.0/attribute.mdx
deleted file mode 100644
index 07024c568..000000000
--- a/pages/docs/manual/v9.0.0/attribute.mdx
+++ /dev/null
@@ -1,86 +0,0 @@
----
-title: "Attribute (Decorator)"
-description: "Annotations in ReScript"
-canonical: "/docs/manual/latest/attribute"
----
-
-# Attribute (Decorator)
-
-Like many other languages, ReScript allows annotating a piece of code to express extra functionality. Here's an example:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@inline
-let mode = "dev"
-
-let mode2 = mode
-```
-```js
-var mode2 = "dev";
-```
-
-</CodeTab>
-
-The `@inline` annotation tells `mode`'s value to be inlined into its usage sites (see output). We call such annotation "attribute" (or "decorator" in JavaScript).
-
-An attribute starts with `@` and goes before the item it annotates. In the above example, it's hooked onto the let binding.
-
-## Usage
-
-> **Note:** In previous versions (< 8.3) all our interop related attributes started with a `bs.` prefix (`bs.module`, `bs.val`). Our formatter will automatically drop them in newer ReScript versions.
-
-You can put an attribute almost anywhere. You can even add extra data to them by using them visually like a function call. Here are a few famous attributes (explained in other sections):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@@warning("-27")
-
-
-@unboxed
-type a = Name(string)
-
-@val external message: string = "message"
-
-type student = {
-  age: int,
-  @as("aria-label") ariaLabel: string,
-}
-
-@deprecated
-let customDouble = foo => foo * 2
-
-@deprecated("Use SomeOther.customTriple instead")
-let customTriple = foo => foo * 3 
-```
-```js
-```
-
-</CodeTab>
-
-1. `@@warning("-27")` is a standalone attribute that annotates the entire file. Those attributes start with `@@`. Here, it carries the data `"-27"`.
-2. `@unboxed` annotates the type definition.
-3. `@val` annotates the `external` statement.
-4. `@as("aria-label")` annotates the `ariaLabel` record field.
-5. `@deprecated` annotates the `customDouble` expression. This shows a warning while compiling telling consumers to not rely on this method long-term.
-6. `@deprecated("Use SomeOther.customTriple instead")` annotates the `customTriple` expression with a string to describe the reason for deprecation.
-
-## Extension Point
-
-There's a second category of attributes, called "extension points" (a remnant term of our early systems):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-%raw("var a = 1")
-```
-```js
-var a = 1
-```
-
-</CodeTab>
-
-Extension points are attributes that don't _annotate_ an item; they _are_ the item. Usually they serve as placeholders for the compiler to implicitly substitute them with another item.
-
-Extension points start with `%`. A standalone extension point (akin to a standalone regular attribute) starts with `%%`.
diff --git a/pages/docs/manual/v9.0.0/bind-to-global-js-values.mdx b/pages/docs/manual/v9.0.0/bind-to-global-js-values.mdx
deleted file mode 100644
index 65038f1bf..000000000
--- a/pages/docs/manual/v9.0.0/bind-to-global-js-values.mdx
+++ /dev/null
@@ -1,145 +0,0 @@
----
-title: "Bind to Global JS Values"
-description: "JS interop with global JS values in ReScript"
-canonical: "/docs/manual/latest/bind-to-global-js-values"
----
-
-# Bind to Global JS Values
-
-**First**, make sure the value you'd like to model doesn't already exist in our [provided API](api/js).
-
-Some JS values, like `setTimeout`, live in the global scope. You can bind to them like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external setTimeout: (unit => unit, int) => float = "setTimeout"
-@val external clearTimeout: float => unit = "clearTimeout"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-(We already provide `setTimeout`, `clearTimeout` and others in the [Js.Global](api/js/global) module).
-
-This binds to the JavaScript [`setTimeout`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrworkerGlobalScope/setTimeout) methods and the corresponding `clearTimeout`. The `external`'s type annotation specifies that `setTimeout`:
-
-- Takes a function that accepts `unit` and returns `unit` (which on the JS side turns into a function that accepts nothing and returns nothing aka `undefined`),
-- and an integer that specifies the duration before calling said function,
-- returns a number that is the timeout's ID. This number might be big, so we're modeling it as a float rather than the 32-bit int.
-
-### Tips & Tricks
-
-**The above isn't ideal**. See how `setTimeout` returns a `float` and `clearTimeout` accepts one. There's no guarantee that you're passing the float created by `setTimeout` into `clearTimeout`! For all we know, someone might pass it `Math.random()` into the latter.
-
-We're in a language with a great type system now! Let's leverage a popular feature to solve this problem: abstract types.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type timerId
-@val external setTimeout: (unit => unit, int) => timerId = "setTimeout"
-@val external clearTimeout: timerId => unit = "clearTimeout"
-
-let id = setTimeout(() => Js.log("hello"), 100)
-clearTimeout(id)
-```
-```js
-var id = setTimeout(function (param) {
-  console.log("hello");
-}, 100);
-
-clearTimeout(id);
-```
-
-</CodeTab>
-
-Clearly, `timerId` is a type that can only be created by `setTimeout`! Now we've guaranteed that `clearTimeout` _will_ be passed a valid ID. Whether it's a number under the hood is now a mere implementation detail.
-
-Since `external`s are inlined, we end up with JS output as readable as hand-written JS.
-
-## Global Modules
-
-If you want to bind to a value inside a global module, e.g. `Math.random`, attach a `scope` to your `val` external:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@scope("Math") @val external random: unit => float = "random"
-let someNumber = random()
-```
-```js
-var someNumber = Math.random();
-```
-
-</CodeTab>
-
-you can bind to an arbitrarily deep object by passing a tuple to `scope`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val @scope(("window", "location", "ancestorOrigins"))
-external length: int = "length"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-This binds to `window.location.ancestorOrigins.length`.
-
-## Special Global Values
-
-Global values like `__filename` and `__DEV__` don't always exist; you can't even model them as an `option`, since the mere act of referring to them in ReScript (then compiled into JS) would trigger the usual `Uncaught ReferenceError: __filename is not defined` error in e.g. the browser environment.
-
-For these troublesome global values, ReScript provides a special approach: `%external(a_single_identifier)`.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch %external(__DEV__) {
-| Some(_) => Js.log("dev mode")
-| None => Js.log("production mode")
-}
-```
-```js
-var match = typeof __DEV__ === "undefined" ? undefined : __DEV__;
-
-if (match !== undefined) {
-  console.log("dev mode");
-} else {
-  console.log("production mode");
-}
-```
-
-</CodeTab>
-
-That first line's `typeof` check won't trigger a JS ReferenceError.
-
-Another example:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch %external(__filename) {
-| Some(f) => Js.log(f)
-| None => Js.log("non-node environment")
-};
-```
-```js
-var match = typeof (__filename) === "undefined" ? undefined : (__filename);
-
-if (match !== undefined) {
-  console.log(match);
-} else {
-  console.log("non-node environment");
-}
-```
-
-</CodeTab>
-
-<!-- TODO: revamp this page. Not good. Tell to use globalThis["foo"], and look in our stdlib -->
diff --git a/pages/docs/manual/v9.0.0/bind-to-js-function.mdx b/pages/docs/manual/v9.0.0/bind-to-js-function.mdx
deleted file mode 100644
index 303781bdf..000000000
--- a/pages/docs/manual/v9.0.0/bind-to-js-function.mdx
+++ /dev/null
@@ -1,463 +0,0 @@
----
-title: "Bind to JS Function"
-description: "JS interop with functions in ReScript"
-canonical: "/docs/manual/latest/bind-to-js-function"
----
-
-# Function
-
-Binding a JS function is like binding any other value:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// Import nodejs' path.dirname
-@module("path") external dirname: string => string = "dirname"
-let root = dirname("/User/github") // returns "User"
-```
-```js
-var Path = require("path");
-var root = Path.dirname("/User/github");
-```
-
-</CodeTab>
-
-We also expose a few special features, described below.
-
-## Labeled Arguments
-
-ReScript has [labeled arguments](function.md#labeled-arguments) (that can also be optional). These work on an `external` too! You'd use them to _fix_ a JS function's unclear usage. Assuming we're modeling this:
-
-```js
-// MyGame.js
-
-function draw(x, y, border) {
-   // suppose `border` is optional and defaults to false
-}
-draw(10, 20)
-draw(20, 20, true)
-```
-
-It'd be nice if on ReScript's side, we can bind & call `draw` while labeling things a bit:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("MyGame")
-external draw: (~x: int, ~y: int, ~border: bool=?, unit) => unit = "draw"
-
-draw(~x=10, ~y=20, ~border=true, ())
-draw(~x=10, ~y=20, ())
-```
-```js
-var MyGame = require("MyGame");
-
-MyGame.draw(10, 20, true);
-MyGame.draw(10, 20, undefined);
-```
-
-</CodeTab>
-
-We've compiled to the same function, but now the usage is much clearer on the ReScript side thanks to labels!
-
-**Note**: in this particular case, you need a unit, `()` after `border`, since `border` is an [optional argument at the last position](function.md#optional-labeled-arguments). Not having a unit to indicate you've finished applying the function would generate a warning.
-
-Note that you can freely reorder the labels on the ReScript side; they'll always correctly appear in their declaration order in the JavaScript output:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("MyGame")
-external draw: (~x: int, ~y: int, ~border: bool=?, unit) => unit = "draw"
-
-draw(~x=10, ~y=20, ())
-draw(~y=20, ~x=10, ())
-```
-```js
-var MyGame = require("MyGame");
-
-MyGame.draw(10, 20, undefined);
-MyGame.draw(10, 20, undefined);
-```
-
-</CodeTab>
-
-## Object Method
-
-Functions attached to JS objects (other than JS modules) require a special way of binding to them, using `send`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type document // abstract type for a document object
-@send external getElementById: (document, string) => Dom.element = "getElementById"
-@val external doc: document = "document"
-
-let el = getElementById(doc, "myId")
-```
-```js
-var el = document.getElementById("myId");
-```
-
-</CodeTab>
-
-In a `send`, the object is always the first argument. Actual arguments of the method follow (this is a bit what modern OOP objects are really).
-
-### Chaining
-
-Ever used `foo().bar().baz()` chaining ("fluent api") in JS OOP? We can model that in ReScript too, through the [pipe operator](pipe.md).
-
-## Variadic Function Arguments
-
-You might have JS functions that take an arbitrary amount of arguments. ReScript supports modeling those, under the condition that the arbitrary arguments part is homogenous (aka of the same type). If so, add `variadic` to your `external`.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("path") @variadic
-external join: array<string> => string = "join"
-
-let v = join(["a", "b"])
-```
-```js
-var Path = require("path");
-var v = Path.join("a", "b");
-```
-
-</CodeTab>
-
-`module` will be explained in [Import from/Export to JS](import-from-export-to-js.md).
-
-## Modeling Polymorphic Function
-
-Apart from the above special-case, JS function in general are often arbitrary overloaded in terms of argument types and number. How would you bind to those?
-
-### Trick 1: Multiple `external`s
-
-If you can exhaustively enumerate the many forms an overloaded JS function can take, simply bind to each differently:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("MyGame") external drawCat: unit => unit = "draw"
-@module("MyGame") external drawDog: (~giveName: string) => unit = "draw"
-@module("MyGame") external draw: (string, ~useRandomAnimal: bool) => unit = "draw"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Note how all three externals bind to the same JS function, `draw`.
-
-### Trick 2: Polymorphic Variant + `unwrap`
-
-If you have the irresistible urge of saying "if only this JS function argument was a variant instead of informally being either `string` or `int`", then good news: we do provide such `external` features through annotating a parameter as a polymorphic variant! Assuming you have the following JS function you'd like to bind to:
-
-```js
-function padLeft(value, padding) {
-  if (typeof padding === "number") {
-    return Array(padding + 1).join(" ") + value;
-  }
-  if (typeof padding === "string") {
-    return padding + value;
-  }
-  throw new Error(`Expected string or number, got '${padding}'.`);
-}
-```
-
-Here, `padding` is really conceptually a variant. Let's model it as such.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val
-external padLeft: (
-  string,
-  @unwrap [
-    | #Str(string)
-    | #Int(int)
-  ])
-  => string = "padLeft"
-padLeft("Hello World", #Int(4))
-padLeft("Hello World", #Str("Message from ReScript: "))
-```
-```js
-padLeft("Hello World", 4);
-padLeft("Hello World", "Message from ReScript: ");
-```
-
-</CodeTab>
-
-Obviously, the JS side couldn't have an argument that's a polymorphic variant! But here, we're just piggy backing on poly variants' type checking and syntax. The secret is the `@unwrap` annotation on the type. It strips the variant constructors and compile to just the payload's value. See the output.
-
-## Constrain Arguments Better
-
-Consider the Node `fs.readFileSync`'s second argument. It can take a string, but really only a defined set: `"ascii"`, `"utf8"`, etc. You can still bind it as a string, but we can use poly variants + `string` to ensure that our usage's more correct:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("fs")
-external readFileSync: (
-  ~name: string,
-  @string [
-    | #utf8
-    | @as("ascii") #useAscii
-  ],
-) => string = "readFileSync"
-
-readFileSync(~name="xx.txt", #useAscii)
-```
-```js
-var Fs = require("fs");
-Fs.readFileSync("xx.txt", "ascii");
-```
-
-</CodeTab>
-
-- Attaching `@string` to the whole poly variant type makes its constructor compile to a string of the same name.
-- Attaching a `@as("bla")` to a constructor lets you customize the final string.
-
-And now, passing something like `"myOwnUnicode"` or other variant constructor names to `readFileSync` would correctly error.
-
-Aside from string, you can also compile an argument to an int, using `int` instead of `string` in a similar way:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val
-external testIntType: (
-  @int [
-    | #onClosed
-    | @as(20) #onOpen
-    | #inBinary
-  ])
-  => int = "testIntType"
-testIntType(#inBinary)
-```
-```js
-testIntType(21);
-```
-
-</CodeTab>
-
-`onClosed` compiles to `0`, `onOpen` to `20` and `inBinary` to **`21`**.
-
-## Special-case: Event Listeners
-
-One last trick with polymorphic variants:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type readline
-
-@send
-external on: (
-    readline,
-    @string [
-      | #close(unit => unit)
-      | #line(string => unit)
-    ]
-  )
-  => readline = "on"
-
-let register = rl =>
-  rl
-  ->on(#close(event => ()))
-  ->on(#line(line => Js.log(line)));
-```
-```js
-function register(rl) {
-  return rl
-    .on("close", function($$event) {})
-    .on("line", function(line) {
-      console.log(line);
-    });
-}
-```
-
-</CodeTab>
-
-<!-- TODO: GADT phantom type -->
-
-## Fixed Arguments
-
-Sometimes it's convenient to bind to a function using an `external`, while passing predetermined argument values to the JS function:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val
-external processOnExit: (
-  @as("exit") _,
-  int => unit
-) => unit = "process.on"
-
-processOnExit(exitCode =>
-  Js.log("error code: " ++ Js.Int.toString(exitCode))
-);
-```
-```js
-process.on("exit", function (exitCode) {
-  console.log("error code: " + exitCode.toString());
-});
-```
-
-</CodeTab>
-
-The `@as("exit")` and the placeholder `_` argument together indicates that you want the first argument to compile to the string `"exit"`. You can also use any JSON literal with `as`: `` @as(json`true`) ``, `` @as(json`{"name": "John"}`) ``, etc.
-
-## Curry & Uncurry
-
-Curry is a delicious Indian dish. More importantly, in the context of ReScript (and functional programming in general), currying means that function taking multiple arguments can be applied a few arguments at time, until all the arguments are applied.
-
-See the `addFive` intermediate function? `add` takes in 3 arguments but received only 1. It's interpreted as "currying" the argument `5` and waiting for the next 2 arguments to be applied later on. Type signatures:
-
-```res sig
-let add: (int, int, int) => int
-let addFive: (int, int) => int
-let twelve: int
-```
-
-(In a dynamic language such as JS, currying would be dangerous, since accidentally forgetting to pass an argument doesn't error at compile time).
-
-### Drawback
-
-Unfortunately, due to JS not having currying because of the aforementioned reason, it's hard for ReScript multi-argument functions to map cleanly to JS functions 100% of the time:
-
-1. When all the arguments of a function are supplied (aka no currying), ReScript does its best to to compile e.g. a 3-arguments call into a plain JS call with 3 arguments.
-
-2. If it's too hard to detect whether a function application is complete\*, ReScript will use a runtime mechanism (the `Curry` module) to curry as many args as we can and check whether the result is fully applied.
-
-3. Some JS APIs like `throttle`, `debounce` and `promise` might mess with context, aka use the function `bind` mechanism, carry around `this`, etc. Such implementation clashes with the previous currying logic.
-
-\* If the call site is typed as having 3 arguments, we sometimes don't know whether it's a function that's being curried, or if the original one indeed has only 3 arguments.
-
-ReScript tries to do #1 as much as it can. Even when it bails and uses #2's currying mechanism, it's usually harmless.
-
-**However**, if you encounter #3, heuristics are not good enough: you need a guaranteed way of fully applying a function, without intermediate currying steps. We provide such guarantee through the use of the ["uncurrying" syntax](./function#uncurried-function) on a function declaration & call site.
-
-### Solution: Use Guaranteed Uncurrying
-
-[Uncurried function](function.md#uncurried-function) annotation also works on `external`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type timerId
-@val external setTimeout: ((. unit) => unit, int) => timerId = "setTimeout"
-
-let id = setTimeout((.) => Js.log("hello"), 1000)
-```
-```js
-var id = setTimeout(function () {
-  console.log("hello");
-}, 1000);
-```
-
-</CodeTab>
-
-#### Extra Solution
-
-The above solution is safe, guaranteed, and performant, but sometimes visually a little burdensome. We provide an alternative solution if:
-
-- you're using `external`
-- the `external` function takes in an argument that's another function
-- you want the user **not** to need to annotate the call sites with the dot
-
-<!-- TODO: is this up-to-date info? -->
-
-Then try `@uncurry`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@send external map: (array<'a>, @uncurry ('a => 'b)) => array<'b> = "map"
-map([1, 2, 3], x => x + 1)
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-In general, `uncurry` is recommended; the compiler will do lots of optimizations to resolve the currying to uncurrying at compile time. However, there are some cases the compiler can't optimize it. In these cases, it will be converted to a runtime check.
-
-## Modeling `this`-based Callbacks
-
-Many JS libraries have callbacks which rely on this (the source), for example:
-
-```js
-x.onload = function(v) {
-  console.log(this.response + v)
-}
-```
-
-Here, `this` would point to `x` (actually, it depends on how `onload` is called, but we digress). It's not correct to declare `x.onload` of type `(. unit) -> unit`. Instead, we introduced a special attribute, `this`, which allows us to type `x` as so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type x
-@val external x: x = "x"
-@set external setOnload: (x, @this ((x, int) => unit)) => unit = "onload"
-@get external resp: x => int = "response"
-setOnload(x, @this ((o, v) => Js.log(resp(o) + v)))
-```
-```js
-x.onload = function (v) {
-  var o = this;
-  console.log((o.response + v) | 0);
-};
-```
-
-</CodeTab>
-
-`this` has its first parameter is reserved for `this` and for arity of 0, there is no need for a redundant `unit` type.
-
-## Function Nullable Return Value Wrapping
-
-For JS functions that return a value that can also be `undefined` or `null`, we provide `@return(...)`. To automatically convert that value to an `option` type (recall that ReScript `option` type's `None` value only compiles to `undefined` and not `null`).
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type element
-type dom
-
-@send @return(nullable)
-external getElementById: (dom, string) => option<element> = "getElementById"
-
-let test = dom => {
-  let elem = dom->(getElementById("haha"))
-  switch (elem) {
-  | None => 1
-  | Some(_ui) => 2
-  }
-}
-```
-```js
-function test(dom) {
-  var elem = dom.getElementById("haha");
-  if (elem == null) {
-    return 1;
-  } else {
-    console.log(elem);
-    return 2;
-  }
-}
-
-```
-
-</CodeTab>
-
-`return(nullable)` attribute will automatically convert `null` and `undefined` to `option` type.
-
-Currently 4 directives are supported: `null_to_opt`, `undefined_to_opt`, `nullable` and `identity`.
-
-<!-- When the return type is unit: the compiler will append its return value with an OCaml unit literal to make sure it does return unit. Its main purpose is to make the user consume FFI in idiomatic OCaml code, the cost is very very small and the compiler will do smart optimizations to remove it when the returned value is not used (mostly likely). -->
-
-`identity` will make sure that compiler will do nothing about the returned value. It is rarely used, but introduced here for debugging purpose.
diff --git a/pages/docs/manual/v9.0.0/bind-to-js-object.mdx b/pages/docs/manual/v9.0.0/bind-to-js-object.mdx
deleted file mode 100644
index 5b46f0c5c..000000000
--- a/pages/docs/manual/v9.0.0/bind-to-js-object.mdx
+++ /dev/null
@@ -1,153 +0,0 @@
----
-title: "Bind to JS Object"
-description: "Interop with JS objects in ReScript"
-canonical: "/docs/manual/latest/bind-to-js-object"
----
-
-# Bind to JS Object
-
-JavaScript objects are a combination of several use-cases:
-
-- As a "record" or "struct" in other languages (like ReScript and C).
-- As a hash map.
-- As a class.
-- As a module to import/export.
-
-ReScript cleanly separates the binding methods for JS object based on these 4 use-cases. This page documents the first three. Binding to JS module objects is described in the [Import from/Export to JS](import-from-export-to-js.md) section.
-
-<!-- TODO: mention scope here too? -->
-
-## Bind to Record-like JS Objects
-
-### Bind Using ReScript Record
-
-If your JavaScript object has fixed fields, then it's conceptually like a ReScript record. Since a ReScript record compiles to a clean JavaScript object, you can definitely type a JS object as a ReScript record!
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type person = {
-  name: string,
-  friends: array<string>,
-  age: int,
-}
-
-@module("MySchool") external john: person = "john"
-
-let johnName = john.name
-```
-```js
-var MySchool = require("MySchool");
-
-var johnName = MySchool.john.name;
-```
-
-</CodeTab>
-
-External is documented [here](external.md). `@module` is documented [here](import-from-export-to-js.md).
-
-### Bind Using ReScript Object
-
-Alternatively, you can use [ReScript object](object.md) to model a JS object too:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type person = {
-  "name": string,
-  "friends": array<string>,
-  "age": int,
-}
-
-@module("MySchool") external john: person = "john"
-
-let johnName = john["name"]
-```
-```js
-var MySchool = require("MySchool");
-
-var johnName = MySchool.john.name;
-```
-
-</CodeTab>
-
-### Bind Using Special Getter and Setter Attributes
-
-Alternatively, you can use `get` and `set` to bind to individual fields of a JS object:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type textarea
-@set external setName: (textarea, string) => unit = "name"
-@get external getName: textarea => string = "name"
-```
-```js
-```
-
-</CodeTab>
-
-You can also use `get_index` and `set_index` to access a dynamic property or an index:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type t
-@new external create: int => t = "Int32Array"
-@get_index external get: (t, int) => int = ""
-@set_index external set: (t, int, int) => unit = ""
-
-let i32arr = create(3)
-i32arr->set(0, 42)
-Js.log(i32arr->get(0))
-```
-```js
-var i32arr = new Int32Array(3);
-i32arr[0] = 42;
-console.log(i32arr[0]);
-```
-
-</CodeTab>
-
-## Bind to Hash Map-like JS Object
-
-If your JavaScript object:
-
-- might or might not add/remove keys
-- contains only values that are of the same type
-
-Then it's not really an object, it's a hash map. Use [Js.Dict](api/js/dict), which contains operations like `get`, `set`, etc. and cleanly compiles to a JavaScript object still.
-
-## Bind to a JS Object That's a Class
-
-Use `new` to emulate e.g. `new Date()`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type t
-@new external createDate: unit => t = "Date"
-
-let date = createDate()
-```
-```js
-var date = new Date();
-```
-
-</CodeTab>
-
-You can chain `new` and `module` if the JS module you're importing is itself a class:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type t
-@new @module external book: unit => t = "Book"
-let myBook = book()
-```
-```js
-var Book = require("Book");
-var myBook = new Book();
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v9.0.0/browser-support-polyfills.mdx b/pages/docs/manual/v9.0.0/browser-support-polyfills.mdx
deleted file mode 100644
index c1de7a491..000000000
--- a/pages/docs/manual/v9.0.0/browser-support-polyfills.mdx
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: "Browser Support & Polyfills"
-description: "Note on browser support in ReScript"
-canonical: "/docs/manual/latest/browser-support-polyfills"
----
-
-# Browser Support & Polyfills
-
-ReScript compiles to JavaScript **ES5**, with the exception of optionally allowing to compile to ES6's module import & export.
-
-For [old browsers](https://caniuse.com/#search=typed%20array), you also need to polyfill TypedArray. The following standard library functions require it:
-
-- `Int64.float_of_bits`
-- `Int64.bits_of_float`
-- `Int32.float_of_bits`
-- `Int32.bits_of_float`
-
-If you don't use these functions, you're fine. Otherwise, it'll be a runtime failure.
diff --git a/pages/docs/manual/v9.0.0/build-configuration-schema.mdx b/pages/docs/manual/v9.0.0/build-configuration-schema.mdx
deleted file mode 100644
index 9dfe69b06..000000000
--- a/pages/docs/manual/v9.0.0/build-configuration-schema.mdx
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: "Configuration Schema"
-metaTitle: "Build System Configuration Schema"
-description: "Schema exploration widget for the ReScript configuration file"
-canonical: "/docs/manual/latest/build-configuration-schema"
----
-
-import dynamic from "next/dynamic";
-
-export const Docson = dynamic(
-  () =>
-    import("src/components/Docson").then((comp) => {
-      return comp.make;
-    }),
-  {
-    ssr: false,
-    loading: () => <div> Loading... </div>,
-  }
-);
-
-export default function BuildConfigurationSchemaPage() {
-  return <Docson tag="9.0.0" />;
-}
diff --git a/pages/docs/manual/v9.0.0/build-configuration.mdx b/pages/docs/manual/v9.0.0/build-configuration.mdx
deleted file mode 100644
index 8cf9d0f23..000000000
--- a/pages/docs/manual/v9.0.0/build-configuration.mdx
+++ /dev/null
@@ -1,196 +0,0 @@
----
-title: "Configuration"
-metaTitle: "Build System Configuration"
-description: "Details about the configuration of the ReScript build system (bsconfig.json)"
-canonical: "/docs/manual/latest/build-configuration"
----
-
-# Configuration
-
-`bsconfig.json` is the single, mandatory build meta file needed for bsb.
-
-**The complete configuration schema is [here](./build-configuration-schema)**. We'll _non-exhaustively_ highlight the important parts in prose below.
-
-## Tips & Tricks
-
-If you're using an editor like VSCode, put the following code as your first field in `bsconfig.json` to get schema autocompletion!
-
-```json
-"$schema": "https://raw.githubusercontent.com/rescript-lang/rescript/master/docs/docson/build-schema.json"
-```
-
-## name, namespace
-
-`name` is the name of the library, used as its "namespace". You can activate namespacing through `"namespace": true` in your `bsconfig.json`. Namespacing is almost **mandatory**; we haven't turned it on by default yet to preserve backward-compatibility.
-
-**Explanation**: by default, your files, once used as a third-party dependency, are available globally to the consumer. E.g. if you have an `Util.re` and the consumer also has a file of the same name, they will clash. Turning on `namespace` avoids this by wrapping all your own project's files into an extra module layer; instead of a global `Util` module, the consumer will see you as `MyProject.Util`. **The namespacing affects your consumers, not yourself**.
-
-Aka, in Bsb, "namespace" is just a fancy term for an auto-generated module that wraps all your project's files (efficiently and correctly, of course!) for third-party consumption.
-
-We don't do folder-level namespacing for your own project; all your own file names must be unique. This is a constraint that enables several features such as fast search and easier project reorganization.
-
-**Note**: the `bsconfig.json` `name` should be the same as the `package.json` `name`, to avoid confusing corner-cases. However, this means that you can't use a camelCased names such as `MyProject`, since `package.json` and npm forbid you to do so (some file systems are case-insensitive). To have the namespace/module as `MyProject`, write `"name": "my-project"`. Bsb will turn that into the camelCased name correctly.
-
-**Note on custom namespacing**: if for some reason, you need a namespace that is different from what your `name` will produce, you can directly send a string to the `namespace` option. For example, if your package is a binding named `bs-some-thing`, you can use `"namespace": "some-thing"` to get `SomeThing` namespace instead of `BsSomeThing`.
-
-## sources
-
-Your source files need to be specified explicitly (we don't want to accidentally drill down into some unrelated directories). Examples:
-
-```json
-{
-  "sources": ["src", "examples"]
-}
-```
-
-```json
-{
-  "sources": {
-    "dir": "src",
-    "subdirs": ["page"]
-  }
-}
-```
-
-```json
-{
-  "sources": [
-    "examples",
-    {
-      "dir": "src",
-      "subdirs": true // recursively builds every subdirectory
-    }
-  ]
-}
-```
-
-You can mark your directories as dev-only (for e.g. tests). These won't be built and exposed to third-parties, or even to other "dev" directories in the same project:
-
-```json
-{
-  "sources": {
-    "dir": "test",
-    "type": "dev"
-  }
-}
-```
-
-## bs-dependencies, bs-dev-dependencies
-
-List of ReScript dependencies. Just like `package.json`'s dependencies, they'll be searched in `node_modules`.
-
-Note that only sources marked with `"type":"dev"` will be able to resolve modules from `bs-dev-dependencies`.
-
-## pinned-dependencies
-
-**Since 8.4**: List of pinned dependencies. A pinned dependency will always be rebuilt whenever you build a toplevel package (e.g. your main app) with `bsb -make-world`.
-
-This is useful for working on multiple independent ReScript packages simultaneously. More usage details can be found in our dedicated [pinned dependencies](./build-pinned-dependencies) page.
-
-## external-stdlib
-
-**Since 9.0**: This setting allows depending on an externally built stdlib package (instead of a locally built stdlib runtime). Useful for shipping packages that are only consumed in JS or TS without any dependencies to the ReScript development toolchain.
-
-More details can be found on our [external stdlib](./build-external-stdlib) page.
-
-## reason, refmt (old)
-
-`reason` config is enabled by default. To turn on JSX for [ReasonReact](https://reasonml.github.io/reason-react/), specify:
-
-```json
-{
-  "reason": { "react-jsx": 3 },
-  "refmt": 3
-}
-```
-
-The `refmt` config **should be explicitly specified** as `3`.
-
-## js-post-build
-
-Hook that's invoked every time a file is recompiled. Good for JS build system interop, but please use it **sparingly**. Calling your custom command for every recompiled file slows down your build and worsens the building experience for even third-party users of your lib.
-
-Example:
-
-```json
-{
-  "js-post-build": {
-    "cmd": "/path/to/node ../../postProcessTheFile.js"
-  }
-}
-```
-
-Note that the path resolution for the command (`node` in this case) is done so:
-
-- `/myCommand` is resolved into `/myCommand`
-- `package/myCommand` is resolved into `node_modules/package/myCommand`
-- `./myCommand` is resolved into `myProjectRoot/myCommand`
-- `myCommand` is just called as `myCommand`, aka a globally available executable. But note that Bsb doesn't read into your shell's environment, so if you put e.g. `node`, it won't find it unless you specify an absolute path. Alternatively, add `#!/usr/local/bin/node` to the top of your script to directly call it without prepending `node`.
-
-The command itself is called from inside `lib/bs`.
-
-## package-specs
-
-Output to either CommonJS (the default) or ES6 modules. Example:
-
-```json
-{
-  "package-specs": {
-    "module": "commonjs",
-    "in-source": true
-  }
-}
-```
-
-- `"module": "es6-global"` resolves `node_modules` using relative paths. Good for development-time usage of ES6 in conjunction with browsers like Safari and Firefox that support ES6 modules today. **No more dev-time bundling**!
-- `"in-source": true` generates output alongside source files. If you omit it, it'll generate the artifacts into `lib/js`. The output directory is not configurable otherwise.
-
-This configuration only applies to you, when you develop the project. When the project is used as a third-party library, the consumer's own `bsconfig.json` `package-specs` overrides the configuration here, logically.
-
-## suffix
-
-Either `".js"`, `".mjs"`, `".cjs"` or `".bs.js"`. Currently prefer `bs.js` for now.
-
-### Design Decisions
-
-Generating JS files with the `.bs.js` suffix means that, on the JS side, you can do `const myReScriptFile = require('./theFile.bs')`. The benefits:
-
-- It's immediately clear that we're dealing with a generated JS file here.
-- It avoids clashes with a potential `theFile.js` file in the same folder.
-- It avoids the need of using a build system loader for ReScript files. This + in-source build means integrating a ReScript project into your pure JS codebase **basically doesn't touch anything in your build pipeline at all**.
-- [genType](/docs/manual/latest/typescript-integration) requires `bs.js` for compiled JS artifacts. If you are using `genType`, you need to use `bs.js` for now.
-
-## warnings
-
-Selectively turn on/off certain warnings and/or turn them into hard errors. Example:
-
-```json
-{
-  "warnings": {
-    "number": "-44-102",
-    "error": "+5"
-  }
-}
-```
-
-Turn off warning `44` and `102` (polymorphic comparison). Turn warning `5` (partial application whose result has function type and is ignored) into a hard error.
-
-The warning number are shown in the build output when they're triggered. The complete list is [here](https://caml.inria.fr/pub/docs/manual-ocaml/comp.html#sec281), a little bit below. `100` and up are ReScript-specific.
-
-## bsc-flags
-
-Extra flags to pass to the underlying `bsc` call. Notably: `["-bs-super-errors"]` for turning on cleaner error output. No need to pass this flag for a new ReScript project; it's enabled by default.
-
-## Environment Variables
-
-We heavily disrecommend the usage of environment variables, but for certain cases, they're justified.
-
-### Error Output Coloring: `NINJA_ANSI_FORCED`
-
-This is mostly for other programmatic usage of `bsb` where outputting colors is not desired.
-
-When `NINJA_ANSI_FORCED` is set to `1`: `bsb` produces color.
-When `NINJA_ANSI_FORCED` is set to `0`: `bsb` doesn't produce color.
-When `NINJA_ANSI_FORCED` is not set: `bsb` might or might not produce color, depending on a smart detection of where it's outputted.
-
-> Note that bsc, the barebone compiler, will always be passed `-color always`. See more details in [this issue](https://github.com/rescript-lang/rescript/issues/2984#issuecomment-410669163).
diff --git a/pages/docs/manual/v9.0.0/build-external-stdlib.mdx b/pages/docs/manual/v9.0.0/build-external-stdlib.mdx
deleted file mode 100644
index 835080157..000000000
--- a/pages/docs/manual/v9.0.0/build-external-stdlib.mdx
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: "External Stdlib"
-metaTitle: "External Stdlib"
-description: "Configuring an external ReScript stdlib package"
-canonical: "/docs/manual/latest/build-external-stdlib"
----
-
-# External Stdlib
-
-**Since 9.0**
-
-Your ReScript project depends on the `bs-platform` (soon `rescript`) package as a [`devDependency`](https://docs.npmjs.com/specifying-dependencies-and-devdependencies-in-a-package-json-file), which includes our compiler, build system and runtime like `Belt`. However, you had to move it to `dependency` in `package.json` if you publish your code:
-- To Docker or other low-storage deployment devices.
-- For pure JS/TS consumers who probably won't install `bs-platform` in their own project.
-
-In these cases, the size or mere presence of `bs-platform` can be troublesome, since it includes not just our necessary runtime like `Belt`, but also our compiler and build system.
-
-To solve that, we now publish our runtime as a standalone package at [`@rescript/std`](https://www.npmjs.com/package/@rescript/std), whose versions mirror `bs-platform`'s. Now you can keep `bs-platform` as a `devDependency` and have only `@rescript/std` as your runtime `dependency`.
-
-**This is an advanced feature**. Please only use it in the aforementioned scenarios. If you already use a JS bundler with dead code elimination, you might not need this feature.
-
-## Configuration
-
-Say you want to publish a JS-only ReScript 9.0 library. Install the packages like this:
-
-```sh
-npm install bs-platform@9.0.0 --save-dev
-npm install @rescript/std@9.0.0 --save
-```
-
-Then add this to `bsconfig.json`:
-
-```json
-{
-  // ...
-  "external-stdlib" : "@rescript/std"
-}
-```
-
-Now the compiled JS code will import using the path defined by `external-stdlib`. Check the JS output tab:
-
-<CodeTab labels={["ReScript", "JS output"]}>
-
-```res
-Belt.Array.forEach([1, 2, 3], num => Js.log(num))
-```
-
-```js
-// Note the require path starting with "@rescript/std".
-var Belt_Array = require("@rescript/std/lib/js/belt_Array.js");
-
-Belt_Array.forEach([1, 2, 3], function (num) {
-  console.log(num);
-});
-```
-
-</CodeTab>
-
-**Make sure the version number of `bs-platform` and `@rescript/std` match in your `package.json`** to avoid running into runtime issues due to mismatching stdlib assumptions.
diff --git a/pages/docs/manual/v9.0.0/build-overview.mdx b/pages/docs/manual/v9.0.0/build-overview.mdx
deleted file mode 100644
index 77f0d674a..000000000
--- a/pages/docs/manual/v9.0.0/build-overview.mdx
+++ /dev/null
@@ -1,47 +0,0 @@
----
-title: "Overview"
-metaTitle: "Build System Overview"
-description: "Documentation about the ReScript build system and its toolchain"
-canonical: "/docs/manual/latest/build-overview"
----
-
-# Build System Overview
-
-ReScript comes with a build system, bsb, that's meant to be fast, lean and used as the authoritative build system of the community.
-
-The build description file is called `bsconfig.json`. Every ReScript project needs one.
-
-## Build Project 
-
-Each build will create build artifacts from your project's source files.
-
-**To build a project (including its dependencies / pinned-dependencies)**, run:
-
-```sh
-bsb -make-world
-```
-
-Add `-w` to keep the built-in watcher running. Any new file change will be picked up and the build will re-run.
-
-**Note**: third-party libraries (in `node_modules`, or via `pinned-dependencies`) aren't watched, as doing so may exceed the node.js watcher count limit.
-
-**Note 2**: In case you want to set up a project in a JS-monorepo-esque approach (`yarn workspaces` / `lerna`) where changes in your sub packages should be noticed by the compiler (`bsb -make-world`), you will need to define pinned dependencies in your main project's `bsconfig.json`. More details [here](./build-pinned-dependencies).
-
-**To build only your project's files (without dependencies)**, run:
-
-
-```sh
-bsb
-```
-
-## Clean Project
-
-If you ever get into a stale build for edge-case reasons, use:
-
-```sh
-bsb -clean-world
-```
-
-This will clean all your project's build artifacts, including those in your dependencies. Alternatively you can run `bsb -clean` to clean your project's build artifacts only.
-
-For more infos, run `bsb -help` to see all the available options.
diff --git a/pages/docs/manual/v9.0.0/build-performance.mdx b/pages/docs/manual/v9.0.0/build-performance.mdx
deleted file mode 100644
index 3a5db7063..000000000
--- a/pages/docs/manual/v9.0.0/build-performance.mdx
+++ /dev/null
@@ -1,89 +0,0 @@
----
-title: "Performance"
-metaTitle: "Build Performance"
-description: "ReScript build performance and measuring tools"
-canonical: "/docs/manual/latest/build-performance"
----
-
-# Build Performance
-
-ReScript considers performance at install time, build time and run time as a serious feature. Here are some more info, and tips on keeping the build fast. **Feel free to skip this section** if you're just starting out.
-
-## Profile Your Build
-
-Sometime your build can be slow due to some confused infra setups. We provide an interactive visualization of your build's performance via `bstracing`:
-
-```sh
-./node_modules/.bin/bstracing
-```
-
-Run the above command at your ReScript project's root; it'll spit out a JSON file you can drag and drop into `chrome://tracing`.
-
-import Image from "src/components/Image";
-
-<Image withShadow={true} src="/static/img/bstracing.png" caption="Screenshot of bstracing result"/>
-
-## Under the Hood
-
-Bsb itself uses a build system under the hood, called [Ninja](https://ninja-build.org). Ninja is like Make, but cross-platform, minimal, focuses in perf and destined to be more of a low-level building block than a full-blown build system. In this regard, Ninja's a great implementation detail for bsb.
-
-Bsb reads into `bsconfig.json` and generates the Ninja build file in `lib/bs`. The file contains the low-level `bsc`-related commands, namespacing rules, intermediate artifacts generation & others. It then runs `ninja` for the actual build.
-
-## The JS Wrapper
-
-`bsb` itself is a Node.js wrapper which takes care of some miscellaneous tasks, plus the watcher. The lower-level, watcher-less, true `bsb` is called `bsb.exe`. It can be located in the same directory as where `bsb` is found:
-
-```sh
-> bsb -where
-/usr/local/lib/node_modules/bs-platform/lib
-```
-
-The path varies across systems.
-
-If you don't need the watcher, you can run said `bsb.exe`: `/usr/local/lib/node_modules/bs-platform/lib/bsb.exe`. This side-steps the node.js startup time, which can be big (in the order of `100ms`).
-
-## Numbers
-
-Raw `bsb.exe` build on a small project should be around `70ms`. This doubles when you use the more common `bsb` wrapper which comes with a watcher, which is practically faster since you don't manually run the build at every change (though you should opt for the raw `bsb.exe` for programmatic usage, e.g. inserting bsb into your existing JS build pipeline).
-
-No-op build (when no file's changed) should be around `15ms`. Incremental rebuild (described soon) of a single file in a project is around `70ms` too.
-
-Cleaning the artifacts should be instantaneous.
-
-### Extreme Test
-
-We've stress-tested bsb on a big project of 10,000 files (2 directories, 5000 files each, first 5000 no dependencies, last 5000 10 dependencies on files from the former directory) using https://github.com/ocaml-omake/omake/blob/perf-test/performance/generate.ml, on Retina Macbook Pro Early 2015 (3.1 GHz Intel Core i7).
-
-<!-- TODO: better repro -->
-
-- No-op build of 10k files: `800ms` (the minimum amount of time required to check the mtimes of 10k files).
-- Clean build: \<3 minutes.
-- Incremental build: depends on the number of the dependents of the file. No dependent means `1s`.
-
-Note that bsb is a file-based build system. We don't do in-memory build, even if that speeds up the build a lot. In-memory builds risk memory leaks, out-of-memory errors and others. The bsb watcher, on the other hand, can stay open for days.
-
-## Incrementality
-
-Bsb doesn't take whole seconds to run every time. The bulk of the build performance comes from incremental build, aka re-building a previously built project when a few files changed.
-
-In short, thanks to our bsc compiler and bsb build system's architecture, we're able to **only build what's needed**. E.g. if `MyFile.res` isn't changed, then it's not recompiled. You can roughly emulate such incrementality in languages like JavaScript, but the degree of correctness is unfortunately low. For example, if you rename or move a JS file, then the watcher might get confused and not pick up the "new" file or fail to clean things up correctly, resulting in you needing to clean your build and restart anew, which defeats the purpose.
-
-## Speed Up Incremental Build
-
-ReScript uses the concept of interface files (`.resi`) (or, equivalently, [module signatures](module.md#signatures)). Exposing only what you need naturally speeds up incremental builds. E.g. if you change a `.res` file whose corresponding `.resi` file doesn't expose the changed part, then you've reduced the amount of dependent files you have to rebuild.
-
-<!-- TODO: validate this -->
-
-## Programmatic Usage
-
-Unfortunately, JS build systems are usually the bottleneck for building a JS project nowadays. Having parts of the build blazingly fast doesn't matter much if the rest of the build takes seconds or literally minutes. Here are a few suggestions:
-
-- Convert more files into ReScript =). Fewer files going through fewer parts of the JS pipeline helps a ton.
-- Careful with bringing in more dependencies: libraries, syntax transforms, build step loaders, etc. The bulk of these dragging down the editing & building experience might out-weight the API benefits they provide.
-- Wait for us to create our own super fast linker (aka bundler).
-
-## Hot Reloading
-
-Hot reloading refers to maintaining a dev server and listening to file changes in a way that allows the server to pipe some delta changes right into the currently running browser page. This provides a relatively fast iteration workflow while working in specific frameworks.
-
-However, hot reloading is fragile by nature, and counts on the occasional inconsistencies (bad state, bad eval, etc.) and the heavy devserver setup/config being less of a hassle than the benefits it provides. We err on the side of caution and stability in general, and decided not to provide a built-in hot reloading _yet_. **Note**: you can still use the hot reloading facility provided by your JS build pipeline.
diff --git a/pages/docs/manual/v9.0.0/build-pinned-dependencies.mdx b/pages/docs/manual/v9.0.0/build-pinned-dependencies.mdx
deleted file mode 100644
index 941f0e083..000000000
--- a/pages/docs/manual/v9.0.0/build-pinned-dependencies.mdx
+++ /dev/null
@@ -1,114 +0,0 @@
----
-title: "Pinned Dependencies"
-metaTitle: "Pinned Dependencies"
-description: "Handling multiple packages within one ReScript project with pinned dependencies"
-canonical: "/docs/manual/latest/build-pinned-dependencies"
----
-
-# Pinned Dependencies
-
-**Since 8.4**
-
-Usually we'd recommend to use ReScript in a single-codebase style by using one `bsconfig.json` file for your whole codebase.
-
-There are scenarios where you still want to connect and build multiple independent ReScript packages for one main project though (`yarn workspaces`-like "monorepos"). This is where `pinned-dependencies` come into play.
-
-
-## Package Types
-
-Before we go into detail, let's first explain all the different package types recognized by the build system:
-
-- Toplevel (this is usually the final app you are building, which has dependencies to other packages)
-- Pinned dependencies (these are your local packages that should always rebuild when you build your toplevel, those should be listed in `bs-dependencies` and `pinned-dependencies`)
-- Normal dependencies (these are packages that are consumed from npm and listed via `bs-dependencies`)
-
-Whenever a package is being built (`bsb -make-world`), the build system will build the toplevel package with its pinned-dependencies. So any changes made in a pinned dependency will automatically be reflected in the final app.
-
-## Build System Package Rules
-
-The build system respects the following rules for each package type:
-
-**Toplevel**
-- Warnings reported
-- Warn-error respected
-- Builds dev dependencies
-- Builds pinned dependencies
-- Runs custom rules
-- Package-specs like ES6/CommonJS overrides all its dependencies
-
-**Pinned dependencies**
-- Warnings reported
-- Warn-error respected
-- Ignores pinned dependencies
-- Builds dev dependencies
-- Runs custom rules
-
-**Normal dependencies**
-- Warnings, warn-error ignored
-- Ignores dev directories
-- Ignores pinned dependencies
-- Ignores custom generator rules
-
-So with that knowledge in mind, let's dive into some more concrete examples to see our pinned dependencies in action.
-
-## Examples
-
-### Yarn workspaces
-
-Let's assume we have a codebase like this:
-
-```
-myproject/
-  app/
-   - src/App.res
-   - bsconfig.json
-  common/
-   - src/Header.res
-   - bsconfig.json
-  myplugin/
-   - src/MyPlugin.res
-   - bsconfig.json
-  package.json
-```
-
-Our `package.json` file within our codebase root would look like this:
-
-```json
-{
-  "name": "myproject",
-  "private": true,
-  "workspaces": {
-    "packages": [
-      "app",
-      "common",
-      "myplugin"
-    ]
-  }
-}
-```
-
-
-Our `app` folder would be our toplevel package, consuming our `common` and `myplugin` packages as `pinned-dependencies`. The configuration for `app/bsconfig.json` looks like this:
-
-```json
-{
-  "name": "app",
-  "version": "1.0.0",
-  "sources": {
-    "dir" : "src",
-    "subdirs" : true
-  },
-  /* ... */
-  "bs-dependencies": [
-    "common",
-    "myplugin"
-  ],
-  "pinned-dependencies": ["common", "myplugin"],
-  /* ... */
-}
-```
-
-Now, whenever we are running `npx bsb -make-world` within our `app` package, the compiler would always rebuild any changes within its pinned dependencies as well.
-
-**Important:** ReScript will not rebuild any `pinned-dependencies` in watch mode! This is due to the complexity of file watching, so you'd need to set up your own file-watcher process that runs `bsb -make-world` on specific file changes. E.g. you could use [`watchman-make`](https://facebook.github.io/watchman/docs/watchman-make.html) to automatically run the build task when a file in `common` or `myplugin` has been changed.
-
diff --git a/pages/docs/manual/v9.0.0/control-flow.mdx b/pages/docs/manual/v9.0.0/control-flow.mdx
deleted file mode 100644
index a7d391534..000000000
--- a/pages/docs/manual/v9.0.0/control-flow.mdx
+++ /dev/null
@@ -1,211 +0,0 @@
----
-title: "If-Else & Loops"
-description: "If, else, ternary, for, and while"
-canonical: "/docs/manual/latest/control-flow"
----
-
-# If-Else & Loops
-
-ReScript supports `if`, `else`, ternary expression (`a ? b : c`), `for` and `while`.
-
-ReScript also supports our famous pattern matching, which will be covered in [its own section](pattern-matching-destructuring.md)
-
-## If-Else & Ternary
-
-Unlike its JavaScript counterpart, ReScript's `if` is an expression; they evaluate to their body's content:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let message = if isMorning {
-  "Good morning!"
-} else {
-  "Hello!"
-}
-```
-```js
-var message = isMorning ? "Good morning!" : "Hello!";
-```
-
-</CodeTab>
-
-**Note:** an `if-else` expression without the final `else` branch implicitly gives `()` (aka the `unit` type). So this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-if showMenu {
-  displayMenu()
-}
-```
-```js
-if (showMenu) {
-  displayMenu();
-}
-```
-
-</CodeTab>
-
-is basically the same as:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-if showMenu {
-  displayMenu()
-} else {
-  ()
-}
-```
-```js
-if (showMenu) {
-  displayMenu()
-}
-```
-
-</CodeTab>
-
-Here's another way to look at it. This is clearly wrong:
-
-```res
-let result = if showMenu {
-  1 + 2
-}
-```
-
-It'll give a type error, saying basically that the implicit `else` branch has the type `unit` while the `if` branch has type `int`. Intuitively, this makes sense: what would `result`'s value be, if `showMenu` was `false`?
-
-We also have ternary sugar, but **we encourage you to prefer if-else when possible**.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let message = isMorning ? "Good morning!" : "Hello!"
-```
-```js
-var message = isMorning ? "Good morning!" : "Hello!";
-```
-
-</CodeTab>
-
-**`if-else` and ternary are much less used** in ReScript than in other languages; [Pattern-matching](pattern-matching-destructuring.md) kills a whole category of code that previously required conditionals.
-
-## For Loops
-
-For loops iterate from a starting value up to (and including) the ending value.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-for i in startValueInclusive to endValueInclusive {
-  Js.log(i)
-}
-```
-```js
-for(var i = startValueInclusive; i <= endValueInclusive; ++i){
-  console.log(i);
-}
-```
-
-</CodeTab>
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// prints: 1 2 3, one per line
-for x in 1 to 3 {
-  Js.log(x)
-}
-```
-```js
-for(var x = 1; x <= 3; ++x){
-  console.log(x);
-}
-```
-
-</CodeTab>
-
-You can make the `for` loop count in the opposite direction by using `downto`.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-for i in startValueInclusive downto endValueInclusive {
-  Js.log(i)
-}
-```
-```js
-for(var i = startValueInclusive; i >= endValueInclusive; --i){
-  console.log(i);
-}
-```
-
-</CodeTab>
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// prints: 3 2 1, one per line
-for x in 3 downto 1 {
-  Js.log(x)
-}
-```
-```js
-for(var x = 3; x >= 1; --x){
-  console.log(x);
-}
-```
-
-</CodeTab>
-
-## While Loops
-
-While loops execute its body code block while its condition is true.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-while testCondition {
-  // body here
-}
-```
-```js
-while (testCondition) {
-  // body here
-}
-```
-
-</CodeTab>
-
-### Tips & Tricks
-
-There's no loop-breaking `break` keyword (nor early `return` from functions, for that matter) in ReScript. However, we can break out of a while loop easily through using a [mutable binding](mutation.md).
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let break = ref(false)
-
-while !break.contents {
-  if Js.Math.random() > 0.3 {
-    break := true
-  } else {
-    Js.log("Still running")
-  }
-}
-```
-```js
-var $$break = {
-  contents: false
-};
-
-while(!$$break.contents) {
-  if (Math.random() > 0.3) {
-    $$break.contents = true;
-  } else {
-    console.log("Still running");
-  }
-};
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v9.0.0/converting-from-js.mdx b/pages/docs/manual/v9.0.0/converting-from-js.mdx
deleted file mode 100644
index 4d72fd941..000000000
--- a/pages/docs/manual/v9.0.0/converting-from-js.mdx
+++ /dev/null
@@ -1,305 +0,0 @@
----
-title: "Converting from JS"
-description: "How to convert to ReScript with an existing JS codebase"
-canonical: "/docs/manual/latest/converting-from-js"
----
-
-# Converting from JS
-
-ReScript offers a unique project conversion methodology which:
-- Ensures minimal disruption to your teammates (very important!).
-- Remove the typical friction of verifying conversion's correctness and performance guarantees.
-- Doesn't force you to search for pre-made binding libraries made by others. **ReScript doesn't need the equivalent of TypeScript's `DefinitelyTyped`**.
-
-Enjoy!
-
-## Step 1: Install ReScript
-
-Run `npm install --save-dev bs-platform` on your project, then imitate our [New Project](installation#new-project) workflow by adding a `bsconfig.json` at the root. Then start `bsb -w`.
-
-## Step 2: Copy Paste the Entire JS File
-
-Let's work on converting a file called `src/main.js`.
-
-```js
-const school = require('school');
-
-const defaultId = 10;
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-```
-
-First, copy the entire file content over to a new file called `src/Main.res` by using our [`%%raw` JS embedding trick](embed-raw-javascript):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-%%raw(`
-const school = require('school');
-
-const defaultId = 10;
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-`)
-```
-```js
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-const school = require('school');
-
-const defaultId = 10;
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-
-/*  Not a pure module */
-```
-
-</CodeTab>
-
-Add this file to `bsconfig.json`:
-
-```json
-  "sources": {
-    "dir" : "src",
-    "subdirs" : true
-  },
-```
-
-Open an editor tab for `src/Main.bs.js`. Do a command-line `diff -u src/main.js src/Main.bs.js`. Aside from whitespaces, you should see only minimal, trivial differences. You're already a third of the way done!
-
-**Always make sure** that at each step, you keep the ReScript output `.bs.js` file open to compare against the existing JavaScript file. Our compilation output is very close to your hand-written JavaScript; you can simply eye the difference to catch conversion bugs!
-
-## Step 3: Extract Parts into Idiomatic ReScript
-
-Let's turn the `defaultId` variable into a ReScript let-binding:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let defaultId = 10
-
-%%raw(`
-const school = require('school');
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return school.getStudentById(defaultId);
-  }
-}
-`)
-```
-```js
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-const school = require('school');
-
-function queryResult(usePayload, payload) {
-  if usePayload {
-    return payload.student
-  } else {
-    return school.getStudentById(defaultId)
-  }
-}
-
-var defaultId = 10;
-
-exports.defaultId = defaultId;
-/*  Not a pure module */
-```
-
-</CodeTab>
-
-Check the output. Diff it. Code still works. Moving on! Extract the function:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-%%raw(`
-const school = require('school');
-`)
-
-let defaultId = 10
-
-let queryResult = (usePayload, payload) => {
-  if usePayload {
-    payload.student
-  } else {
-    school.getStudentById(defaultId)
-  }
-}
-```
-```js
-```
-
-</CodeTab>
-
-Format the code: `./node_modules/.bin/bsc -format src/Main.res`.
-
-We have a type error: "The record field student can't be found". That's fine! **Always ensure your code is syntactically valid first**. Fixing type errors comes later.
-
-## Step 4: Add `external`s, Fix Types
-
-The previous type error is caused by `payload`'s record declaration (which supposedly contains the field `student`) not being found. Since we're trying to convert as quickly as possible, let's use our [object](object) feature to avoid needing type declaration ceremonies:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-%%raw(`
-const school = require('school');
-`)
-
-let defaultId = 10
-
-let queryResult = (usePayload, payload) => {
-  if usePayload {
-    payload["student"]
-  } else {
-    school["getStudentById"](defaultId)
-  }
-}
-```
-```js
-```
-
-</CodeTab>
-
-Now this triggers the next type error, that `school` isn't found. Let's use [`external`](external) to bind to that module:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@bs.module external school: 'whatever = "school"
-
-let defaultId = 10
-
-let queryResult = (usePayload, payload) => {
-  if usePayload {
-    payload["student"]
-  } else {
-    school["getStudentById"](defaultId)
-  }
-}
-```
-```js
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-var School = require("school");
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return School.getStudentById(10);
-  }
-}
-
-var defaultId = 10;
-
-exports.defaultId = defaultId;
-exports.queryResult = queryResult;
-/* school Not a pure module */
-```
-
-</CodeTab>
-
-We hurrily typed `school` as a polymorphic `'whatever` and let its type be inferred by its usage below. The inference is technically correct, but within the context of bringing it a value from JavaScript, slightly dangerous. This is just the interop trick we've shown in the [`external`](external) page.
-
-Anyway, the file passes the type checker again. Check the `.bs.js` output, diff with the original `.js`; we've now converted a file over to ReScript!
-
-Now, you can delete the original, hand-written `main.js` file, and grep the files importing `main.js` and change them to importing `Main.bs.js`.
-
-## (Optional) Step 5: Cleanup
-
-If you prefer more advanced, rigidly typed `payload` and `school`, feel free to do so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type school
-type student
-type payload = {
-  student: student
-}
-
-@bs.module external school: school = "school"
-@bs.send external getStudentById: (school, int) => student = "getStudentById"
-
-let defaultId = 10
-
-let queryResult = (usePayload, payload) => {
-  if usePayload {
-    payload.student
-  } else {
-    school->getStudentById(defaultId)
-  }
-}
-```
-```js
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-var School = require("school");
-
-function queryResult(usePayload, payload) {
-  if (usePayload) {
-    return payload.student;
-  } else {
-    return School.getStudentById(10);
-  }
-}
-
-var defaultId = 10;
-
-exports.defaultId = defaultId;
-exports.queryResult = queryResult;
-/* school Not a pure module */
-```
-
-</CodeTab>
-
-We've:
-- introduced an opaque types for `school` and `student` to prevent misusages their values
-- typed the payload as a record with only the `student` field
-- typed `getStudentById` as the sole method of `student`
-
-Check that the `.bs.js` output didn't change. How rigidly to type your JavaScript code is up to you; we recommend not typing them too elaborately; it's sometime an endless chase, and produces diminishing returns, especially considering that the elaborate-ness might turn off your potential teammates.
-
-## Tips & Tricks
-
-In the same vein of idea, **resist the urge to write your own wrapper functions for the JS code you're converting**. Use [`external`s](external), which are guaranteed to be erased in the output. And avoid trying to take the occasion to convert JS data structures into ReScript-specific data structures like variant or list. **This isn't the time for that**.
-
-The moment you produce extra conversion code in the output, your skeptical teammate's mental model might switch from "I recognize this output" to "this conversion might be introducing more problems than it solves. Why are we testing ReScript again?". Then you've lost.
-
-## Conclusion
-
-- Paste the JS code into a new ReScript file as embedded raw JS code.
-- Compile and keep the output file open. Check and diff against original JS file. Free regression tests.
-- Always make sure your file is syntactically valid. Don't worry about fixing types before that.
-- (Ab)use [object](object.md) accesses to quickly convert things over.
-- Optionally clean up the types for robustness.
-- Don't go overboard and turn off your boss and fellow teammates.
-- Proudly display that you've conserved the semantics and performance characteristics during the conversion by showing your teammates the eerily familiar output.
-- Get promoted for introducing a new technology the safer, mature way.
diff --git a/pages/docs/manual/v9.0.0/editor-plugins.mdx b/pages/docs/manual/v9.0.0/editor-plugins.mdx
deleted file mode 100644
index 90e82cc47..000000000
--- a/pages/docs/manual/v9.0.0/editor-plugins.mdx
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: "Editor Plugins"
-description: "List of ReScript editor plugins"
-canonical: "/docs/manual/latest/editor-plugins"
----
-
-# Editor Plugins
-
-- [VSCode](https://marketplace.visualstudio.com/items?itemName=chenglou92.rescript-vscode)
-- [Sublime Text](https://github.com/reasonml-editor/sublime-reason)
-- [Vim/Neovim](https://github.com/rescript-lang/vim-rescript)
-- 
-## Community Supported
-
-We don't officially support these; use them at your own risk!
-
-- [Atom](https://atom.io/packages/ide-rescript)
-- [IDEA](https://github.com/reasonml-editor/reasonml-idea-plugin)
-- [Emacs](https://github.com/reasonml-editor/reason-mode) (only legacy `v8.0.0` Reason/OCaml syntax support)
diff --git a/pages/docs/manual/v9.0.0/embed-raw-javascript.mdx b/pages/docs/manual/v9.0.0/embed-raw-javascript.mdx
deleted file mode 100644
index 4d99e9b5a..000000000
--- a/pages/docs/manual/v9.0.0/embed-raw-javascript.mdx
+++ /dev/null
@@ -1,110 +0,0 @@
----
-title: "Embed Raw JavaScript"
-description: "Utility syntax to for raw JS usage in ReScript"
-canonical: "/docs/manual/latest/embed-raw-javascript"
----
-
-# Embed Raw JavaScript
-
-## Paste Raw JS Code
-
-First thing first. If you're ever stuck learning ReScript, remember that you can always just paste raw JavaScript code into our source file:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-%%raw(`
-// look ma, regular JavaScript!
-var message = "hello";
-function greet(m) {
-  console.log(m)
-}
-`)
-```
-```js
-// look ma, regular JavaScript!
-var message = "hello";
-function greet(m) {
-  console.log(m)
-}
-```
-
-</CodeTab>
-
-The `%%raw` special ReScript call takes your code string and pastes it as-is into the output. **You've now technically written your first ReScript file!**
-
-(The back tick syntax is a multiline string, similar to JavaScript's. Except for us, no escaping is needed inside the string. More on string in a later section.)
-
-While `%%raw` lets you embed top-level raw JS code, `%raw` lets you embed expression-level JS code:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let add = %raw(`
-  function(a, b) {
-    console.log("hello from raw JavaScript!");
-    return a + b
-  }
-`)
-
-Js.log(add(1, 2))
-```
-```js
-var add = function(a, b) {
-  console.log("hello from raw JavaScript!");
-  return a + b
-};
-
-console.log(add(1, 2));
-```
-
-</CodeTab>
-
-The above code:
-- declared a ReScript variable `add`,
-- with the raw JavaScript value of a function declaration,
-- then called that function in ReScript.
-
-If your boss is ever worried that your teammates can't adopt ReScript, just let them keep writing JavaScript inside ReScript files =).
-
-## Debugger
-
-You can also drop a `%debugger` expression in a body:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let f = (x, y) => {
-  %debugger
-  x + y
-}
-```
-```js
-function f(x, y) {
-  debugger;
-  return x + y | 0;
-}
-```
-
-</CodeTab>
-
-Output:
-
-```js
-function f(x, y) {
-  debugger; // JavaScript developer tools will set an breakpoint and stop here
-  x + y;
-}
-```
-
-## Tips & Tricks
-
-Embedding raw JS snippets isn't the best way to experience ReScript, though it's also highly useful if you're just starting out. As a matter of fact, the first few ReScript projects were converted through:
-
-- pasting raw JS snippets inside a file
-- examining the JS output (identical to the old hand-written JS)
-- gradually extract a few values and functions and making sure the output still looks OK
-
-At the end, we get a fully safe, converted ReScript file whose JS output is clean enough that we can confidently assert that no new bug has been introduced during the conversion process.
-
-We have a small guide on this iteration [here](converting-from-js.md). Feel free to peruse it later.
diff --git a/pages/docs/manual/v9.0.0/exception.mdx b/pages/docs/manual/v9.0.0/exception.mdx
deleted file mode 100644
index e27305991..000000000
--- a/pages/docs/manual/v9.0.0/exception.mdx
+++ /dev/null
@@ -1,274 +0,0 @@
----
-title: "Exception"
-description: "Exceptions and exception handling in ReScript"
-canonical: "/docs/manual/latest/exception"
----
-
-# Exception
-
-Exceptions are just a special kind of variant, thrown in **exceptional** cases (don't abuse them!).
-
-## Usage
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let getItem = (items) =>
-  if callSomeFunctionThatThrows() {
-    // return the found item here
-    1
-  } else {
-    raise(Not_found)
-  }
-
-let result =
-  try {
-    getItem([1, 2, 3])
-  } catch {
-  | Not_found => 0 // Default value if getItem throws
-  }
-```
-```js
-function getItem(items) {
-  if (callSomeFunctionThatThrows()) {
-    return 1;
-  }
-  throw {
-    RE_EXN_ID: "Not_found",
-    Error: new Error()
-  };
-}
-
-var result;
-
-try {
-  result = getItem([1, 2, 3]);
-} catch (raw_exn) {
-  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-  if (exn.RE_EXN_ID === "Not_found") {
-    result = 0;
-  } else {
-    throw exn;
-  }
-}
-```
-
-</CodeTab>
-
-Note that the above is just for demonstration purposes; in reality, you'd return an `option<int>` directly from `getItem` and avoid the `try` altogether.
-
-You can directly match on exceptions _while_ getting another return value from a function:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-switch List.find(i => i === theItem, myItems) {
-| item => Js.log(item)
-| exception Not_found => Js.log("No such item found!")
-}
-```
-```js
-var exit = 0;
-
-var item;
-
-try {
-  item = List.find(function(i) {
-    return i === theItem;
-  }, myItems);
-  exit = 1;
-}
-catch (raw_exn){
-  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-  if (exn.RE_EXN_ID === "Not_found") {
-    console.log("No such item found!");
-  } else {
-    throw exn;
-  }
-}
-
-if (exit === 1) {
-  console.log(item);
-}
-```
-
-</CodeTab>
-
-You can also make your own exceptions like you'd make a variant (exceptions need to be capitalized too).
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-exception InputClosed(string)
-// later on
-raise(InputClosed("The stream has closed!"))
-```
-```js
-var Caml_exceptions = require("./stdlib/caml_exceptions.js");
-
-var InputClosed = Caml_exceptions.create("MyFile.InputClosed");
-
-throw {
-  RE_EXN_ID: InputClosed,
-  _1: "The stream has closed!",
-  Error: new Error()
-};
-```
-
-</CodeTab>
-
-## Catching JS Exceptions
-
-To distinguish between JavaScript exceptions and ReScript exceptions, ReScript namespaces JS exceptions under the `Js.Exn.Error(payload)` variant. To catch an exception thrown from the JS side:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-try {
-  someJSFunctionThatThrows()
-} catch {
-| Js.Exn.Error(obj) =>
-  switch Js.Exn.message(obj) {
-  | Some(m) => Js.log("Caught a JS exception! Message: " ++ m)
-  | None => ()
-  }
-}
-```
-```js
-var Js_exn = require("./stdlib/js_exn.js");
-var Caml_js_exceptions = require("./stdlib/caml_js_exceptions.js");
-
-try {
-  someJSFunctionThatThrows();
-} catch (raw_obj) {
-  var obj = Caml_js_exceptions.internalToOCamlException(raw_obj);
-  if (obj.RE_EXN_ID === Js_exn.$$Error) {
-    var m = obj._1.message;
-    if (m !== undefined) {
-      console.log("Caught a JS exception! Message: " + m);
-    }
-  } else {
-    throw obj;
-  }
-}
-```
-
-</CodeTab>
-
-The `obj` here is of type `Js.Exn.t`, intentionally opaque to disallow illegal operations. To operate on `obj`, do like the code above by using the standard library's [`Js.Exn`](api/js/exn) module's helpers.
-
-## Raise a JS Exception
-
-`raise(MyException)` raises a ReScript exception. To raise a JavaScript exception (whatever your purpose is), use `Js.Exn.raiseError`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myTest = () => {
-  Js.Exn.raiseError("Hello!")
-}
-```
-```js
-var Js_exn = require("./stdlib/js_exn.js");
-
-function myTest() {
-  return Js_exn.raiseError("Hello!");
-}
-```
-
-</CodeTab>
-
-Then you can catch it from the JS side:
-
-```js
-// after importing `myTest`...
-try {
-  myTest()
-} catch (e) {
-  console.log(e.message) // "Hello!"
-}
-```
-
-## Catch ReScript Exceptions from JS
-
-The previous section is less useful than you think; to let your JS code work with your exception-throwing ReScript code, the latter doesn't actually need to throw a JS exception. ReScript exceptions can be used by JS code!
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-exception BadArgument({myMessage: string})
-
-let myTest = () => {
-  raise(BadArgument({myMessage: "Oops!"}))
-}
-```
-```js
-var Caml_exceptions = require("./stdlib/caml_exceptions.js");
-
-var BadArgument = Caml_exceptions.create("Playground.BadArgument");
-
-function myTest() {
-  throw {
-    RE_EXN_ID: BadArgument,
-    myMessage: "Oops!",
-    Error: new Error()
-  };
-}
-```
-
-</CodeTab>
-
-Then, in your JS:
-
-```js
-// after importing `myTest`...
-try {
-  myTest()
-} catch (e) {
-  console.log(e.myMessage) // "Oops!"
-  console.log(e.Error.stack) // the stack trace
-}
-```
-
-> Note: `RE_EXN_ID` is an internal field for bookkeeping purposes. Don't use it on the JS side. Use the other fields.
-
-The above `BadArgument` exception takes an inline record type. We special-case compile the exception as `{RE_EXN_ID, myMessage, Error}` for good ergonomics. If the exception instead took ordinary positional arguments, l like the standard library's `Invalid_argument("Oops!")`, which takes a single argument, the argument is compiled to JS as the field `_1` instead. A second positional argument would compile to `_2`, etc.
-
-## Tips & Tricks
-
-When you have ordinary variants, you often don't **need** exceptions. For example, instead of throwing when `item` can't be found in a collection, try to return an `option<item>` (`None` in this case) instead.
-
-### Catch Both ReScript and JS Exceptions in the Same `catch` Clause
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-try {
-  someOtherJSFunctionThatThrows()
-} catch {
-| Not_found => ... // catch a ReScript exception
-| Invalid_argument(_) => ... // catch a second ReScript exception
-| Js.Exn.Error(obj) => ... // catch the JS exception
-}
-```
-```js
-var Js_exn = require("./stdlib/js_exn.js");
-var Caml_js_exceptions = require("./stdlib/caml_js_exceptions.js");
-
-try {
-  someOtherJSFunctionThatThrows();
-} catch (raw_obj) {
-  var obj = Caml_js_exceptions.internalToOCamlException(raw_obj);
-  if (
-    obj.RE_EXN_ID !== "Not_found" &&
-    obj.RE_EXN_ID !== "Invalid_argument" &&
-    obj.RE_EXN_ID !== Js_exn.$$Error
-  ) {
-    throw obj;
-  }
-}
-```
-
-</CodeTab>
-
-This technically works, but hopefully you don't ever have to work with such code...
diff --git a/pages/docs/manual/v9.0.0/external.mdx b/pages/docs/manual/v9.0.0/external.mdx
deleted file mode 100644
index 95cddbe3d..000000000
--- a/pages/docs/manual/v9.0.0/external.mdx
+++ /dev/null
@@ -1,87 +0,0 @@
----
-title: "External (Bind to Any JS Library)"
-description: "The external keyword"
-canonical: "/docs/manual/latest/external"
----
-
-# External (Bind to Any JS Library)
-
-`external` is the primary ReScript feature for bringing in and using JavaScript values.
-
-`external` is like a let binding, but:
-- The right side of `=` isn't a value; it's the name of the JS value you're referring to.
-- The type for the binding is mandatory, since we need to know what the type of that JS value is.
-- Can only exist at the top level of a file or module.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external setTimeout: (unit => unit, int) => float = "setTimeout"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-There are several kinds of `external`s, differentiated and/or augmented through the `@bs` notation they carry. This page deals with the general, shared mechanism behind most `external`s. The different `@bs` annotations are documented in their respective pages later. A few notable ones:
-
-- `@val`, `@scope`: [bind to global JS values](bind-to-global-js-values).
-- `@module`: [bind to JS imported/exported values](import-from-export-to-js).
-- `@send`: [bind to JS methods](bind-to-js-function).
-
-## Usage
-
-Once declared, you can use an `external` as a normal value, just like a let binding.
-
-## Tips & Tricks
-
-`external` + ReScript objects are a wonderful combination for quick prototyping. Check the JS output tab:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// The type of document is just some random type 'a
-// that we won't bother to specify
-@val external document: 'a = "document"
-
-// call a method
-document["addEventListener"]("mouseup", _event => {
-  Js.log("clicked!")
-})
-
-// get a property
-let loc = document["location"]
-
-// set a property
-document["location"]["href"] = "rescript-lang.org"
-```
-```js
-document.addEventListener("mouseup", function(_event) {
-  console.log("clicked!");
-});
-
-var loc = document.location;
-
-document.location.href = "rescript-lang.org";
-```
-
-</CodeTab>
-
-We've specified `document`'s type as `'a`, aka a placeholder type that's polymorphic. Any value can be passed there, so you're not getting much type safety (except the inferences at various call sites). However, this is excellent for quickly getting started using a JavaScript library in ReScript **without needing the equivalent of a repository of typed bindings** like TypeScript's `DefinitelyTyped` repo.
-
-However, if you want to more rigidly bind to the JavaScript library you want, keep reading the next few interop pages.
-
-## Performance & Output Readability
-
-`external`s declarations are inlined into their callers during compilation, **and completely disappear from the JS output**. This means any time you use one, you can be sure that you're not incurring extra JavaScript \<-> ReScript conversion cost.
-
-Additionally, no extra ReScript-specific runtime is better for output readability.
-
-> **Note:** do also use `external`s and the `@blabla` attributes in the interface files. Otherwise the inlining won't happen.
-
-## Design Decisions
-
-ReScript takes interoperating with existing code very seriously. Our type system has very strong guarantees. However, such strong feature also means that, without a great interop system, it'd be very hard to gradually convert a codebase over to ReScript. Fortunately, our interop are comprehensive and cooperate very well with most existing JavaScript code.
-
-The combination of a sound type system + great interop means that we get the benefits of a traditional gradual type system regarding incremental codebase coverage & conversion, without the downside of such gradual type system: complex features to support existing patterns, slow analysis, diminishing return in terms of type coverage, etc.
diff --git a/pages/docs/manual/v9.0.0/faq.mdx b/pages/docs/manual/v9.0.0/faq.mdx
deleted file mode 100644
index 18cb46b88..000000000
--- a/pages/docs/manual/v9.0.0/faq.mdx
+++ /dev/null
@@ -1,66 +0,0 @@
----
-title: "FAQ"
-description: "Frequently asked questions about ReScript and its ecosystem"
-canonical: "/docs/manual/latest/faq"
----
-
-# Frequently Asked Questions
-
-**What's the goal of this project?**
-
-We aim to provide the best typed language experience for the JavaScript platform.
-
-
-**What’s the relationship with BuckleScript?**
-
-BuckleScript is ReScript's old branding, with a sharper focus on proper JS support and familiarity which we previously couldn't achieve to the degree we wanted, due to us needing to cater to various different crowds.
-
-**What’s ReScript's relationship with OCaml?**
-
-We reuse and adjust the excellent type system and lots of other high quality components from OCaml for JS experience. 
-Additionally, ReScript provides its own syntax, build system, IDE, backend, JS interop, extra language features, etc. 
-
-The ReScript toolchain is developed using OCaml, however, the version of ReScript is decoupled against the version of OCaml, 
-ReScript compiler should build against any reasonable modern version of OCaml compiler.
-
-For the majority of ReScript users, they don't need to learn OCaml or use OCaml toolchain to be productive in ReScript.
-
-
-
-**What’s the relationship with Reason?**
-
-See [here](/blog/bucklescript-is-rebranding). Reason is a syntax layer for OCaml that BuckleScript also adopted. The current ReScript compiler also supports the old Reason syntax v3.6 for backward compatibility. We will support it for a long time to make sure existing users do not get breaking changes.
-
-**I come from Reason/OCaml. Will ReScript keep supporting X?**
-
-Please see our [blog post](/blog/a-note-on-bucklescripts-future-commitments) on this matter.
-
-**Where can I see the docs in old Reason/OCaml syntax?**
-
-Switch the doc version to `v8.0.0` in the sidebar on the left!
-
-**Will ReScript support native compilation eventually?**
-
-Our focus is a solid JS story right now. In the future, if there’s strong demand, we might consider it.
-
-**What’s the current state of ReScript?**
-
-Currently, we're actively working on the editor support.
-
-**When will we get the `async/await` keywords?**
-
-See our answer on the [Async & Promise](promise) page's intro.
-
-**Why create a new syntax?**
-
-The existing Reason syntax is owned by a different team with a different vision. Reason aims to be 100% compatible with OCaml syntax and to support all versions of OCaml. In the last few years, we've drawn the conclusion that it’s very hard to deliver such goal without sacrificing user experience. The other reason is that we feel it’s better to have the same vision as a team so that we can make more coherent decisions.
-
-**Who is behind the project?**
-
-The ReScript team (Hongbo, Cheng, Cristiano, Maxim, Patrick, Ricky).
-
-**We have a new forum; will we also have our own Discord?**
-
-Not now. We've found that too much important information get casually passed in Discord then lost within the noise. We prefer folks to communicate on the [forum](https://forum.rescript-lang.org). This is nicer to the less active members.
-
-The team doesn't use the old Discord anymore. We encourage you to move your questions to the forum instead.
diff --git a/pages/docs/manual/v9.0.0/function.mdx b/pages/docs/manual/v9.0.0/function.mdx
deleted file mode 100644
index 79af09f5d..000000000
--- a/pages/docs/manual/v9.0.0/function.mdx
+++ /dev/null
@@ -1,551 +0,0 @@
----
-title: "Function"
-description: "Function syntax in ReScript"
-canonical: "/docs/manual/latest/function"
----
-
-# Function
-
-_Cheat sheet for the full function syntax at the end_.
-
-ReScript functions are declared with an arrow and return an expression, just like JS functions. They compile to clean JS functions too.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let greet = (name) => "Hello " ++ name
-```
-```js
-function greet(name) {
-  return "Hello " + name;
-}
-```
-
-</CodeTab>
-
-This declares a function and assigns to it the name `greet`, which you can call like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-greet("world!") // "Hello world!"
-```
-```js
-greet("world!");
-```
-
-</CodeTab>
-
-Multi-arguments functions have arguments separated by comma:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let add = (x, y, z) => x + y + z
-add(1, 2, 3) // 6
-```
-```js
-function add(x, y, z) {
-  return (x + y | 0) + z | 0;
-}
-```
-
-</CodeTab>
-
-For longer functions, you'd surround the body with a block:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let greetMore = (name) => {
-  let part1 = "Hello"
-  part1 ++ " " ++ name
-}
-```
-```js
-function greetMore(name) {
-  return "Hello " + name;
-}
-```
-
-</CodeTab>
-
-If your function has no argument, just write `let greetMore = () => {...}`.
-
-## Labeled Arguments
-
-Multi-arguments functions, especially those whose arguments are of the same type, can be confusing to call.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let addCoordinates = (x, y) => {
-  // use x and y here
-}
-// ...
-addCoordinates(5, 6) // which is x, which is y?
-```
-```js
-function addCoordinates(x, y) {
-  // use x and y here
-}
-
-addCoordinates(5, 6);
-```
-
-</CodeTab>
-
-You can attach labels to an argument by prefixing the name with the `~` symbol:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let addCoordinates = (~x, ~y) => {
-  // use x and y here
-}
-// ...
-addCoordinates(~x=5, ~y=6)
-```
-```js
-function addCoordinates(x, y) {
-  // use x and y here
-}
-
-addCoordinates(5, 6);
-```
-
-</CodeTab>
-
-You can provide the arguments in **any order**:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-addCoordinates(~y=6, ~x=5)
-```
-```js
-addCoordinates(5, 6);
-```
-
-</CodeTab>
-
-The `~x` part in the declaration means the function accepts an argument labeled `x` and can refer to it in the function body by the same name. You can also refer to the arguments inside the function body by a different name for conciseness:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let drawCircle = (~radius as r, ~color as c) => {
-  setColor(c)
-  startAt(r, r)
-  // ...
-}
-
-drawCircle(~radius=10, ~color="red")
-```
-```js
-function drawCircle(r, c) {
-  setColor(c);
-  return startAt(r, r);
-}
-
-drawCircle(10, "red");
-```
-
-</CodeTab>
-
-As a matter of fact, `(~radius)` is just a shorthand for `(~radius as radius)`.
-
-Here's the syntax for typing the arguments:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let drawCircle = (~radius as r: int, ~color as c: string) => {
-  // code here
-}
-```
-```js
-function drawCircle(r, c) {
-  // code here
-}
-```
-
-</CodeTab>
-
-## Optional Labeled Arguments
-
-Labeled function arguments can be made optional during declaration. You can then omit them when calling the function.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// radius can be omitted
-let drawCircle = (~color, ~radius=?, ()) => {
-  setColor(color)
-  switch radius {
-  | None => startAt(1, 1)
-  | Some(r_) => startAt(r_, r_)
-  }
-}
-```
-```js
-var Caml_option = require("./stdlib/caml_option.js");
-
-function drawCircle(color, radius, param) {
-  setColor(color);
-  if (radius === undefined) {
-    return startAt(1, 1);
-  }
-  var r_ = Caml_option.valFromOption(radius);
-  return startAt(r_, r_);
-}
-```
-
-</CodeTab>
-
-When given in this syntax, `radius` is **wrapped** in the standard library's `option` type, defaulting to `None`. If provided, it'll be wrapped with a `Some`. So `radius`'s type value is `None | Some(int)` here.
-
-More on `option` type [here](null-undefined-option.md).
-
-**Note** for the sake of the type system, whenever you have an optional argument, you need to ensure that there's also at least one positional argument (aka non-labeled, non-optional argument) after it. If there's none, provide a dummy `unit` (aka `()`) argument.
-
-### Signatures and Type Annotations
-
-Functions with optional labeled arguments can be confusing when it comes to signature and type annotations. Indeed, the type of an optional labeled argument looks different depending on whether you're calling the function, or working inside the function body. Outside the function, a raw value is either passed in (`int`, for example), or left off entirely. Inside the function, the parameter is always there, but its value is an option (`option<int>`). This means that the type signature is different, depending on whether you're writing out the function type, or the parameter type annotation. The first being a raw value, and the second being an option.
-
-If we get back to our previous example and both add a signature and type annotations to its argument, we get this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let drawCircle: (~color: color, ~radius: int=?, unit) => unit =
-  (~color: color, ~radius: option<int>=?, ()) => {
-    setColor(color)
-    switch radius {
-    | None => startAt(1, 1)
-    | Some(r_) => startAt(r_, r_)
-    }
-  }
-```
-```js
-function drawCircle(color, radius, param) {
-  setColor(color);
-  if (radius !== undefined) {
-    return startAt(radius, radius);
-  } else {
-    return startAt(1, 1);
-  }
-}
-```
-
-</CodeTab>
-
-The first line is the function's signature, we would define it like that in an interface file (see [Signatures](module.md#signatures)). The function's signature describes the types that the **outside world** interacts with, hence the type `int` for `radius` because it indeed expects an `int` when called.
-
-In the second line, we annotate the arguments to help us remember the types of the arguments when we use them **inside** the function's body, here indeed `radius` will be an `option<int>` inside the function.
-
-So if you happen to struggle when writing the signature of a function with optional labeled arguments, try to remember this!
-
-### Explicitly Passed Optional
-
-Sometimes, you might want to forward a value to a function without knowing whether the value is `None` or `Some(a)`. Naively, you'd do:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result =
-  switch payloadRadius {
-  | None => drawCircle(~color, ())
-  | Some(r) => drawCircle(~color, ~radius=r, ())
-  }
-```
-```js
-var r = payloadRadius;
-
-var result = r !== undefined
-  ? drawCircle(color, Caml_option.valFromOption(r), undefined)
-  : drawCircle(color, undefined);
-```
-
-</CodeTab>
-
-This quickly gets tedious. We provide a shortcut:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result = drawCircle(~color, ~radius=?payloadRadius, ())
-```
-```js
-var result = drawCircle(1, undefined, undefined);
-```
-
-</CodeTab>
-
-This means "I understand `radius` is optional, and that when I pass it a value it needs to be an `int`, but I don't know whether the value I'm passing is `None` or `Some(val)`, so I'll pass you the whole `option` wrapper".
-
-### Optional with Default Value
-
-Optional labeled arguments can also be provided a default value. In this case, they aren't wrapped in an `option` type.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let drawCircle = (~radius=1, ~color, ()) => {
-  setColor(color)
-  startAt(radius, radius)
-}
-```
-```js
-function drawCircle(radiusOpt, color, param) {
-  var radius = radiusOpt !== undefined ? radiusOpt : 1;
-  setColor(color);
-  return startAt(radius, radius);
-}
-```
-
-</CodeTab>
-
-## Recursive Functions
-
-ReScript chooses the sane default of preventing a function to be called recursively within itself. To make a function recursive, add the `rec` keyword after the `let`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let rec neverTerminate = () => neverTerminate()
-```
-```js
-function neverTerminate(_param) {
-  while(true) {
-    _param = undefined;
-    continue ;
-  };
-}
-```
-
-</CodeTab>
-
-A simple recursive function may look like this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// Recursively check every item on the list until one equals the `item`
-// argument. If a match is found, return `true`, otherwise return `false`
-let rec listHas = (list, item) =>
-  switch list {
-  | list{} => false
-  | list{a, ...rest} => a === item || listHas(rest, item)
-  }
-```
-```js
-function listHas(_list, item) {
-  while(true) {
-    var list = _list;
-    if (!list) {
-      return false;
-    }
-    if (list.hd === item) {
-      return true;
-    }
-    _list = list.tl;
-    continue ;
-  };
-}
-```
-
-</CodeTab>
-
-Recursively calling a function is bad for performance and the call stack. However, ReScript intelligently compiles [tail recursion](https://stackoverflow.com/questions/33923/what-is-tail-recursion) into a fast JavaScript loop. Try checking the JS output of the above code!
-
-### Mutually Recursive Functions
-
-Mutually recursive functions start like a single recursive function using the
-`rec` keyword, and then are chained together with `and`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let rec callSecond = () => callFirst()
-and callFirst = () => callSecond()
-```
-```js
-function callSecond(_param) {
-  while(true) {
-    _param = undefined;
-    continue ;
-  };
-}
-
-function callFirst(_param) {
-  while(true) {
-    _param = undefined;
-    continue ;
-  };
-}
-```
-
-</CodeTab>
-
-## Uncurried Function
-
-ReScript's functions are curried by default, which is one of the few performance penalties we pay in the compiled JS output. The compiler does a best-effort job at removing those currying whenever possible. However, in certain edge cases, you might want guaranteed uncurrying. In those cases, put a dot in the function's parameter list:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let add = (. x, y) => x + y
-
-add(. 1, 2)
-```
-```js
-function add(x, y) {
-  return x + y | 0;
-}
-
-add(1, 2);
-```
-
-</CodeTab>
-
-If you need to call a curried function with a single unit `()` argument, you can use the `ignore()` function:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let echo = (. a) => a
-
-echo(. ignore())
-```
-
-```js
-function echo(a) {
-  return a;
-}
-
-echo(undefined);
-```
-
-</CodeTab>
-
-
-If you write down the uncurried function's type, you'll add a dot there as well.
-
-**Note**: both the declaration site and the call site need to have the uncurry annotation. That's part of the guarantee/requirement.
-
-**This feature seems trivial**, but is actually one of our most important features, as a primarily functional language. We encourage you to use it if you'd like to remove any mention of `Curry` runtime in the JS output.
-
-## Tips & Tricks
-
-Cheat sheet for the function syntaxes:
-
-### Declaration
-
-```res
-// anonymous function
-(x, y) => 1
-// bind to a name
-let add = (x, y) => 1
-
-// labeled
-let add = (~first as x, ~second as y) => x + y
-// with punning sugar
-let add = (~first, ~second) => first + second
-
-// labeled with default value
-let add = (~first as x=1, ~second as y=2) => x + y
-// with punning
-let add = (~first=1, ~second=2) => first + second
-
-// optional
-let add = (~first as x=?, ~second as y=?) => switch x {...}
-// with punning
-let add = (~first=?, ~second=?) => switch first {...}
-```
-
-#### With Type Annotation
-
-```res
-// anonymous function
-(x: int, y: int): int => 1
-// bind to a name
-let add = (x: int, y: int): int => 1
-
-// labeled
-let add = (~first as x: int, ~second as y: int) : int => x + y
-// with punning sugar
-let add = (~first: int, ~second: int) : int => first + second
-
-// labeled with default value
-let add = (~first as x: int=1, ~second as y: int=2) : int => x + y
-// with punning sugar
-let add = (~first: int=1, ~second: int=2) : int => first + second
-
-// optional
-let add = (~first as x: option<int>=?, ~second as y: option<int>=?) : int => switch x {...}
-// with punning sugar
-// note that the caller would pass an `int`, not `option<int>`
-// Inside the function, `first` and `second` are `option<int>`.
-let add = (~first: option<int>=?, ~second: option<int>=?) : int => switch first {...}
-```
-
-### Application
-
-```res
-add(x, y)
-
-// labeled
-add(~first=1, ~second=2)
-// with punning sugar
-add(~first, ~second)
-
-// application with default value. Same as normal application
-add(~first=1, ~second=2)
-
-// explicit optional application
-add(~first=?Some(1), ~second=?Some(2))
-// with punning
-add(~first?, ~second?)
-```
-
-#### With Type Annotation
-
-```res
-// labeled
-add(~first=1: int, ~second=2: int)
-// with punning sugar
-add(~first: int, ~second: int)
-
-// application with default value. Same as normal application
-add(~first=1: int, ~second=2: int)
-
-// explicit optional application
-add(~first=?Some(1): option<int>, ~second=?Some(2): option<int>)
-// no punning sugar when you want to type annotate
-```
-
-### Standalone Type Signature
-
-```res
-// first arg type, second arg type, return type
-type add = (int, int) => int
-
-// labeled
-type add = (~first: int, ~second: int) => int
-
-// labeled
-type add = (~first: int=?, ~second: int=?, unit) => int
-```
-
-#### In Interface Files
-
-To annotate a function from the implementation file (`.res`) in your interface file (`.resi`):
-
-```res sig
-let add: (int, int) => int
-```
-
-The type annotation part is the same as the previous section on With Type Annotation.
-
-**Don't** confuse `let add: myType` with `type add = myType`. When used in `.resi` interface files, the former exports the binding `add` while annotating it as type `myType`. The latter exports the type `add`, whose value is the type `myType`.
diff --git a/pages/docs/manual/v9.0.0/generate-converters-accessors.mdx b/pages/docs/manual/v9.0.0/generate-converters-accessors.mdx
deleted file mode 100644
index a87bf7872..000000000
--- a/pages/docs/manual/v9.0.0/generate-converters-accessors.mdx
+++ /dev/null
@@ -1,614 +0,0 @@
----
-title: "Generate Converters & Helpers"
-description: "All about the @deriving decorator, and how to generate code from types"
-canonical: "/docs/manual/latest/generate-converters-accessors"
----
-
-# Generate Converters & Helpers
-
-<!-- TODO: genType -->
-
-When using ReScript, you will sometimes come into situations where you want to
-
-- Automatically generate functions that convert between ReScript's internal and JS runtime values (e.g. variants).
-- Convert a record type into an abstract type with generated creation, accessor and method functions.
-- Generate some other helper functions, such as functions from record attribute names.
-
-You can use the `@deriving` decorator for different code generation scenarios. All different options and configurations will be discussed on this page.
-
-**Note:** Please be aware that extensive use of code generation might make it harder to understand your programs (since the code being generated is not visible in the source code, and you just need to know what kind of functions / values a decorator generates).
-
-## Generate Functions & Plain Values for Variants
-
-Use `@deriving(accessors)` on a variant type to create accessor functions for its constructors.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@deriving(accessors)
-type action =
-  | Click
-  | Submit(string)
-  | Cancel;
-```
-
-```js
-function submit(param_0) {
-  return /* Submit */[param_0];
-}
-
-var click = /* Click */0;
-
-var cancel = /* Cancel */1;
-
-exports.click  = click;
-exports.submit = submit;
-exports.cancel = cancel;
-```
-
-</CodeTab>
-
-Variants constructors with payloads generate functions, payload-less constructors generate plain integers (the internal representation of variants).
-
-**Note**:
-- The generated accessors are lower-cased.
-- You can now use these helpers on the JavaScript side! But don't rely on their actual values please.
-
-### Usage
-
-```res
-let s = submit("hello"); /* gives Submit("hello") */
-```
-
-This is useful:
-
-- When you're passing the accessor function as a higher-order function (which plain variant constructors aren't).
-- When you'd like the JS side to use these values & functions opaquely and pass you back a variant constructor (since JS has no such thing).
-
-Please note that in case you just want to _pipe a payload into a constructor_, you don't need to generate functions for that. Use the `->` syntax instead, e.g. `"test"->Submit`.
-
-## Generate Field Accessors for Records
-
-Use `@deriving(accessors)` on a record type to create accessors for its record field names.
-
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@deriving(accessors)
-type pet = {name: string}
-
-let pets = [{name: "bob"}, {name: "bob2"}]
-
-pets
- ->Belt.Array.map(name)
- ->Js.Array2.joinWith("&")
- ->Js.log
-```
-
-```js
-function name(param) {
-  return param.name;
-}
-
-var pets = [
-  {
-    name: "bob"
-  },
-  {
-    name: "bob2"
-  }
-];
-
-console.log(Belt_Array.map(pets, name).join("&"));
-```
-
-</CodeTab>
-
-## Generate Converters for JS Object and Record
-
-> **Note:** In ReScript >= v7 [records are already compiled to JS
-> objects](bind-to-js-object#bind-to-record-like-js-objects). `@deriving(jsConverter)` is therefore
-> obsolete and will generate a no-op function for compatibility instead.
-
-Use `@deriving(jsConverter)` on a record type to create convertion functions between records / JS object runtime values.
-
-
-```res
-@deriving(jsConverter)
-type coordinates = {
-  x: int,
-  y: int
-};
-```
-
-Generates 2 functions of the following types:
-
-```res
-let coordinatesToJs: coordinates => {"x": int, "y": int};
-
-let coordinatesFromJs: {.. "x": int, "y": int} => coordinates;
-```
-
-**Note**:
-
-- `coordinatesFromJs` uses an open object type that accepts more fields, just to be more permissive.
-- The converters are shallow. They don't recursively drill into the fields and convert them. This preserves the speed and simplicity of output while satisfying 80% of use-cases.
-
-### Usage
-
-This exports a `jsCoordinates` JS object (not a record!) for JS files to use:
-
-```res
-let jsCoordinates = coordinatesToJs({x: 1, y: 2});
-```
-
-This binds to a `jsCoordinates` record (not a JS object!) that exists on the JS side, presumably created by JS calling the function `coordinatesFromJs`:
-
-```res
-@module("myGame")
-external jsCoordinates : coordinates = "jsCoordinates";
-```
-
-### More Safety
-
-The above generated functions use JS object types. You can also hide this implementation detail by making the object type **abstract** by using the `newType` option with `@deriving(jsConverter)`:
-
-```res
-@deriving({jsConverter: newType})
-type coordinates = {
-  x: int,
-  y: int,
-}
-```
-
-Generates 2 functions of the following types:
-
-```resi
-let coordinatesToJs: coordinates => abs_coordinates;
-
-let coordinatesFromJs: abs_coordinates => coordinates;
-```
-
-#### Usage
-
-Using `newType`, you've now prevented consumers from inadvertently doing the following:
-
-```res
-let myCoordinates = {
-  x: 10,
-  y: 20
-};
-let jsCoords = coordinatesToJs(myCoordinates);
-
-let x = jsCoords["x"]; /* disallowed! Don't access the object's internal details */
-```
-
-Same generated output. Isn't it great that types prevent invalid accesses you'd otherwise have to encode at runtime?
-
-## Generate Converters for JS Integer Enums and Variants
-
-Use `@deriving(jsConverter)` on a variant type to create converter functions that allow back and forth conversion between JS integer enum and ReScript variant values.
-
-```res
-@deriving(jsConverter)
-type fruit =
-  | Apple
-  | Orange
-  | Kiwi
-  | Watermelon;
-```
-
-This option causes `jsConverter` to, again, generate functions of the following types:
-
-```resi
-let fruitToJs: fruit => int;
-
-let fruitFromJs: int => option(fruit);
-```
-
-For `fruitToJs`, each fruit variant constructor would map into an integer, starting at 0, in the order they're declared.
-
-For `fruitFromJs`, the return value is an `option`, because not every int maps to a constructor.
-
-You can also attach a `@as(1234)` to each constructor to customize their output.
-
-### Usage
-
-```res
-@deriving(jsConverter)
-type fruit =
-  | Apple
-  | @as(10) Orange
-  | @as(100) Kiwi
-  | Watermelon
-
-let zero = fruitToJs(Apple) /* 0 */
-
-switch fruitFromJs(100) {
-| Some(Kiwi) => Js.log("this is Kiwi")
-| _ => Js.log("received something wrong from the JS side")
-}
-```
-
-**Note**: by using `@as` here, all subsequent number encoding changes. `Apple` is still `0`, `Orange` is `10`, `Kiwi` is `100` and `Watermelon` is **`101`**!
-
-### More Safety
-
-Similar to the JS object \<-> record deriving, you can hide the fact that the JS enum are ints by using the same `newType` option with `@deriving(jsConverter)`:
-
-```res
-@deriving({jsConverter: newType})
-type fruit =
-  | Apple
-  | @as(100) Kiwi
-  | Watermelon;
-```
-
-This option causes `@deriving(jsConverter)` to generate functions of the following types:
-
-```resi
-let fruitToJs: fruit => abs_fruit;
-
-let fruitFromJs: abs_fruit => fruit;
-```
-
-For `fruitFromJs`, the return value, unlike the previous non-abstract type case, doesn't contain an `option`, because there's no way a bad value can be passed into it; the only creator of `abs_fruit` values is `fruitToJs`!
-
-#### Usage
-
-```res
-@deriving({jsConverter: newType})
-type fruit =
-  | Apple
-  | @as(100) Kiwi
-  | Watermelon
-
-let opaqueValue = fruitToJs(Apple)
-
-@module("myJSFruits") external jsKiwi: abs_fruit = "iSwearThisIsAKiwi"
-let kiwi = fruitFromJs(jsKiwi)
-
-let error = fruitFromJs(100) /* nope, can't take a random int */
-```
-
-## Generate Converters for JS String Enums and Polymorphic Variants
-
-> **Note**: Since ReScript v8.2, polymorphic variants are already compiled to strings, so this feature is getting deprecated at some point. It's currently still useful for aliasing JS output with `@as`.
-
-Similarly as with [generating int converters](#generate-converters-between-js-integer-enums-and-variants), use `@deriving(jsConverter)` on a polymorphic variant type to create converter functions for JS string and ReScript poly variant values.
-
-### Usage
-
-```res
-@deriving(jsConverter)
-type fruit = [
-  | #Apple
-  | @as("miniCoconut") #Kiwi
-  | #Watermelon
-]
-
-let appleString = fruitToJs(#Apple); /* "Apple" */
-let kiwiString = fruitToJs(#Kiwi); /* "miniCoconut" */
-```
-
-As in similar use-cases before, you can also use `@deriving({jsConverter: newType})` to generate abstract types instead.
-
-## Convert Record Type to Abstract Record
-
-> **Note**: For ReScript >= v7, we recommend using [plain records to compile to JS objects](bind-to-js-object#bind-to-record-like-js-objects).
-> This feature might still be useful for certain scenarios, but the ergonomics might be worse
-
-Use `@deriving(abstract)` on a record type to expand the type into a creation, and a set of getter / setter functions for fields and methods.
-
-Usually you'd just use ReScript records to compile to JS objects of the same shape. There is still one particular use-case left where the `@deriving(abstract)` convertion is still useful: Whenever you need compile a record with an optional field where the JS object attribute shouldn't show up in the resulting JS when undefined (e.g. `{name: "Carl", age: undefined}` vs `{name: "Carl"}`). Check the [Optional Labels](#optional-labels) section for more infos on this particular scenario.
-
-### Usage Example
-
-```res
-@deriving(abstract)
-type person = {
-  name: string,
-  age: int,
-  job: string,
-};
-
-@val external john : person = "john";
-```
-
-**Note**: the `person` type is **not** a record! It's a record-looking type that uses the record's syntax and type-checking. The `@deriving(abstract)` decorator turns it into an "abstract type" (aka you don't know what the actual value's shape).
-
-### Creation
-
-You don't have to bind to an existing `person` object from the JS side. You can also create such `person` JS object from ReScript's side.
-
-Since `@deriving(abstract)` turns the above `person` record into an abstract type, you can't directly create a person record as you would usually. This doesn't work: `{name: "Joe", age: 20, job: "teacher"}`.
-
-Instead, you'd use the **creation function** of the same name as the record type, implicitly generated by the `@deriving(abstract)` annotation:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let joe = person(~name="Joe", ~age=20, ~job="teacher")
-```
-
-```js
-var joe = {
-  name: "Joe",
-  age: 20,
-  job: "teacher"
-};
-```
-
-</CodeTab>
-
-Note how in the example above there is no JS runtime overhead.
-
-#### Rename Fields
-
-Sometimes you might be binding to a JS object with field names that are invalid in ReScript. Two examples would be `{type: "foo"}` (reserved keyword in ReScript) and `{"aria-checked": true}`. Choose a valid field name then use `@as` to circumvent this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@deriving(abstract)
-type data = {
-  @as("type") type_: string,
-  @as("aria-label") ariaLabel: string,
-};
-
-let d = data(~type_="message", ~ariaLabel="hello");
-```
-
-```js
-var d = {
-  type: "message",
-  "aria-label": "hello"
-};
-```
-
-</CodeTab>
-
-#### Optional Labels
-
-You can omit fields during the creation of the object:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@deriving(abstract)
-type person = {
-  @optional name: string,
-  age: int,
-  job: string,
-};
-
-let joe = person(~age=20, ~job="teacher", ());
-```
-
-```js
-var joe = {
-  age: 20,
-  job: "teacher"
-};
-```
-
-</CodeTab>
-
-Optional values that are not defined, will not show up as an attribute in the resulting JS object. In the example above, you will see that `name` was omitted.
-
-**Note** that the `@optional` tag turned the `name` field optional. Merely typing `name` as `option<string>` wouldn't work.
-
-**Note**: now that your creation function contains optional fields, we mandate an unlabeled `()` at the end to indicate that [you've finished applying the function](function#optional-labeled-arguments).
-
-### Accessors
-
-Again, since `@deriving(abstract)` hides the actual record shape, you can't access a field using e.g. `joe.age`. We remediate this by generating getter and setters.
-
-#### Read
-
-One getter function is generated per `@deriving(abstract)` record type field. In the above example, you'd get 3 functions: `nameGet`, `ageGet`, `jobGet`. They take in a `person` value and return `string`, `int`, `string` respectively:
-
-```res
-let twenty = ageGet(joe)
-```
-
-Alternatively, you can use the [Pipe](pipe) operator (`->`) for a nicer-looking access syntax:
-
-```res
-let twenty = joe->ageGet
-```
-
-If you prefer shorter names for the getter functions, we also support a `light` setting:
-
-```res
-@deriving({abstract: light})
-type person = {
-  name: string,
-  age: int,
-}
-
-let joe = person(~name="Joe", ~age=20)
-let joeName = name(joe)
-```
-
-The getter functions will now have the same names as the object fields themselves.
-
-#### Write
-
-A `@deriving(abstract)` value is immutable by default. To mutate such value, you need to first mark one of the abstract record field as `mutable`, the same way you'd mark a normal record as mutable:
-
-```res
-@deriving(abstract)
-type person = {
-  name: string,
-  mutable age: int,
-  job: string,
-}
-```
-
-Then, a setter of the name `ageSet` will be generated. Use it like so:
-
-```res
-let joe = person(~name="Joe", ~age=20, ~job="teacher");
-ageSet(joe, 21);
-```
-
-Alternatively, with the Pipe First syntax:
-
-```res
-joe->ageSet(21)
-```
-
-### Methods
-
-You can attach arbitrary methods onto a type (_any_ type, as a matter of fact. Not just `@deriving(abstract)` record types). See [Object Method](bind-to-js-function#object-method) in the "Bind to JS Function" section for more infos.
-
-### Tips & Tricks
-
-You can leverage `@deriving(abstract)` for finer-grained access control.
-
-#### Mutability
-
-You can mark a field as mutable in the implementation (`.res`) file, while _hiding_ such mutability in the interface file:
-
-```res
-/* test.res */
-@deriving(abstract)
-type cord = {
-  @optional mutable x: int,
-  y: int,
-};
-```
-
-```resi
-/* test.resi */
-@deriving(abstract)
-type cord = {
-  @optional x: int,
-  y: int,
-};
-```
-
-Tada! Now you can mutate inside your own file as much as you want, and prevent others from doing so!
-
-#### Hide the Creation Function
-
-Mark the record as `private` to disable the creation function:
-
-```res
-@deriving(abstract)
-type cord = private {
-  @optional x: int,
-  y: int,
-}
-```
-
-The accessors are still there, but you can no longer create such data structure. Great for binding to a JS object while preventing others from creating more such object!
-
-#### Use submodules to prevent naming collisions and binding shadowing
-
-Oftentimes you will have multiple abstract types with similar attributes. Since
-ReScript will expand all abstract getter, setter and creation functions in the
-same scope where the type is defined, you will eventually run into value shadowing problems.
-
-**For example:**
-
-```res
-@deriving(abstract)
-type person = {name: string}
-
-@deriving(abstract)
-type cat = {
-  name: string,
-  isLazy: bool,
-};
-
-let person = person(~name="Alice")
-
-/* Error: This expression has type person but an expression was expected
-   of type cat */
-person->nameGet()
-```
-
-To get around this issue, you can use modules to group a type with its related
-functions and later use them via local open statements:
-
-```res
-module Person = {
-  @deriving(abstract)
-  type t = {name: string}
-}
-
-module Cat = {
-  @deriving(abstract)
-  type t = {
-    name: string,
-    isLazy: bool,
-  }
-}
-
-let person = Person.t(~name="Alice")
-let cat = Cat.t(~name="Snowball", ~isLazy=true)
-
-/* We can use each nameGet function separately now */
-let shoutPersonName = {
-  open Person
-  person->nameGet->Js.String.toUpperCase
-}
-
-/* Note how we use a local `open Cat` expression to
- get access to Cat's nameGet function */
-let whisperCatName = {
-  open Cat
-  cat->nameGet->Js.String.toLowerCase
-}
-```
-
-## Convert External into JS Object Creation Function
-
-Use `@obj` on an `external` binding to create a function that, when called, will evaluate to a JS object with fields corresponding to the function's parameter labels.
-
-This is very handy because you can make some of those labelled parameters optional and if you don't pass them in, the output object won't include the corresponding fields. Thus you can use it to dynamically create objects with the subset of fields you need at runtime.
-
-For example, suppose you need a JavaScript object like this:
-
-
-```js
-var homeRoute = {
-  type: "GET",
-  path: "/",
-  action: () => console.log("Home"),
-  // options: ...
-};
-```
-
-But only the first three fields are required; the options field is optional. You can declare the binding function like so:
-
-```res
-@obj
-external route: (
-  ~\"type": string,
-  ~path: string,
-  ~action: list<string> => unit,
-  ~options: {..}=?,
-  unit,
-) => _ = ""
-```
-
-**Note**: the ` = ""` part at the end is just a dummy placeholder, due to syntactic limitations. It serves no purpose currently.
-
-This function has four labelled parameters (the fourth one optional), one unlabelled parameter at the end (which we mandate for functions with [optional parameters](function#optional-labeled-arguments), and one parameter (`\"type"`) that required quoting to [avoid clashing](use-illegal-identifier-names) with the reserved `type` keyword.
-
-Also of interest is the return type: `_`, which tells ReScript to automatically infer the full type of the JS object, sparing you the hassle of writing down the type manually!
-
-The function is called like so:
-
-```res
-let homeRoute = route(
-  ~\"type"="GET",
-  ~path="/",
-  ~action=_ => Js.log("Home"),
-  (),
-)
-```
diff --git a/pages/docs/manual/v9.0.0/import-export.mdx b/pages/docs/manual/v9.0.0/import-export.mdx
deleted file mode 100644
index 137646038..000000000
--- a/pages/docs/manual/v9.0.0/import-export.mdx
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: "Import & Export"
-description: "Importing / exporting in ReScript modules"
-canonical: "/docs/manual/latest/import-export"
----
-
-# Import & Export
-
-## Import a Module/File
-
-Unlike JavaScript, ReScript doesn't have or need import statements:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Inside School.res
-let studentMessage = Student.message
-```
-```js
-var Student = require("./Student.bs");
-var studentMessage = Student.message
-```
-
-</CodeTab>
-
-The above code refers to the `message` binding in the file `Student.res`. Every ReScript file is also a module, so accessing another file's content is the same as accessing another module's content!
-
-A ReScript project's file names need to be unique.
-
-## Export Stuff
-
-By default, every file's type declaration, binding and module is exported, aka publicly usable by another file. **This also means those values, once compiled into JS, are immediately usable by your JS code**.
-
-To only export a few selected things, use a `.resi` [interface file](module.md#signatures).
-
-## Work with JavaScript Import & Export
-
-To see how to import JS modules and export stuff for JS consumption, see the JavaScript Interop section's [Import from/Export to JS](import-from-export-to-js.md).
diff --git a/pages/docs/manual/v9.0.0/import-from-export-to-js.mdx b/pages/docs/manual/v9.0.0/import-from-export-to-js.mdx
deleted file mode 100644
index 166f7fcfb..000000000
--- a/pages/docs/manual/v9.0.0/import-from-export-to-js.mdx
+++ /dev/null
@@ -1,150 +0,0 @@
----
-title: "Import from / Export to JS"
-description: "Importing / exporting JS module content in ReScript"
-canonical: "/docs/manual/latest/import-from-export-to-js"
----
-
-# Import from/Export to JS
-
-You've seen how ReScript's idiomatic [Import & Export](import-export.md) works. This section describes how we work with importing stuff from JavaScript and exporting stuff for JavaScript consumption.
-
-**Note**: due to JS ecosystem's module compatibility issues, our advice of keeping your ReScript file's compiled JS output open in a tab applies here **more than ever**, as you don't want to subtly output the wrong JS module import/export code, on top of having to deal with Babel/Webpack/Jest/Node's CommonJS\<->ES6 compatibility shims.
-
-In short: **make sure your bindings below output what you'd have manually written in JS**.
-
-## Output Format
-
-We support 2 JavaScript import/export formats:
-
-- CommonJS: `require('myFile')` and `module.export = ...`.
-- ES6 modules: `import * from 'MyReScriptFile'` and `export let ...`.
-
-The format is [configurable in bsb](build-configuration.md#package-specs).
-
-## Import From JavaScript
-
-### Import a JavaScript Module's Named Export
-
-Use the `module` [external](external.md):
-
-<CodeTab labels={["ReScript", "JS Output (CommonJS)", "JS Output (ES6)"]}>
-
-```res example
-// Import nodejs' path.dirname
-@module("path") external dirname: string => string = "dirname"
-let root = dirname("/User/github") // returns "User"
-```
-```js
-var Path = require("path");
-var root = Path.dirname("/User/github");
-```
-```js
-import * as Path from "path";
-var root = Path.dirname("/User/github");
-```
-
-</CodeTab>
-
-Here's what the `external` does:
-
-- `@module("path")`: pass the name of the JS module; in this case, `"path"`. The string can be anything: `"./src/myJsFile"`, `"@myNpmNamespace/myLib"`, etc.
-- `external`: the general keyword for declaring a value that exists on the JS side.
-- `dirname`: the binding name you'll use on the ReScript side.
-- `string => string`: the type signature of `dirname`. Mandatory for `external`s.
-- `= "dirname"`: the name of the variable inside the `path` JS module. There's repetition in writing the first and second `dirname`, because sometime the binding name you want to use on the ReScript side is different than the variable name the JS module exported.
-
-### Import a JavaScript Module As a Single Value
-
-By omitting the string argument to `module`, you bind to the whole JS module:
-
-<CodeTab labels={["ReScript", "JS Output (CommonJS)", "JS Output (ES6)"]}>
-
-```res example
-@module external leftPad: string => int => string = "./leftPad"
-let paddedResult = leftPad("hi", 5)
-```
-```js
-var LeftPad = require("./leftPad");
-var paddedResult = LeftPad("hi", 5);
-```
-```js
-import * as LeftPad from "./leftPad";
-var paddedResult = LeftPad("hi", 5);
-```
-
-</CodeTab>
-
-Depending on whether you're compiling ReScript to CommonJS or ES6 module, **this feature will generate subtly different code**. Please check both output tabs to see the difference. The ES6 output here would be wrong!
-
-### Import an ES6 Default Export (Since >= 8.3.0)
-
-Use the value `"default"` on the right hand side:
-
-<CodeTab labels={["ReScript", "JS Output (ES6)"]}>
-
-```res example
-@module("./student") external studentName: string = "default"
-Js.log(studentName)
-```
-```js
-import Student from "./student";
-var studentName = Student;
-```
-
-</CodeTab>
-
-## Export To JavaScript
-
-### Export a Named Value
-
-As mentioned in ReScript's idiomatic [Import & Export](import-export.md), every let binding and module is exported by default to other ReScript modules (unless you use a `.resi` [interface file](module#signatures)). If you open up the compiled JS file, you'll see that these values can also directly be used by a _JavaScript_ file too.
-
-### Export an ES6 Default Value
-
-If your JS project uses ES6 modules, you're likely exporting & importing some default values:
-
-```js
-// student.js
-export default name = "Al";
-```
-
-```js
-// teacher.js
-import studentName from 'student.js';
-```
-
-A JavaScript default export is really just syntax sugar for a named export implicitly called `default` (now you know!). So to export a default value from ReScript, you can just do:
-
-<CodeTab labels={["ReScript", "JS Output (CommonJS)", "JS Output (ES6)"]}>
-
-```res example
-// ReScriptStudent.res
-let default = "Bob"
-```
-```js
-var $$default = "Bob";
-
-exports.$$default = $$default;
-exports.default = $$default;
-// informal transpiler-compatible marker of a default export compiled from ES6
-exports.__esModule = true;
-```
-```js
-var $$default = "Bob";
-
-export {
-  $$default,
-  $$default as default,
-}
-```
-
-</CodeTab>
-
-You can then import this default export as usual on the JS side:
-
-```js
-// teacher2.js
-import studentName from 'ReScriptStudent.js';
-```
-
-If your JavaScript's ES6 default import is transpiled by Babel/Webpack/Jest into CommonJS `require`s, we've taken care of that too! See the CommonJS output tab for `__esModule`.
diff --git a/pages/docs/manual/v9.0.0/inlining-constants.mdx b/pages/docs/manual/v9.0.0/inlining-constants.mdx
deleted file mode 100644
index 45609df20..000000000
--- a/pages/docs/manual/v9.0.0/inlining-constants.mdx
+++ /dev/null
@@ -1,78 +0,0 @@
----
-title: "Inlining Constants"
-description: "Inlining constants"
-canonical: "/docs/manual/latest/inlining-constants"
----
-
-# Inlining Constants
-
-Sometime, in the JavaScript output, you might want a certain value to be forcefully inlined. For example:
-
-```js
-if (process.env.mode === 'development') {
-  console.log("Dev-only code here!")
-}
-```
-
-The reason is that your JavaScript bundler (e.g. Webpack) might turn that into:
-
-```js
-if ('production' === 'development') {
-  console.log("Dev-only code here!")
-}
-```
-
-Then your subsequent Uglifyjs optimization would remove that entire `if` block. This is how projects like ReactJS provide a development mode code with plenty of dev warnings, while ensuring that the uglified (minified) production code is free of those expensive blocks.
-
-So, in ReScript, producing that example `if (process.env.mode === 'development')` output is important. This first try doesn't work:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external process: 'a = "process"
-
-let mode = "development"
-
-if (process["env"]["mode"] === mode) {
-  Js.log("Dev-only code here!")
-}
-```
-```js
-var mode = "development";
-
-if (process.env.mode === mode) {
-  console.log("Dev-only code here!");
-}
-```
-
-</CodeTab>
-
-The JS output shows `if (process.env.mode === mode)`, which isn't what we wanted. To inline `mode`'s value, use `@inline`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external process: 'a = "process"
-
-@inline
-let mode = "development"
-
-if (process["env"]["mode"] === mode) {
-  Js.log("Dev-only code here!")
-}
-```
-```js
-if (process.env.mode === "development") {
-  console.log("Dev-only code here!");
-}
-```
-
-</CodeTab>
-
-Now your resulting JS code can pass through Webpack and Uglifyjs like the rest of your JavaScript code, and that whole `console.log` can be removed.
-
-The inlining currently only works for **string, float and boolean**.
-
-## Tips & Tricks
-
-This is **not** an optimization. This is an edge-case feature for folks who absolutely need particular values inlined for a JavaScript post-processing step, like conditional compilation. Beside the difference in code that the conditional compilation might end up outputting, there's no performance difference between inlining and not inlining simple values in the eyes of a JavaScript engine.
diff --git a/pages/docs/manual/v9.0.0/installation.mdx b/pages/docs/manual/v9.0.0/installation.mdx
deleted file mode 100644
index b219b9580..000000000
--- a/pages/docs/manual/v9.0.0/installation.mdx
+++ /dev/null
@@ -1,77 +0,0 @@
----
-title: "Installation"
-description: "ReScript installation and setup instructions"
-canonical: "/docs/manual/latest/installation"
----
-
-# Installation
-
-Prerequisite: NPM, which comes with [NodeJS](https://nodejs.org/en/). [Yarn](https://yarnpkg.com/en/) also works.
-
-To install ReScript globally:
-
-```sh
-npm install -g bs-platform
-```
-
-## New Project
-
-```sh
-git clone https://github.com/rescript-lang/rescript-project-template
-cd rescript-project-template
-npm install
-npm run build
-node src/Demo.bs.js
-```
-
-That compiles your ReScript into JavaScript, then uses NodeJS to run said JavaScript. **We recommend you use our unique workflow of keeping a tab open for the generated `.bs.js` file**, so that you can learn how ReScript transforms into JavaScript. Not many languages output clean JavaScript code you can inspect and learn from!
-
-During development, instead of running `npm run build` each time to compile, use `npm run start` to start a watcher that recompiles automatically after file changes.
-
-## Integrate Into Existing JS Project
-
-If you already have a JavaScript project into which you'd like to add ReScript:
-
-- Install ReScript locally as a [devDependency](https://docs.npmjs.com/specifying-dependencies-and-devdependencies-in-a-package-json-file):
-  ```sh
-  npm install --save-dev bs-platform
-  ```
-- Create a ReScript build configuration at the root:
-  ```json
-  {
-    "name": "your-project-name",
-    "sources": [
-      {
-        "dir": "src", // update this to wherever you're putting ReScript files
-        "subdirs": true
-      }
-    ],
-    "package-specs": [
-      {
-        "module": "es6",
-        "in-source": true
-      }
-    ],
-    "suffix": ".bs.js",
-    "bs-dependencies": []
-  }
-  ```
-  See [Build Configuration](build-configuration) for more details on `bsconfig.json`.
-- Add convenience `npm` scripts to `package.json`:
-  ```json
-  "scripts": {
-    "re:build": "bsb -make-world -clean-world",
-    "re:start": "bsb -make-world -clean-world -w"
-  }
-  ```
-
-Since ReScript compiles to clean readable JS files, the rest of your existing toolchain (e.g. Babel and Webpack) should just work!
-
-Helpful guides:
-- [Converting from JS](converting-from-js).
-- [Shared Data Types](shared-data-types).
-- [Import from/Export to JS](import-from-export-to-js).
-
-### Integrate with a ReactJS Project
-
-To start a [rescript-react](/docs/react/latest/introduction) app, or to integrate ReScript into an existing ReactJS app, follow the instructions [here](/docs/react/latest/installation).
diff --git a/pages/docs/manual/v9.0.0/interop-cheatsheet.mdx b/pages/docs/manual/v9.0.0/interop-cheatsheet.mdx
deleted file mode 100644
index a509c366a..000000000
--- a/pages/docs/manual/v9.0.0/interop-cheatsheet.mdx
+++ /dev/null
@@ -1,249 +0,0 @@
----
-title: "Interop Cheatsheet"
-description: "Cheatsheet for various interop scenarios in ReScript"
-canonical: "/docs/manual/latest/interop-cheatsheet"
----
-
-# Interop Cheatsheet
-
-This is a glossary with examples. All the features are described by later pages.
-
-## List of Decorators
-
-> **Note:** In previous versions (< 8.3) all our attributes started with a `bs.` prefix. Our formatter will automatically drop them in newer ReScript versions.
-
-<!-- Synced from https://github.com/rescript-lang/syntax/blob/123760c5a264da5288eeee5213ddd25eb86d62fe/src/res_printer.ml#L19-L51 -->
-
-### Attributes
-
-- `@as`: [here](attribute#usage), [here](bind-to-js-function#fixed-arguments), [here](bind-to-js-function#constrain-arguments-better) and [here](generate-converters-accessors#usage-3)
-- [`@deriving`](generate-converters-accessors#generate-functions--plain-values-for-variants)
-- [`@get`](bind-to-js-object#bind-using-special-bs-getters--setters)
-- [`@get_index`](bind-to-js-object#bind-using-special-bs-getters--setters)
-<!-- - `@ignore` -->
-- [`@inline`](inlining-constants)
-- [`@int`](bind-to-js-function#constrain-arguments-better)
-<!-- - `@meth` -->
-- [`@module`](import-from-export-to-js#import-a-javascript-modules-content)
-- [`@new`](bind-to-js-object#bind-to-a-js-object-thats-a-class)
-- [`@obj`](generate-converters-accessors#convert-external-into-js-object-creation-function)
-- [`@optional`](generate-converters-accessors#optional-labels)
-- [`@return`](bind-to-js-function#function-nullable-return-value-wrapping)
-- `@send`: [here](bind-to-js-function#object-method) and [here](pipe#js-method-chaining)
-- [`@scope`](bind-to-global-js-values#global-modules)
-- [`@set`](bind-to-js-object#bind-using-special-bs-getters--setters)
-- [`@set_index`](bind-to-js-object#bind-using-special-bs-getters--setters)
-- [`@variadic`](bind-to-js-function#variadic-function-arguments)
-- [`@string`](bind-to-js-function#constrain-arguments-better)
-- [`@this`](bind-to-js-function#modeling-this-based-callbacks)
-- [`@uncurry`](bind-to-js-function#extra-solution)
-- [`@unwrap`](bind-to-js-function#trick-2-polymorphic-variant--bsunwrap)
-- [`@val`](bind-to-global-js-values#global-modules)
-
-- [`@deprecated`](attribute#usage)
-- [`genType`](https://github.com/reason-association/genType)
-- [`@JSX`](jsx)
-- `@react.component`: [here](/docs/react/latest/introduction) and [here](https://github.com/reasonml/reason-react)
-- [`@warning`](attribute#usage)
-- [`@unboxed`](unboxed)
-
-### Extension Points
-
-- [`%debugger`](embed-raw-javascript#debugger)
-- [`%external`](bind-to-global-js-values#special-global-values)
-<!-- - `%node` -->
-<!-- - `%obj` -->
-- [`%raw`](embed-raw-javascript#paste-raw-js-code)
-- [`%re`](primitive-types#regular-expression)
-
-## Raw JS
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let add = %raw("(a, b) => a + b")
-%%raw("const a = 1")
-```
-```js
-var add = ((a, b) => a + b);
-const a = 1
-```
-
-</CodeTab>
-
-## Global Value
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val external setTimeout: (unit => unit, int) => float = "setTimeout"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Global Module's Value
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val @scope("Math")
-external random: unit => float = "random"
-
-let someNumber = random()
-
-@val @scope(("window", "location", "ancestorOrigins"))
-external length: int = "length"
-```
-```js
-var someNumber = Math.random();
-```
-
-</CodeTab>
-
-## Nullable
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let a = Some(5) // compiles to 5
-let b = None // compiles to undefined
-```
-```js
-var a = 5;
-var b;
-```
-
-</CodeTab>
-
-Handling a value that can be `undefined` and `null`, by ditching the `option` type and using `Js.Nullable.t`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let jsNull = Js.Nullable.null
-let jsUndefined = Js.Nullable.undefined
-let result1: Js.Nullable.t<string> = Js.Nullable.return("hello")
-let result2: Js.Nullable.t<int> = Js.Nullable.fromOption(Some(10))
-let result3: option<int> = Js.Nullable.toOption(Js.Nullable.return(10))
-```
-```js
-var Caml_option = require("./stdlib/caml_option.js");
-var Js_null_undefined = require("./stdlib/js_null_undefined.js");
-
-var jsNull = null;
-var jsUndefined;
-var result1 = "hello";
-var result2 = Js_null_undefined.fromOption(10);
-var result3 = Caml_option.nullable_to_opt(10);
-```
-
-</CodeTab>
-
-## JS Object
-
-- [Bind to a JS object as a ReScript record](bind-to-js-object#bind-to-record-like-js-objects).
-- [Bind to a JS object that acts like a hash map](bind-to-js-object#bind-to-hash-map-like-js-object).
-- [Bind to a JS object that's a class](bind-to-js-object#bind-to-a-js-object-thats-a-class).
-
-## Function
-
-### Object Method & Chaining
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@send external map: (array<'a>, 'a => 'b) => array<'b> = "map"
-@send external filter: (array<'a>, 'a => 'b) => array<'b> = "filter"
-[1, 2, 3]
-  ->map(a => a + 1)
-  ->filter(a => mod(a, 2) == 0)
-  ->Js.log
-```
-```js
-console.log(
-  [1, 2, 3]
-    .map(function (a) {
-      return (a + 1) | 0;
-    })
-    .filter(function (a) {
-      return a % 2 === 0;
-    })
-);
-```
-
-</CodeTab>
-
-### Variadic Arguments
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("path") @variadic
-external join: array<string> => string = "join"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-### Polymorphic Function
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("Drawing") external drawCat: unit => unit = "draw"
-@module("Drawing") external drawDog: (~giveName: string) => unit = "draw"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@val
-external padLeft: (
-  string,
-  @unwrap [
-    | #Str(string)
-    | #Int(int)
-  ])
-  => string = "padLeft"
-
-padLeft("Hello World", #Int(4))
-padLeft("Hello World", #Str("Message from ReScript: "))
-```
-```js
-padLeft("Hello World", 4);
-padLeft("Hello World", "Message from ReScript: ");
-```
-
-</CodeTab>
-
-## JS Module Interop
-
-[See here](import-from-export-to-js.md)
-
-## Dangerous Type Cast
-
-Final escape hatch converter. Do not abuse.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-external convertToFloat: int => float = "%identity"
-let age = 10
-let gpa = 2.1 +. convertToFloat(age)
-```
-```js
-var age = 10;
-var gpa = 2.1 + 10;
-```
-
-</CodeTab>
diff --git a/pages/docs/manual/v9.0.0/interop-with-js-build-systems.mdx b/pages/docs/manual/v9.0.0/interop-with-js-build-systems.mdx
deleted file mode 100644
index 04a34a6c4..000000000
--- a/pages/docs/manual/v9.0.0/interop-with-js-build-systems.mdx
+++ /dev/null
@@ -1,57 +0,0 @@
----
-title: "Interop with JS Build Systems"
-description: "Documentation on how to interact with existing JS build systems"
-canonical: "/docs/manual/latest/interop-with-js-build-systems"
----
-
-# Interop with JS Build Systems
-
-If you come from JS, chances are that you already have a build system in your existing project. Here's an overview of the role bsb would play in your build pipeline, if you want to introduce some ReScript code into the codebase.
-
-> As much as possible, please try not to wrap bsb into your own incremental build framework. ReScript's compilation is very hard to get right, and you'll inevitably run into stale or badly performing builds (therefore erasing much of our value proposition) if you create your own meta layer on top.
-
-## Popular JS Build Systems
-
-The JS ecosystem uses a few build systems: [browserify](http://browserify.org/), [rollup](https://github.com/rollup/rollup), [webpack](https://webpack.js.org/), etc. The latter's probably the most popular of the three (as of 2019 =P). These build systems do both the compilation and the linking (aka, bundling many files into one or few files).
-
-ReScript and bsb only take care of the compilation step; it maps one `.res`/`.resi` file into one JS output file. As such, in theory, no build system integration is needed from our side. From e.g. the webpack watcher's perspective, the JS files ReScript generates are almost equivalent to your hand-written JS files. We also recommend that you initially check in those ReScript-generated JS files, as this workflow means:
-
-- You can introduce ReScript silently into your codebase without disturbing existing infra.
-- You have a **visual** diff of the performance & correctness of your JS file when you update the `.res` files and the JS artifacts change.
-- You can let teammates hot-patch the JS files in emergency situations, without needing to first start learning ReScript.
-- You can remove ReScript completely from your codebase and things will still work (in case your company decides to stop using us for whatever reason).
-
-For what it's worth, you can also turn bsb into an automated step in your build pipeline, e.g. into a webpack loader; but such approach is error-prone and therefore discouraged.
-
-### Tips & Tricks
-
-You can make ReScript JS files look even more idiomatic through the in-source + bs suffix config in `bsconfig.json`:
-
-```json
-{
-  "package-specs": {
-    "module": "commonjs", // or whatever module system your project uses
-    "in-source": true
-  },
-  "suffix": ".bs.js"
-}
-```
-
-This will:
-
-- Generate the JS files alongside your ReScript source files.
-- Use the file extension `.bs.js`, so that you can require these files on the JS side through `require('./MyFile.bs')`, without needing a loader.
-
-## Use Loaders on ReScript Side
-
-"What if my build system uses a CSS/png/whatever loader and I'd like to use it in ReScript?"
-
-Loaders are indeed troublesome; in the meantime, please use e.g. `%raw("require('./myStyles.css')")` at the top of your file. This just uses [`raw`](embed-raw-javascript.md) to compile the snippet into an actual JS require.
-
-## Getting Project's Dependencies
-
-`bsb` generates one `MyFile.d` file per `MyFile` source file; you'll find them in `lib/bs`. These are human readable, machine-friendly list of the dependencies of said `MyFile`. You can read into them for your purpose (though mind the IO overhead). Use these files instead of creating your own dependency graph; we did the hard work of tracking the dependencies as best as possible (including inner modules, `open`s, module names overlap, etc).
-
-## Run Script Per File Built
-
-See [js-post-build](build-configuration#js-post-build). Though please use it sparingly; if you hook up a node.js script after each file built, you'll incur the node startup time per file!
diff --git a/pages/docs/manual/v9.0.0/introduction.mdx b/pages/docs/manual/v9.0.0/introduction.mdx
deleted file mode 100644
index 9fa73cdca..000000000
--- a/pages/docs/manual/v9.0.0/introduction.mdx
+++ /dev/null
@@ -1,80 +0,0 @@
----
-title: "Introduction"
-description: "The hows and whys of ReScript"
-canonical: "/docs/manual/latest/introduction"
----
-
-# ReScript
-
-Ever wanted a language like JavaScript, but without the warts, with a great type system, and with a lean build toolchain that doesn't waste your time?
-
-ReScript looks like JS, acts like JS, and compiles to the highest quality of clean, readable and performant JS, directly runnable in browsers and Node.
-
-**This means you can pick up ReScript and access the vast JavaScript ecosystem and tooling as if you've known ReScript for a long time!**
-
-**ReScript is the language for folks who don't necessarily love JavaScript, but who still acknowledge its importance**.
-
-## Difference vs TypeScript
-
-We respect TypeScript very much and think that it's a positive force in the JavaScript ecosystem. ReScript shares some of the same goals as TypeScript, but is different enough regarding some important nuances:
-
-- TypeScript's (admittedly noble) goal is to cover the entire JavaScript feature set and more. **ReScript covers only a curated subset of JavaScript**. For example, we emphasize plain data + functions over classes, clean [pattern matching](pattern-matching-destructuring.md) over fragile `if`s and virtual dispatches, [proper data modeling](variant.md) over string abuse, etc. JavaScript supersets will only grow larger over time; ReScript doesn't. \*
-
-- Consequently, TypeScript's type system is necessarily complex, pitfalls-ridden, potentially requires tweaking, sometimes slow, and requires quite a bit of noisy annotations that often feel like manual bookkeeping rather than clear documentation. In contrast, ReScript's type system:
-
-  - Is deliberately curated to be a simple subset most folks will have an easier time to use.
-  - Has **no** pitfalls, aka the type system is "sound" (the types will always be correct). E.g. If a type isn't marked as nullable, its value will never lie and let through some `undefined` value silently. **ReScript code has no null/undefined errors**.
-  - Is the same for everyone. No knobs, no bikeshedding opportunity.
-  - Runs extremely fast precisely thanks to its simplicity and curation. It's one of the fastest compiler & build system toolchains for JavaScript development.
-  - **Doesn't need type annotations**. Annotate as much or as little as you'd like. The types are inferred by the language (and, again, are guaranteed correct).
-
-- Migrating to TypeScript is done "breadth-first," whereas migrating to ReScript is done "depth-first." You can convert your codebase to TypeScript by "turning it on" for all files and annotate here and there; but how much type safety did you gain? How do you measure it? Type errors can still slip in and out of the converted pieces. For ReScript, our interop features draw clear boundaries: there's pure ReScript code, and there's JS interop code. Every piece of converted ReScript code is 100% clean. You'd convert file by file and each conversion increases your safety monotonically.
-
-\* When you absolutely need to write or interoperate with free-for-all JavaScript, we expose enough escape hatches for you.
-
-## Other Highlights
-
-Aside from the aforementioned simple, robust and fast type system, ReScript presents a few more advantages.
-
-### Faster than JavaScript
-
-JavaScript's been aggressively optimized by talented engineers over a long span. Unfortunately, even for seasoned JS devs, it can be hard to know how to properly leverage JS's performance. ReScript's type system and compiler naturally guides you toward writing code that's very often performant by default, with good leverage of various Just-In-Time optimizations (hidden classes, inline caching, avoiding deopts, etc).
-
-A widespread adage to write fast JavaScript code is to write as if there's a type system (in order to trigger JS engines' good optimization heuristics); ReScript gives you a real one and generates code that's friendly to optimizations by default.
-
-### High Quality Dead Code Elimination
-
-The JavaScript ecosystem is very reliant on dependencies. Shipping the final product inevitably drags in a huge amount of code, lots of which the project doesn't actually use. These regions of dead code impact loading, parsing and interpretation speed. ReScript provides powerful dead code elimination at all levels:
-
-- Function- and module-level code elimination is facilitated by the well-engineered type system and purity analysis.
-- At the global level, ReScript generates code that is naturally friendly to dead code elimination done by bundling tools such as [Rollup](https://github.com/rollup/rollup) and [Closure Compiler](https://developers.google.com/closure/compiler/), after its own sophisticated elimination pass.
-- The same applies for ReScript's own tiny runtime (which is written in ReScript itself).
-
-### Tiny JS Output
-
-A `Hello world` ReScript program generates **20 bytes** of JS code. Additionally, the standard library pieces you require in are only included when needed.
-
-### Fast Iteration Loop
-
-ReScript's build time is **one or two orders of magnitude** faster than alternatives. In its watcher mode, the build system usually finishes before you switch screen from the editor to the terminal tab (two digits of milliseconds). A fast iteration cycle reduces the need of keeping one's mental state around longer; this in turn allows one to stay in the flow longer and more often.
-
-### Readable Output & Great Interop
-
-Unreadable JavaScript code generated from other compiled-to-js languages makes it so that it could be, practically speaking:
-
-- Hard to debug (cryptic stack trace, mangled variable names)
-- Hard to learn from (non-straightforward mapping of concepts from one language to another)
-- Hard to profile for performance (unclear what runtime performance cost there is)
-- Hard to integrate with existing hand-written JS code
-
-ReScript's JS output is very readable. This is especially important while learning, where users might want to understand how the code's compiled, and to audit for bugs.
-
-This characteristic, combined with a fully-featured JS interop system, allows ReScript code to be inserted into an existing JavaScript codebase almost unnoticed.
-
-### Preservation of Code Structure
-
-ReScript maps one source file to one JavaScript output file. This eases the integration of existing tools such as bundlers and test runners. You can even start writing a single file without much change to your build setup. Each file's code structure is approximately preserved, too.
-
-## Conclusion
-
-We hope the above gave you enough of an idea of ReScript and its differentiators. Feel free to [try it online](/try) to get a feel!
diff --git a/pages/docs/manual/v9.0.0/json.mdx b/pages/docs/manual/v9.0.0/json.mdx
deleted file mode 100644
index b223cc228..000000000
--- a/pages/docs/manual/v9.0.0/json.mdx
+++ /dev/null
@@ -1,55 +0,0 @@
----
-title: "JSON"
-description: "Interacting with JSON in ReScript"
-canonical: "/docs/manual/latest/json"
----
-
-# JSON
-
-## Parse
-
-Bind to JavaScript's `JSON.parse` and type the return value as the type you're expecting:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// declare the shape of the json you're binding to
-type data = {names: array<string>}
-
-// bind to JS' JSON.parse
-@scope("JSON") @val
-external parseIntoMyData: string => data = "parse"
-
-let result = parseIntoMyData(`{"names": ["Luke", "Christine"]}`)
-let name1 = result.names[0]
-```
-```js
-var result = JSON.parse("{\"names\": [\"Luke\", \"Christine\"]}");
-var name1 = result.names[0];
-```
-
-</CodeTab>
-
-Where `data` can be any type you assume the JSON is. As you can see, this compiles to a straightforward `JSON.parse` call. As with regular JS, this is convenient, but has no guarantee that e.g. the data is correctly shaped, or even syntactically valid. Slightly dangerous.
-
-## Stringify
-
-Use `Js.Json.stringify`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-Js.log(Js.Json.stringifyAny(["Amy", "Joe"]))
-```
-```js
-console.log(JSON.stringify([
-  "Amy",
-  "Joe"
-]));
-```
-
-</CodeTab>
-
-## Advanced
-
-The [Js.Json](api/js/json) module provides slightly safer, low-level building blocks for power users who want to parse JSON on a per-field basis. See the examples in the API docs.
diff --git a/pages/docs/manual/v9.0.0/jsx.mdx b/pages/docs/manual/v9.0.0/jsx.mdx
deleted file mode 100644
index b1690b2c4..000000000
--- a/pages/docs/manual/v9.0.0/jsx.mdx
+++ /dev/null
@@ -1,260 +0,0 @@
----
-title: "JSX"
-description: "JSX syntax in ReScript and React"
-canonical: "/docs/manual/latest/jsx"
----
-
-# JSX
-
-Would you like some HTML syntax in your ReScript? If not, quickly skip over this section and pretend you didn't see anything!
-
-ReScript supports the JSX syntax, with some slight differences compared to the one in [ReactJS](https://facebook.github.io/react/docs/introducing-jsx.html). ReScript JSX isn't tied to ReactJS; they translate to normal function calls:
-
-**Note** for [ReasonReact](https://reasonml.github.io/reason-react/en/) readers: this isn't what ReasonReact turns JSX into, in the end. See Usage section for more info.
-
-## Capitalized Tag
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<MyComponent name={"ReScript"} />
-```
-```js
-React.createElement(
-  MyComponent.make,
-  MyComponent.makeProps("ReScript", undefined)
-);
-```
-
-</CodeTab>
-
-becomes
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@JSX MyComponent.createElement(~name="ReScript", ~children=list{}, ())
-```
-```js
-React.createElement(
-  MyComponent.make,
-  MyComponent.makeProps("ReScript", undefined)
-);
-```
-
-</CodeTab>
-
-## Uncapitalized Tag
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<div onClick={handler}> child1 child2 </div>
-```
-```js
-React.createElement("div", {
-  onClick: handler
-}, child1, child2);
-```
-
-</CodeTab>
-
-becomes
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@JSX div(~onClick=handler, ~children=list{child1, child2}, ())
-```
-```js
-React.createElement("div", {
-  onClick: handler
-}, child1, child2);
-```
-
-</CodeTab>
-
-## Fragment
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<> child1 child2 </>
-```
-```js
-React.createElement(React.Fragment, undefined, child1, child2);
-```
-
-</CodeTab>
-
-becomes
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@JSX list{child1, child2}
-```
-```js
-React.createElement(React.Fragment, undefined, child1, child2);
-```
-
-</CodeTab>
-
-### Children
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<MyComponent> child1 child2 </MyComponent>
-```
-```js
-React.createElement(MyComponent.make, MyComponent.makeProps(null, undefined), child1, child2);
-```
-
-</CodeTab>
-
-This is the syntax for passing a list of two items, `child1` and `child2`, to the children position. It desugars to a list containing `child1` and `child2`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@JSX MyComponent.createElement(~children=list{child1, child2}, ())
-```
-```js
-React.createElement(MyComponent.make, MyComponent.makeProps(null, undefined), child1, child2);
-```
-
-</CodeTab>
-
-**Note** again that this isn't the transform for ReasonReact; ReasonReact turns the final list into an array. But the idea still applies.
-
-So naturally, `<MyComponent> myChild </MyComponent>` desugars to `@JSX MyComponent.createElement(~children=list{myChild}, ())`. I.e. whatever you do, the arguments passed to the children position will be wrapped in a list. What if you don't want that? **What if you want to directly pass `myChild` without an extra wrapping**?
-
-#### Children Spread
-
-To solve the above problem, we've introduced
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<MyComponent> ...myChild </MyComponent>
-```
-```js
-React.createElement(MyComponent.make, MyComponent.makeProps(myChild, undefined));
-```
-
-</CodeTab>
-
-This passes the value `myChild` _without_ wrapping it in a list (or array, in the case of ReasonReact). Aka, this desugars to:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@JSX MyComponent.createElement(~children=myChild, ())
-```
-```js
-React.createElement(MyComponent.make, MyComponent.makeProps(myChild, undefined));
-```
-
-</CodeTab>
-
-This is extra useful in the cases where you are handled `myChild` that is already a list of things, and want to forward that without wrapping it an extra time (which would be a type error) \*. It also allows you to pass arbitrary data structures at `children` position (remember, JSX `children` is really just a totally normal prop):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<MyComponent> ...((theClassName) => <div className=theClassName />) </MyComponent>
-
-<MyForm> ...("Hello", "Submit") </MyForm>
-```
-```js
-React.createElement(
-  make,
-  makeProps(function (theClassName) {
-    return React.createElement("div", {
-      className: theClassName,
-    });
-  }, undefined)
-);
-
-React.createElement(MyForm.make, MyForm.makeProps(["Hello", "Submit"], undefined));
-```
-
-</CodeTab>
-
-## Usage
-
-See [ReasonReact JSX](https://reasonml.github.io/reason-react/docs/en/jsx) for an example application of JSX, which transforms the above calls into a ReasonReact-specific call.
-
-Here's a JSX tag that shows most of the features.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<MyComponent
-  booleanAttribute={true}
-  stringAttribute="string"
-  intAttribute=1
-  forcedOptional=?{Some("hello")}
-  onClick={handleClick}>
-  <div> {React.string("hello")} </div>
-</MyComponent>
-```
-```js
-React.createElement(
-  MyComponent.make,
-  MyComponent.makeProps(
-    true,
-    "string",
-    1,
-    "hello",
-    handleClick,
-    React.createElement("div", undefined, "hello"),
-    undefined
-  )
-);
-```
-
-</CodeTab>
-
-## Departures From JS JSX
-
-- Attributes and children don't mandate `{}`, but we show them anyway for ease of learning. Once you format your file, some of them go away and some turn into parentheses.
-- There is no support for JSX prop spread: `<Comp {...props} />`. Though somewhat related,  we do have children spread, described above: `<Comp> ...children </Comp>`.
-- Punning!
-
-### Punning
-
-"Punning" refers to the syntax shorthand for when a label and a value are the same. For example, in JavaScript, instead of doing `return {name: name}`, you can do `return {name}`.
-
-Reason JSX supports punning. `<input checked />` is just a shorthand for `<input checked=checked />`. The formatter will help you format to the punned syntax whenever possible. This is convenient in the cases where there are lots of props to pass down:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-<MyComponent isLoading text onClick />
-```
-```js
-React.createElement(
-  MyComponent.make,
-  MyComponent.makeProps(isLoading, text, onClick, undefined)
-);
-```
-
-</CodeTab>
-
-Consequently, a Reason JSX component can cram in a few more props before reaching for extra libraries solutions that avoids props passing.
-
-**Note** that this is a departure from ReactJS JSX, which does **not** have punning. ReactJS' `<input checked />` desugars to `<input checked=true />`, in order to conform to DOM's idioms and for backward compatibility.
-
-## Tip & Tricks
-
-For library authors wanting to take advantage of the JSX: the `@JSX` attribute above is a hook for potential ppx macros to spot a function wanting to format as JSX. Once you spot the function, you can turn it into any other expression.
-
-This way, everyone gets to benefit the JSX syntax without needing to opt into a specific library using it, e.g. ReasonReact.
-
-JSX calls supports the features of [labeled functions](function.md#labeled-arguments): optional, explicitly passed optional and optional with default.
-
-## Design Decisions
-
-\* You might wonder why you never needed such children spread in ReactJS; ReactJS uses some special runtime logic + special syntax transforms + variadic argument detection & marking to avoid most of these cases ([see here](https://github.com/facebook/react/blob/9b36df86c6ccecb73ca44899386e6a72a83ad445/packages/react/src/ReactElement.js#L207)). Such dynamic usage complexifies the type system detection _quite a bit_. Since we control the whole syntax and ReasonReact, we decided to introduce children spread to disambiguate between the case of wrapping vs not wrapping, without compile-time & runtime cost!
diff --git a/pages/docs/manual/v9.0.0/lazy-values.mdx b/pages/docs/manual/v9.0.0/lazy-values.mdx
deleted file mode 100644
index 7fde6bb26..000000000
--- a/pages/docs/manual/v9.0.0/lazy-values.mdx
+++ /dev/null
@@ -1,123 +0,0 @@
----
-title: "Lazy Value"
-description: "Data type for deferred computation in ReScript"
-canonical: "/docs/manual/latest/lazy-values"
----
-
-# Lazy Value
-
-If you have some expensive computations you'd like to **defer and cache** subsequently, you can wrap it with `lazy`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-// Read the directory, only once
-let expensiveFilesRead = lazy({
-  Js.log("Reading dir")
-  Node.Fs.readdirSync("./pages")
-})
-```
-```js
-var Fs = require("fs");
-
-var expensiveFilesRead = {
-  LAZY_DONE: false,
-  VAL: (function () {
-    console.log("Reading dir");
-    return Fs.readdirSync("./pages");
-  })
-};
-```
-
-</CodeTab>
-
-Check the JS Output tab: that `expensiveFilesRead`'s code isn't executed yet, even though you declared it! You can carry it around without fearing that it'll run the directory read.
-
-**Note**: a lazy value is **not** a [shared data type](shared-data-types.md). Don't rely on its runtime representation in your JavaScript code.
-
-## Execute The Lazy Computation
-
-To actually run the lazy value's computation, use `Lazy.force` from the globally available `Lazy` module:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// First call. The computation happens
-Js.log(Lazy.force(expensiveFilesRead)) // logs "Reading dir" and the directory content
-
-// Second call. Will just return the already calculated result
-Js.log(Lazy.force(expensiveFilesRead)) // logs the directory content
-```
-```js
-console.log(CamlinternalLazy.force(expensiveFilesRead));
-
-console.log(CamlinternalLazy.force(expensiveFilesRead));
-```
-
-</CodeTab>
-
-The first time `Lazy.force` is called, the expensive computation happens and the result is **cached**. The second time, the cached value is directly used.
-
-**You can't re-trigger the computation after the first `force` call**. Make sure you only use a lazy value with computations whose results don't change (e.g. an expensive server request whose response is always the same).
-
-Instead of using `Lazy.force`, you can also use [pattern matching](pattern-matching-destructuring.md) to trigger the computation:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch expensiveFilesRead {
-| lazy(result) => Js.log(result)
-}
-```
-```js
-var result = CamlinternalLazy.force(expensiveFilesRead);
-```
-
-</CodeTab>
-
-Since pattern matching also works on a `let` binding, you can also do:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let lazy(result) = expensiveFilesRead
-Js.log(result)
-```
-```js
-var result = CamlinternalLazy.force(expensiveFilesRead);
-console.log(result);
-```
-
-</CodeTab>
-
-## Exception Handling
-
-For completeness' sake, our files read example might raise an exception because of `readdirSync`. Here's how you'd handle it:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let result = try {
-  Lazy.force(expensiveFilesRead)
-} catch {
-| Not_found => [] // empty array of files
-}
-```
-```js
-var result;
-
-try {
-  result = CamlinternalLazy.force(expensiveFilesRead);
-} catch (raw_exn) {
-  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-  if (exn.RE_EXN_ID === "Not_found") {
-    result = [];
-  } else {
-    throw exn;
-  }
-}
-```
-
-</CodeTab>
-
-Though you should probably handle the exception inside the lazy computation itself.
diff --git a/pages/docs/manual/v9.0.0/let-binding.mdx b/pages/docs/manual/v9.0.0/let-binding.mdx
deleted file mode 100644
index f746be3ab..000000000
--- a/pages/docs/manual/v9.0.0/let-binding.mdx
+++ /dev/null
@@ -1,185 +0,0 @@
----
-title: "Let Binding"
-description: "Let binding syntax for binding to values in ReScript"
-canonical: "/docs/manual/latest/let-binding"
----
-
-# Let Binding
-
-A "let binding", in other languages, might be called a "variable declaration". `let` _binds_ values to names. They can be seen and referenced by code that comes _after_ them.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let greeting = "hello!"
-let score = 10
-let newScore = 10 + score
-```
-```js
-var greeting = "hello!";
-var score = 10;
-var newScore = 20;
-```
-
-</CodeTab>
-
-## Block Scope
-
-Bindings can be scoped through `{}`.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let message = {
-  let part1 = "hello"
-  let part2 = "world"
-  part1 ++ " " ++ part2
-}
-// `part1` and `part2` not accessible here!
-```
-```js
-var message = "hello world";
-```
-
-</CodeTab>
-
-The value of the last line of a scope is implicitly returned.
-
-### Design Decisions
-
-ReScript's `if`, `while` and functions all use the same block scoping mechanism. The code below works **not** because of some special "if scope"; but simply because it's the same scope syntax and feature you just saw:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-if displayGreeting {
-  let message = "Enjoying the docs so far?"
-  Js.log(message)
-}
-// `message` not accessible here!
-```
-```js
-if (displayGreeting) {
-  console.log("Enjoying the docs so far?");
-}
-```
-
-</CodeTab>
-
-## Bindings Are Immutable
-
-Let bindings are "immutable", aka "cannot change". This helps our type system deduce and optimize much more than other languages (and in turn, help you more).
-
-## Binding Shadowing
-
-The above restriction might sound unpractical at first. How would you change a value then? Usually, 2 ways:
-
-The first is to realize that many times, what you want isn't to mutate a variable's value. For example, this JavaScript pattern:
-
-```js
-var result = 0;
-result = calculate(result);
-result = calculateSomeMore(result);
-```
-
-...is really just to comment on intermediate steps. You didn't need to mutate `result` at all! You could have just written this JS:
-
-```js
-var result1 = 0;
-var result2 = calculate(result1);
-var result3 = calculateSomeMore(result2);
-```
-
-In ReScript, this obviously works too:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result1 = 0
-let result2 = calculate(result1)
-let result3 = calculateSomeMore(result2)
-```
-```js
-var result1 = 0;
-var result2 = calculate(0);
-var result3 = calculateSomeMore(result2);
-```
-
-</CodeTab>
-
-Additionally, reusing the same let binding name overshadows the previous bindings with the same name. So you can write this too:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result = 0
-let result = calculate(result)
-let result = calculateSomeMore(result)
-```
-```js
-var result = calculate(0);
-var result$1 = calculateSomeMore(result);
-```
-
-</CodeTab>
-
-(Though for the sake of clarity, we don't recommend this).
-
-As a matter of fact, even this is valid code:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let result = "hello"
-Js.log(result) // prints "hello"
-let result = 1
-Js.log(result) // prints 1
-```
-```js
-var result = 1;
-console.log("hello");
-console.log(1);
-```
-
-</CodeTab>
-
-The binding you refer to is whatever's the closest upward. No mutation here!
-If you need _real_ mutation, e.g. passing a value around, have it modified by many pieces of code, we provide a slightly heavier [mutation feature](mutation.md).
-
-## Private let bindings
-
-Private let bindings are introduced in the release [7.2](https://rescript-lang.org/blog/bucklescript-release-7-2).
-
-In the module system, everything is public by default, 
-the only way to hide some values is by providing a separate signature to 
-list public fields and their types:
-
-```res
-module A: {
-  let b: int
-} = {
-  let a = 3
-  let b = 4
-}
-```
-`%private` gives you an option to mark private fields directly
-
-```res
-module A = {
-  %%private(let a = 3)
-  let b = 4
-}
-```
-
-`%private` also applies to file level modules, so in some cases, 
-users do not need to provide a separate interface file just to hide some particular values.
-
-Note interface files are still recommended as a general best practice since they give you better 
-separate compilation units and also they're better for documentation. 
-
-Still, `%private` is useful in the following scenarios:
-
-- Code generators. Some code generators want to hide some values but it is sometimes very hard or time consuming for code generators to synthesize the types for public fields.
-
-- Quick prototyping. During prototyping, we still want to hide some values, but the interface file is not stable yet. `%private` provides you such convenience.
-
diff --git a/pages/docs/manual/v9.0.0/libraries.mdx b/pages/docs/manual/v9.0.0/libraries.mdx
deleted file mode 100644
index 57876b799..000000000
--- a/pages/docs/manual/v9.0.0/libraries.mdx
+++ /dev/null
@@ -1,27 +0,0 @@
----
-title: "Libraries & Publishing"
-description: "Install & publish ReScript packages"
-canonical: "/docs/manual/latest/libraries"
----
-
-# Libraries & Publishing
-
-ReScript libraries are just like JavaScript libraries: published & hosted on [NPM](http://npmjs.com). You can reuse your `npm`, `yarn` and `package.json`-related tools to manage them!
-
-## Tips & Tricks
-
-### Publish
-
-We recommend you to check in your compiled JavaScript output, for its [various benefits](interop-with-js-build-systems.md#popular-js-build-systems). If not, then at least consider publishing the JavaScript output by un-ignoring them in your [npmignore](https://docs.npmjs.com/cli/v7/using-npm/developers#keeping-files-out-of-your-package). This way, your published ReScript package comes with plain JavaScript files that JS users can consume. If your project's good, JS users might not even realize that they've installed a library written in ReScript!
-
-In case your library is only consumed by JS users, you may want to check out our [external stdlib](./build-external-stdlib) configuration as well.
-
-### Find Libraries
-
-Search `rescript`-related packages on NPM, or use our [Package Index](/packages).
-
-If you can't find what you're looking for, remember that **you don't need a wrapper** to use a JS library:
-
-- Most JS data types, such as array and objects, [map over cleanly to ReScript and vice-versa](shared-data-types.md).
-- You also have access to the familiar [JS API](api/js).
-- You can use a JavaScript library without needing to install dedicated binding libraries. Check the [`external`](external) page.
diff --git a/pages/docs/manual/v9.0.0/migrate-from-bucklescript-reason.mdx b/pages/docs/manual/v9.0.0/migrate-from-bucklescript-reason.mdx
deleted file mode 100644
index 27d476461..000000000
--- a/pages/docs/manual/v9.0.0/migrate-from-bucklescript-reason.mdx
+++ /dev/null
@@ -1,61 +0,0 @@
----
-title: "Migrate to ReScript Syntax"
-description: "Instructions on upgrading from Reason to ReScript"
-canonical: "/docs/manual/latest/migrate-to-new-syntax"
----
-
-# Migrate from BuckleScript/Reason
-
-ReScript is a rebranding and cleanup of BuckleScript (since `v8.2.0`) & Reason (`v3.6`) that enables us to ship a tighter compile-to-JS stack with more coherent documentation & tools. If you're an existing user of BuckleScript & Reason, here's the gist:
-
-- ReScript is mostly just BuckleScript rebranded, with a new syntax that's like the Reason syntax, but catered more toward the JavaScript crowd.
-- All your existing code will keep working even if you don't upgrade.
-
-## Upgrade Your Codebase
-
-There are lots of exciting improvements in the new syntax (features, speed, error messages, etc.). The upgrade is trivial, backward-compatible and can be done on a per-file basis:
-
-- Upgrade your project to `bs-platform 8.2.0` or later.
-- Choose a file to convert, for example `MyFile.re`
-- Compile your project and keep the generated JavaScript file around (probably `MyFile.bs.js` but might depend on your `bsconfig.json` config).
-- Run `node_modules/.bin/bsc -format MyFile.re > MyFile.res`.
-- If your new `MyFile.res` looks good, you can delete (or move/rename) `MyFile.re` before compiling again your project (otherwise you will have an error `Invalid bsconfig.json implementation and interface have different path names or different cases MyFile vs MyFile` because 2 files with the same module name (file basename)  cannot coexist in your project).
-- Last thing you can do to ensure conversion is correct: build your project with the new `MyFile.res` file to compare the newly generated JavaScript file with the old one. You should get almost identical generated JavaScript code.
-
-**That's it**! `MyFile.re` could be any `.re`, `.rei`, `.ml` and `.mli` file.
-
-Enjoy the improved experience!
-
-### Upgrade an Entire Folder
-
-Please use this with caution. Migrating an entire codebase at once is an unnecessary risk.
-It is recommended to migrate small portion of code to ensure correctness.
-That being said, for small codebases or some tiny folders that are safely versioned, you can try the following:
-
-```console
-for f in your-folder/**/*.re; do; node_modules/.bin/bsc -format $f > ${f%.re}.res && rm $f; done;
-```
-
-This command loops on the `.re` files from the `your-folder` folder, converts them with a proper `.res` extension, and asks you if you want to remove the previous file (check the newly created `.res` file first and refer to instructions above to follow the check to do on your generated JavaScript).
-If you are confident enough, you can add `-f` option to the `rm` command to avoid all checks. This will convert your entire folder without any confirmations.
-
-## Difference With Old Reason
-
-- Complete removal of semicolon (you can still write them).
-- No need for parentheses around `if`, `switch` and `try`.
-- Type arguments: from `option(int)` to `option<int>`.
-- Old interpolated string: from `{j|hello ${name}|j}` to `` j`hello ${name}` ``. Now with proper unicode support!
-- New interpolated string: `` `hello world` ``. Also supports multiline and unicode. `"hello world"` string is now singleline.
-- Polymorphic variants: from `` `red`` to `#red`.
-- Arrays: from `[|1,2,3|]` to `[1,2,3]`. In JS, arrays are the right default.
-- Lists: from `[1,2,3]` to `list[1,2,3]` (_8.1.1 update_: now it is `list{1, 2, 3}`). This ties with upcoming plans to access containers in a uniform way: `set[...]` and `map[...]`. Maybe temporary.
-- Exception: from `try (compute()) { | Not_found => Js.log("oops")}` to `try compute() catch { | Not_found => Js.log("oops")}`.
-- First class module: from `(module S: Student)` to `module(S: Student)`.
-- No custom infix operator for now (including `mod`).
-- Object access: from `settings##visible #= true` to `settings["visible"] = true`. Rejoice!
-- Object: from `Js.t({"age": int})` to just `{"age": int}`. The `Js.t` part is now implicit.
-- Attribute: from `[@myAttribute "hello"]` to `@myAttribute("hello")`. From `[%re bla]` to `%re(bla)`.
-- Removed dereference syntax `result^`. Just use `result.contents`.
-- `fun` pattern matching syntax removed.
-- Type declaration is non-recursive by default, consistent with let bindings. To have recursive types, use `type rec myList<'a> = Nil | Cons('a, myList<'a>)`.
-- Use any words, including reserved keywords, as your identifier name: `let \"try" = true`.
diff --git a/pages/docs/manual/v9.0.0/module.mdx b/pages/docs/manual/v9.0.0/module.mdx
deleted file mode 100644
index 8b76a1458..000000000
--- a/pages/docs/manual/v9.0.0/module.mdx
+++ /dev/null
@@ -1,533 +0,0 @@
----
-title: "Module"
-description: "ReScript modules, module signatures and interface files"
-canonical: "/docs/manual/latest/module"
----
-
-# Module
-
-## Basics
-
-**Modules are like mini files**! They can contain type definitions, `let`
-bindings, nested modules, etc.
-
-### Creation
-
-To create a module, use the `module` keyword. The module name must start with a
-**capital letter**. Whatever you could place in a `.res` file, you may place
-inside a module definition's `{}` block.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module School = {
-  type profession = Teacher | Director
-
-  let person1 = Teacher
-  let getProfession = (person) =>
-    switch person {
-    | Teacher => "A teacher"
-    | Director => "A director"
-    }
-}
-```
-```js
-function getProfession(person) {
-  if (person) {
-    return "A director";
-  } else {
-    return "A teacher";
-  }
-}
-
-var School = {
-  person1: /* Teacher */0,
-  getProfession: getProfession
-};
-```
-
-</CodeTab>
-
-A module's contents (including types!) can be accessed much like a record's,
-using the `.` notation. This demonstrates modules' utility for namespacing.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let anotherPerson: School.profession = School.Teacher
-Js.log(School.getProfession(anotherPerson)) /* "A teacher" */
-```
-```js
-var anotherPerson = /* Teacher */0;
-console.log("A teacher");
-```
-
-</CodeTab>
-
-Nested modules work too.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module MyModule = {
-  module NestedModule = {
-    let message = "hello"
-  }
-}
-
-let message = MyModule.NestedModule.message
-```
-```js
-var NestedModule = {
-  message: message
-};
-
-var MyModule = {
-  NestedModule: NestedModule
-};
-
-var message = MyModule.NestedModule.message;
-```
-
-</CodeTab>
-
-### `open`ing a module
-
-Constantly referring to a value/type in a module can be tedious. Instead, we can "open" a module and refer to its contents without always prepending them with the
-module's name. Instead of writing:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let p = School.getProfession(School.person1)
-```
-```js
-var p = School.getProfession(School.person1);
-```
-
-</CodeTab>
-
-We can write:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-open School
-let p = getProfession(person1)
-```
-```js
-var p = School.getProfession(School.person1);
-```
-
-</CodeTab>
-
-The content of `School` module are made visible (**not** copied into the file, but simply made visible!) in scope. `profession`, `getProfession` and `person1` will thus correctly be found.
-
-**Use `open` this sparingly, it's convenient, but makes it hard to know where some values come from**. You should usually use `open` in a local scope:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let p = {
-  open School
-  getProfession(person1)
-}
-/* School's content isn't visible here anymore */
-```
-```js
-var p = School.getProfession(School.person1);
-```
-
-</CodeTab>
-
-### Use `open!` to ignore shadow warnings
-
-There are situations where `open` will cause a warning due to existing identifiers (bindings, types) being redefined. Use `open!` to explicitly tell the compiler that this is desired behavior.
-
-```res
-let map = (arr, value) => {
-  value
-}
-
-// opening Js.Array2 would shadow our previously defined `map`
-// `open!` will explicitly turn off the automatic warning
-open! Js.Array2
-let arr = map([1,2,3], (a) => { a + 1})
-```
-
-**Note:** Same as with `open`, don't overuse `open!` statements if not necessary. Use (sub)modules to prevent shadowing issues.
-
-### Extending modules
-
-Using `include` in a module statically "spreads" a module's content into a new one, thus often fulfill the role of "inheritance" or "mixin".
-
-**Note**: this is equivalent to a compiler-level copy paste. **We heavily discourage `include`**. Use it as last resort!
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module BaseComponent = {
-  let defaultGreeting = "Hello"
-  let getAudience = (~excited) => excited ? "world!" : "world"
-}
-
-module ActualComponent = {
-  /* the content is copied over */
-  include BaseComponent
-  /* overrides BaseComponent.defaultGreeting */
-  let defaultGreeting = "Hey"
-  let render = () => defaultGreeting ++ " " ++ getAudience(~excited=true)
-}
-```
-```js
-function getAudience(excited) {
-  if (excited) {
-    return "world!";
-  } else {
-    return "world";
-  }
-}
-
-var BaseComponent = {
-  defaultGreeting: "Hello",
-  getAudience: getAudience
-};
-
-var defaultGreeting = "Hey";
-
-function render(param) {
-  return "Hey world!";
-}
-
-var ActualComponent = {
-  getAudience: getAudience,
-  defaultGreeting: defaultGreeting,
-  render: render
-};
-```
-
-</CodeTab>
-
-**Note**: `open` and `include` are very different! The former brings a module's content into your current scope, so that you don't have to refer to a value by prefixing it with the module's name every time. The latter **copies over** the definition of a module statically, then also do an `open`.
-
-### Every `.res` file is a module
-
-Every ReScript file is itself compiled to a module of the same name as the file name, capitalized. The file `React.res` implicitly forms a module `React`, which can be seen by other source files.
-
-**Note**: ReScript file names should, by convention, be capitalized so that their casing matches their module name. Uncapitalized file names are not invalid, but will be implicitly transformed into a capitalized module name. I.e. `file.res` will be compiled into the module `File`. To simplify and minimize the disconnect here, the convention is therefore to capitalize file names.
-
-## Signatures
-
-A module's type is called a "signature", and can be written explicitly. If a
-module is like a `.res` (implementation) file, then a module's signature is like
-a `.resi` (interface) file.
-
-### Creation
-
-To create a signature, use the `module type` keyword. The signature name must start with a
-**capital letter**. Whatever you could place in a `.resi` file, you may place
-inside a signature definition's `{}` block.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-/* Picking up previous section's example */
-module type EstablishmentType = {
-  type profession
-  let getProfession: profession => string
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-A signature defines the list of requirements that a module must satisfy in order
-for that module to match the signature. Those requirements are of the form:
-
-- `let x: int` requires a `let` binding named `x`, of type `int`.
-- `type t = someType` requires a type field `t` to be equal to `someType`.
-- `type t` requires a type field `t`, but without imposing any requirements on the actual, concrete type of `t`. We'd use `t` in other entries in the signature to describe relationships, e.g. `let makePair: t => (t, t)` but we cannot, for example, assume that `t` is an `int`. This gives us great, enforced abstraction abilities.
-
-To illustrate the various kinds of type entries, consider the above signature
-`EstablishmentType` which requires that a module:
-
-- Declare a type named `profession`.
-- Must include a function that takes in a value of the type `profession` and returns a string.
-
-**Note**:
-
-Modules of the type `EstablishmentType` can contain more fields than the
-signature declares, just like the module `School` in the previous section (if we
-choose to assign it the type `EstablishmentType`. Otherwise, `School` exposes
-every field). This effectively makes the `person1` field an enforced
-implementation detail! Outsiders can't access it, since it's not present in the
-signature; the signature **constrained** what others can access.
-
-The type `EstablishmentType.profession` is **abstract**: it doesn't have a
-concrete type; it's saying "I don't care what the actual type is, but it's used
-as input to `getProfession`". This is useful to fit many modules under the same
-interface:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-module Company: EstablishmentType = {
-  type profession = CEO | Designer | Engineer | ...
-
-  let getProfession = (person) => ...
-  let person1 = ...
-  let person2 = ...
-}
-```
-```js
-function getProfession(person) {
-  ...
-}
-
-var person1 = ...
-
-var person2 = ...
-
-var Company = {
-  getProfession: getProfession,
-  person1: person1,
-  person2: person2
-};
-```
-
-</CodeTab>
-
-It's also useful to hide the underlying type as an implementation detail others
-can't rely on. If you ask what the type of `Company.profession` is, instead of
-exposing the variant, it'll only tell you "it's `Company.profession`".
-
-### Extending module signatures
-
-Like modules themselves, module signatures can also be extended by other module signatures using `include`. Again, **heavily discouraged**:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module type BaseComponent = {
-  let defaultGreeting: string
-  let getAudience: (~excited: bool) => string
-}
-
-module type ActualComponent = {
-  /* the BaseComponent signature is copied over */
-  include BaseComponent
-  let render: unit => string
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-**Note**: `BaseComponent` is a module **type**, not an actual module itself!
-
-If you do not have a defined module type, you can extract it from an actual module
-using `include (module type of ActualModuleName)`. For example, we can extend the
-`List` module from the standard library, which does not define a module
-type.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module type MyList = {
-  include (module type of List)
-  let myListFun: list<'a> => list<'a>
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-### Every `.resi` file is a signature
-
-Similar to how a `React.res` file implicitly defines a module `React`, a file
-`React.resi` implicitly defines a signature for `React`. If `React.resi` isn't
-provided, the signature of `React.res` defaults to exposing all the fields of the
-module. Because they don't contain implementation files, `.resi` files are used
-in the ecosystem to also document the public API of their corresponding modules.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-/* file React.res (implementation. Compiles to module React) */
-type state = int
-let render = (str) => str
-```
-```js
-function render(str) {
-  return str;
-}
-```
-
-</CodeTab>
-
-```res sig
-/* file React.resi (interface. Compiles to the signature of React.res) */
-type state = int
-let render: string => string
-```
-
-## Module Functions (functors)
-
-Modules can be passed to functions! It would be the equivalent of passing a file
-as a first-class item. However, modules are at a different "layer" of the
-language than other common concepts, so we can't pass them to *regular*
-functions. Instead, we pass them to special functions called "functors".
-
-The syntax for defining and using functors is very much like the syntax
-for defining and using regular functions. The primary differences are:
-
-- Functors use the `module` keyword instead of `let`.
-- Functors take modules as arguments and return a module.
-- Functors *require* annotating arguments.
-- Functors must start with a capital letter (just like modules/signatures).
-
-Here's an example `MakeSet` functor, that takes in a module of the type
-`Comparable` and returns a new set that can contain such comparable items.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-module type Comparable = {
-  type t
-  let equal: (t, t) => bool
-}
-
-module MakeSet = (Item: Comparable) => {
-  // let's use a list as our naive backing data structure
-  type backingType = list<Item.t>
-  let empty = list{}
-  let add = (currentSet: backingType, newItem: Item.t): backingType =>
-    // if item exists
-    if List.exists(x => Item.equal(x, newItem), currentSet) {
-      currentSet // return the same (immutable) set (a list really)
-    } else {
-      list{
-        newItem,
-        ...currentSet // prepend to the set and return it
-      }
-    }
-}
-```
-```js
-var List = require("./stdlib/list.js");
-
-function MakeSet(Item) {
-  var add = function(currentSet, newItem) {
-    if (
-      List.exists(function(x) {
-        return Item.equal(x, newItem);
-      }, currentSet)
-    ) {
-      return currentSet;
-    } else {
-      return {
-        hd: newItem,
-        tl: currentSet,
-      };
-    }
-  };
-  return {
-    empty: /* [] */ 0,
-    add: add,
-  };
-}
-```
-
-</CodeTab>
-
-Functors can be applied using function application syntax. In this case, we're
-creating a set, whose items are pairs of integers.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-module IntPair = {
-  type t = (int, int)
-  let equal = ((x1: int, y1: int), (x2, y2)) => x1 == x2 && y1 == y2
-  let create = (x, y) => (x, y)
-}
-
-/* IntPair abides by the Comparable signature required by MakeSet */
-module SetOfIntPairs = MakeSet(IntPair)
-```
-```js
-function equal(param, param$1) {
-  if (param[0] === param$1[0]) {
-    return param[1] === param$1[1];
-  } else {
-    return false;
-  }
-}
-
-function create(x, y) {
-  return [x, y];
-}
-
-var IntPair = {
-  equal: equal,
-  create: create,
-};
-
-var SetOfIntPairs = {
-  empty: /* [] */ 0,
-  add: add,
-};
-```
-
-</CodeTab>
-
-### Module functions types
-
-Like with module types, functor types also act to constrain and hide what we may
-assume about functors. The syntax for functor types are consistent with those
-for function types, but with types capitalized to represent the signatures of
-modules the functor accepts as arguments and return values. In the
-previous example, we're exposing the backing type of a set; by giving `MakeSet`
-a functor signature, we can hide the underlying data structure!
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-module type Comparable = ...
-
-module type MakeSetType = (Item: Comparable) => {
-  type backingType
-  let empty: backingType
-  let add: (backingType, Item.t) => backingType
-}
-
-module MakeSet: MakeSetType = (Item: Comparable) => {
-  ...
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Exotic Module Filenames
-
-**Since 8.3**
-
-It is possible to use non-conventional characters in your filenames (which is sometimes needed for specific JS frameworks). Here are some examples:
-
-- `src/Button.ios.res`
-- `pages/[id].res`
-
-Please note that modules with an exotic filename will not be accessible from other ReScript modules.
-
-## Tips & Tricks
-
-Modules and functors are at a different "layer" of language than the rest (functions, let bindings, data structures, etc.). For example, you can't easily pass them into a tuple or record. Use them judiciously, if ever! Lots of times, just a record or a function is enough.
diff --git a/pages/docs/manual/v9.0.0/mutation.mdx b/pages/docs/manual/v9.0.0/mutation.mdx
deleted file mode 100644
index 750613a4a..000000000
--- a/pages/docs/manual/v9.0.0/mutation.mdx
+++ /dev/null
@@ -1,75 +0,0 @@
----
-title: "Mutation"
-description: "Imperative and mutative programming capabilities in ReScript"
-canonical: "/docs/manual/latest/mutation"
----
-
-# Mutation
-
-ReScript has great traditional imperative & mutative programming capabilities. You should use these features sparingly, but sometimes they allow your code to be more performant and written in a more familiar pattern.
-
-## Mutate Let-binding
-
-Let-bindings are immutable, but you can wrap it with a `ref`, exposed as a record with a single mutable field in the standard library:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let myValue = ref(5)
-```
-```js
-var myValue = {
-  contents: 5
-};
-```
-
-</CodeTab>
-
-## Usage
-
-You can get the actual value of a `ref` box through accessing its `contents` field:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let five = myValue.contents // 5
-```
-```js
-var five = myValue.contents;
-```
-
-</CodeTab>
-
-Assign a new value to `myValue` like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-myValue.contents = 6
-```
-```js
-myValue.contents = 6;
-```
-
-</CodeTab>
-
-We provide a syntax sugar for this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-myValue := 6
-```
-```js
-myValue.contents = 6;
-```
-
-</CodeTab>
-
-Note that the previous binding `five` stays `5`, since it got the underlying item on the `ref` box, not the `ref` itself.
-
-**Note**: you might see in the JS output tabs above that `ref` allocates an object. Worry not; local, non-exported `ref`s allocations are optimized away.
-
-## Tip & Tricks
-
-Before reaching for `ref`, know that you can achieve lightweight, local "mutations" through [overriding let bindings](let-binding.md#binding-shadowing).
diff --git a/pages/docs/manual/v9.0.0/newcomer-examples.mdx b/pages/docs/manual/v9.0.0/newcomer-examples.mdx
deleted file mode 100644
index 4f701411d..000000000
--- a/pages/docs/manual/v9.0.0/newcomer-examples.mdx
+++ /dev/null
@@ -1,134 +0,0 @@
----
-title: "Newcomer Examples"
-description: "Quick examples for users new to ReScript"
-canonical: "/docs/manual/latest/newcomer-examples"
----
-
-# Newcomer Examples
-
-<!-- TODO: this whole page needs a revamp -->
-
-An example is worth a thousand words.
-
-This section is dedicated to newcomers trying to figure out general idioms & conventions. If you're a beginner who's got a good idea for an example, please suggest an edit!
-
-## Use the [`option` type](null-undefined-option.md)
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let possiblyNullValue1 = None
-let possiblyNullValue2 = Some("Hello")
-
-switch possiblyNullValue2 {
-| None => Js.log("Nothing to see here.")
-| Some(message) => Js.log(message)
-}
-```
-```js
-var possiblyNullValue1;
-var possiblyNullValue2 = "Hello";
-
-if (possiblyNullValue2 !== undefined) {
-  console.log(possiblyNullValue2);
-} else {
-  console.log("Nothing to see here.");
-}
-
-```
-
-</CodeTab>
-
-## Create a Parametrized Type
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type universityStudent = {gpa: float}
-
-type response<'studentType> = {
-  status: int,
-  student: 'studentType,
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Creating a JS Object
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let student1 = {
-  "name": "John",
-  "age": 30,
-}
-```
-```js
-var student1 = {
-  name: "John",
-  age: 30,
-};
-```
-
-</CodeTab>
-
-Or using [record](record.md):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type payload = {
-  name: string,
-  age: int,
-}
-
-let student1 = {
-  name: "John",
-  age: 30,
-}
-```
-```js
-var student1 = {
-  name: "John",
-  age: 30,
-};
-```
-
-</CodeTab>
-
-## Modeling a JS Module with Default Export
-
-See [here](import-from-export-to-js.md#import-a-javascript-module-itself-es6-module-format).
-
-## Checking for JS nullable types using the `option` type
-
-For a function whose argument is passed a JavaScript value that's potentially `null` or `undefined`, it's idiomatic to convert it to an `option`. The conversion is done through the helper functions in ReScript's [`Js.Nullable`](api/js/nullable#t) module. In this case, `toOption`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let greetByName = (possiblyNullName) => {
-  let optionName = Js.Nullable.toOption(possiblyNullName)
-  switch optionName {
-  | None => "Hi"
-  | Some(name) => "Hello " ++ name
-  }
-}
-```
-```js
-function greetByName(possiblyNullName) {
-  if (possiblyNullName == null) {
-    return "Hi";
-  } else {
-    return "Hello " + possiblyNullName;
-  }
-}
-```
-
-</CodeTab>
-
-This check compiles to `possiblyNullName == null` in JS, so checks for the presence of `null` or `undefined`.
diff --git a/pages/docs/manual/v9.0.0/null-undefined-option.mdx b/pages/docs/manual/v9.0.0/null-undefined-option.mdx
deleted file mode 100644
index 422fa413c..000000000
--- a/pages/docs/manual/v9.0.0/null-undefined-option.mdx
+++ /dev/null
@@ -1,203 +0,0 @@
----
-title: "Null, Undefined and Option"
-description: "JS interop with nullable and optional values in ReScript"
-canonical: "/docs/manual/latest/null-undefined-option"
----
-
-# Null, Undefined and Option
-
-ReScript itself doesn't have the notion of `null` or `undefined`. This is a _great_ thing, as it wipes out an entire category of bugs. No more `undefined is not a function`, and `cannot access someAttribute of undefined`!
-
-However, the **concept** of a potentially nonexistent value is still useful, and safely exists in our language.
-
-We represent the existence and nonexistence of a value by wrapping it with the `option` type. Here's its definition from the standard library:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type option<'a> = None | Some('a)
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-It means "a value of type option is either None (representing nothing) or that actual value wrapped in a Some".
-
-**Note** how the `option` type is just a regular [variant](variant.md).
-
-## Example
-
-Here's a normal value:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let licenseNumber = 5
-```
-```js
-var licenseNumber = 5;
-```
-
-</CodeTab>
-
-To represent the concept of "maybe null", you'd turn this into an `option` type by wrapping it. For the sake of a more illustrative example, we'll put a condition around it:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let licenseNumber =
-  if personHasACar {
-    Some(5)
-  } else {
-    None
-  }
-```
-```js
-var licenseNumber = personHasACar ? 5 : undefined;
-```
-
-</CodeTab>
-
-Later on, when another piece of code receives such value, it'd be forced to handle both cases through [pattern matching](pattern-matching-destructuring.md):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-switch licenseNumber {
-| None =>
-  Js.log("The person doesn't have a car")
-| Some(number) =>
-  Js.log("The person's license number is " ++ Js.Int.toString(number))
-}
-```
-```js
-var number = licenseNumber;
-
-if (number !== undefined) {
-  console.log("The person's license number is " + number.toString());
-} else {
-  console.log("The person doesn't have a car");
-}
-```
-
-</CodeTab>
-
-By turning your ordinary number into an `option` type, and by forcing you to handle the `None` case, the language effectively removed the possibility for you to mishandle, or forget to handle, a conceptual `null` value! **A pure ReScript program doesn't have null errors**.
-
-## Interoperate with JavaScript `undefined` and `null`
-
-The `option` type is common enough that we special-case it when compiling to JavaScript:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let x = Some(5)
-```
-```js
-var x = 5;
-```
-
-</CodeTab>
-
-simply compiles down to `5`, and
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let x = None
-```
-```js
-var x;
-```
-
-</CodeTab>
-
-compiles to `undefined`! If you've got e.g. a string in JavaScript that you know might be `undefined`, type it as `option<string>` and you're done! Likewise, you can send a `Some(5)` or `None` to the JS side and expect it to be interpreted correctly =)
-
-### Caveat 1
-
-The option-to-undefined translation isn't perfect, because on our side, `option` values can be composed:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let x = Some(Some(Some(5)))
-```
-```js
-var x = 5;
-```
-
-</CodeTab>
-
-This still compiles to `5`, but this gets troublesome:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let x = Some(None)
-```
-```js
-var Caml_option = require("./stdlib/caml_option.js");
-
-var x = Caml_option.some(undefined);
-```
-
-(See output tab).
-
-</CodeTab>
-
-What's this `Caml_option.some` thing? Why can't this compile to `undefined`? Long story short, when dealing with a polymorphic `option` type (aka `option<'a>`, for any `'a`), many operations become tricky if we don't mark the value with some special annotation. If this doesn't make sense, don't worry; just remember the following rule:
-
-- **Never, EVER, pass a nested `option` value (e.g. `Some(Some(Some(5)))`) into the JS side.**
-- **Never, EVER, annotate a value coming from JS as `option<'a>`. Always give the concrete, non-polymorphic type.**
-
-### Caveat 2
-
-Unfortunately, lots of times, your JavaScript value might be _both_ `null` or `undefined`. In that case, you unfortunately can't type such value as e.g. `option<int>`, since our `option` type only checks for `undefined` and not `null` when dealing with a `None`.
-
-#### Solution: More Sophisticated `undefined` & `null` Interop
-
-To solve this, we provide access to more elaborate `null` and `undefined` helpers through the [`Js.Nullable`](api/js/nullable) module. This somewhat works like an `option` type, but is different from it.
-
-#### Examples
-
-To create a JS `null`, use the value `Js.Nullable.null`. To create a JS `undefined`, use `Js.Nullable.undefined` (you can naturally use `None` too, but that's not the point here; the `Js.Nullable.*` helpers wouldn't work with it).
-
-If you're receiving, for example, a JS string that can be `null` and `undefined`, type it as:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("MyConstant") external myId: Js.Nullable.t<string> = "myId"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-To create such a nullable string from our side (presumably to pass it to the JS side, for interop purpose), do:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@module("MyIdValidator") external validate: Js.Nullable.t<string> => bool = "validate"
-let personId: Js.Nullable.t<string> = Js.Nullable.return("abc123")
-
-let result = validate(personId)
-```
-```js
-var MyIdValidator = require("MyIdValidator");
-var personId = "abc123";
-var result = MyIdValidator.validate(personId);
-```
-
-</CodeTab>
-
-The `return` part "wraps" a string into a nullable string, to make the type system understand and track the fact that, as you pass this value around, it's not just a string, but a string that can be `null` or `undefined`.
-
-#### Convert to/from `option`
-
-`Js.Nullable.fromOption` converts from a `option` to `Js.Nullable.t`. `Js.Nullable.toOption` does the opposite.
diff --git a/pages/docs/manual/v9.0.0/object.mdx b/pages/docs/manual/v9.0.0/object.mdx
deleted file mode 100644
index 6726b9595..000000000
--- a/pages/docs/manual/v9.0.0/object.mdx
+++ /dev/null
@@ -1,161 +0,0 @@
----
-title: "Object"
-description: "Interoping with JS objects in ReScript"
-canonical: "/docs/manual/latest/object"
----
-
-# Object
-
-ReScript objects are like [records](record.md), but:
-
-- No type declaration needed.
-- Structural and more polymorphic, [unlike records](record.md#record-types-are-found-by-field-name).
-- Doesn't support updates unless the object comes from the JS side.
-- Doesn't support [pattern matching](pattern-matching-destructuring.md).
-
-<!-- TODO: support update man -->
-
-Although ReScript records compile to clean JavaScript objects, ReScript objects are a better candidate for emulating/binding to JS objects, as you'll see.
-
-## Type Declaration
-
-**Optional**, unlike for records. The type of an object is inferred from the value, so you never really need to write down its type definition. Nevertheless, here's its type declaration syntax:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type person = {
-  "age": int,
-  "name": string
-};
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Visually similar to record type's syntax, with the field names quoted.
-
-<!-- TODO: document {.} and {..} -->
-
-## Creation
-
-To create a new object:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let me = {
-  "age": 5,
-  "name": "Big ReScript"
-}
-```
-```js
-var me = {
-  "age": 5,
-  "name": "Big ReScript"
-};
-```
-
-</CodeTab>
-
-**Note**: as said above, unlike for record, this `me` value does **not** try to find a conforming type declaration with the field `"age"` and `"name"`; rather, the type of `me` is inferred as `{"age": int, "name": string}`. This is convenient, but also means this code passes type checking without errors:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type person = {
-  "age": int
-};
-
-let me = {
-  "age": "hello!" // age is a string. No error.
-}
-```
-```js
-var me = {
-  "age": "hello!"
-};
-```
-
-</CodeTab>
-
-Since the type checker doesn't try to match `me` with the type `person`. If you ever want to force an object value to be of a predeclared object type, just annotate the value:
-
-```res
-let me: person = {
-  "age": "hello!"
-}
-```
-
-Now the type system will error properly.
-
-## Access
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let age = me["age"]
-```
-```js
-var age = me["age"];
-```
-
-</CodeTab>
-
-## Update
-
-Disallowed unless the object is a binding that comes from the JavaScript side. In that case, use `=`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type student = {
-  @set "age": int,
-  @set "name": string,
-}
-@module("MyJSFile") external student1: student = "student1"
-
-student1["name"] = "Mary"
-```
-```js
-var MyJSFile = require("MyJSFile");
-MyJSFile.student1.name = "Mary";
-```
-
-</CodeTab>
-
-## Tips & Tricks
-
-Since objects don't require type declarations, and since ReScript infers all the types for you, you get to very quickly and easily (and dangerously) bind to any JavaScript API. Check the JS output tab:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// The type of document is just some random type 'a
-// that we won't bother to specify
-@val external document: 'a = "document"
-
-// call a method
-document["addEventListener"]("mouseup", _event => {
-  Js.log("clicked!")
-})
-
-// get a property
-let loc = document["location"]
-
-// set a property
-document["location"]["href"] = "rescript-lang.org"
-```
-```js
-document.addEventListener("mouseup", function(_event) {
-  console.log("clicked!");
-});
-var loc = document.location;
-document.location.href = "rescript-lang.org";
-```
-
-</CodeTab>
-
-The `external` feature and the usage of this trick are also documented in the [external](external#tips--tricks) section later. It's an excellent way to start writing some ReScript code without worrying about whether bindings to a particular library exists.
diff --git a/pages/docs/manual/v9.0.0/overview.mdx b/pages/docs/manual/v9.0.0/overview.mdx
deleted file mode 100644
index b91a5b778..000000000
--- a/pages/docs/manual/v9.0.0/overview.mdx
+++ /dev/null
@@ -1,244 +0,0 @@
----
-title: "Overview"
-metaTitle: "Language Features Overview"
-description: "A quick overview on ReScript's syntax"
-canonical: "/docs/manual/latest/overview"
----
-
-# Overview
-
-## Comparison to JS
-
-### Semicolon
-
-| JavaScript                           | ReScript             |
-| ------------------------------------ | -------------------- |
-| Rules enforced by linter/formatter   | No semicolon needed! |
-
-### Comments
-
-| JavaScript        | ReScript    |
-| ----------------- | ----------- |
-| `/* Comment */`   | Same        |
-| `// Line comment` | Same        |
-
-### Variable
-
-| JavaScript              | ReScript                       |
-| ----------------------- | ------------------------------ |
-| `const x = 5;`          | `let x = 5`                    |
-| `var x = y;`            | No equivalent (thankfully)     |
-| `let x = 5; x = x + 1;` | `let x = ref(5); x := x.contents + 1` |
-
-### String & Character
-
-| JavaScript                | ReScript              |
-| --------------------------| --------------------- |
-| `"Hello world!"`          | Same                  |
-| `'Hello world!'`          | Strings must use `"`  |
-| `"hello " + "world"`      | `"hello " ++ "world"` |
-| `` `hello ${message}` ``  | Same                  |
-
-### Boolean
-
-| JavaScript                            | ReScript                                       |
-| ------------------------------------- | ---------------------------------------------- |
-| `true`, `false`                       | Same                                           |
-| `!true`                               | Same                                           |
-| `\|\|`, `&&`, `<=`, `>=`, `<`, `>`    | Same                                           |
-| `a === b`, `a !== b`                  | Same                                           |
-| No deep equality (recursive compare)  | `a == b`, `a != b`                             |
-| `a == b`                              | No equality with implicit casting (thankfully) |
-
-### Number
-
-| JavaScript  | ReScript     |
-| ----------- | ------------ |
-| `3`         | Same \*      |
-| `3.1415`    | Same         |
-| `3 + 4`     | Same         |
-| `3.0 + 4.5` | `3.0 +. 4.5` |
-| `5 % 3`     | `mod(5, 3)`  |
-
-\* JS has no distinction between integer and float.
-
-### Object/Record
-
-| JavaScript          | ReScript                                |
-| ------------------- | --------------------------------------- |
-| no types            | `type point = {x: int, mutable y: int}` |
-| `{x: 30, y: 20}`    | Same                                    |
-| `point.x`           | Same                                    |
-| `point.y = 30;`     | Same                                    |
-| `{...point, x: 30}` | Same                                    |
-
-### Array
-
-| JavaScript            | ReScript                           |
-| --------------------- | ---------------------------------- |
-| `[1, 2, 3]`           | Same                               |
-| `myArray[1] = 10`     | Same                               |
-| `[1, "Bob", true]`    | `(1, "Bob", true)` \*              |
-
-\* Heterogenous arrays in JS are disallowed for us. Use tuple instead.
-
-### Null
-
-| JavaScript          | ReScript  |
-| ------------------- | --------- |
-| `null`, `undefined` | `None` \* |
-
-\* Again, only a spiritual equivalent; we don't have nulls, nor null bugs! But we do have an `option` type for when you actually need nullability.
-
-### Function
-
-| JavaScript                      | ReScript                     |
-| ------------------------------- | ---------------------------- |
-| `arg => retVal`                 | Same                         |
-| `function named(arg) {...}`     | `let named = (arg) => {...}` |
-| `const f = function(arg) {...}` | `let f = (arg) => {...}`     |
-| `add(4, add(5, 6))`             | Same                         |
-
-### Blocks
-
-<table>
-  <thead>
-    <tr>
-      <th>JavaScript</th>
-      <th>ReScript</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>
-      ```
-      const myFun = (x, y) => {
-        const doubleX = x + x;
-        const doubleY = y + y;
-        return doubleX + doubleY;
-      };
-      ```
-      </td>
-      <td>
-      ```
-      let myFun = (x, y) => {
-        let doubleX = x + x
-        let doubleY = y + y
-        doubleX + doubleY
-      }
-      ```
-      </td>
-    </tr>
-  </tbody>
-</table>
-
-### If-else
-
-| JavaScript            | ReScript                                                            |
-| --------------------- | ------------------------------------------------------------------- |
-| `if (a) {b} else {c}` | `if a {b} else {c}` \*                                              |
-| `a ? b : c`           | Same                                                                |
-| `switch`              | `switch` but [super-powered pattern matching!](pattern-matching-destructuring.md) |
-
-\* Our conditionals are always expressions! You can write `let result = if a {"hello"} else {"bye"}`
-
-### Destructuring
-
-| JavaScript                    | ReScript                                      |
-| ----------------------------- | --------------------------------------------- |
-| `const {a, b} = data`         | `let {a, b} = data`                           |
-| `const [a, b] = data`         | <code>let [a, b] = data</code> \*             |
-| `const {a: aa, b: bb} = data` | `let {a: aa, b: bb} = data`                   |
-
-\* Gives good compiler warning that `data` might not be of length 2.
-
-### Loop
-
-| JavaScript                            | ReScript                       |
-| ------------------------------------- | ------------------------------ |
-| `for (let i = 0; i <= 10; i++) {...}` | `for i in 0 to 10 {...}`       |
-| `for (let i = 10; i >= 0; i--) {...}` | `for i in 10 downto 0 {...}`   |
-| `while (true) {...}`                  | `while true {...}`             |
-
-### JSX
-
-| JavaScript                                | ReScript                   |
-| ----------------------------------------- | -------------------------- |
-| `<Comp message="hi" onClick={handler} />` | Same                       |
-| `<Comp message={message} />`              | `<Comp message />` \*      |
-| `<input checked />`                       | `<input checked=true />`   |
-| No children spread                        | `<Comp>...children</Comp>` |
-
-\* Argument punning!
-
-### Exception
-
-| JavaScript                                      | ReScript                                   |
-| ----------------------------------------------- | ------------------------------------------ |
-| `throw new SomeError(...)`                      | `raise(SomeError(...))`                    |
-| `try {a} catch (Err) {...} finally {...}`       | `try a catch { \| Err => ...}` \* |
-
-\* No finally.
-
-### Blocks
-
-The last expression of a block delimited by `{}` implicitly returns (including function body). In JavaScript, this can only be simulated via an immediately-invoked function expression (since function bodies have their own local scope).
-
-<table>
-  <thead>
-    <tr>
-      <th>JavaScript</th>
-      <th>ReScript</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>
-      ```
-      let result = (function() {
-        const x = 23;
-        const y = 34;
-        return x + y;
-      })();
-      ```
-      </td>
-      <td>
-      ```
-      let result = {
-        let x = 23
-        let y = 34
-        x + y
-      }
-      ```
-      </td>
-    </tr>
-  </tbody>
-</table>
-
-
-## Common Features' JS Output
-
-Feature                         | Example                              | JavaScript Output
---------------------------------|--------------------------------------|----------------------
-String                          | `"Hello"`                            | `"Hello"`
-String Interpolation            | `` `Hello ${message}` ``             | `"Hello " + message`
-Character (disrecommended)      | `'x'`                                | `120` (char code)
-Integer                         | `23`, `-23`                          | `23`, `-23`
-Float                           | `23.0`, `-23.0`                      | `23.0`, `-23.0`
-Integer Addition                | `23 + 1`                             | `23 + 1`
-Float Addition                  | `23.0 +. 1.0`                        | `23.0 + 1.0`
-Integer Division/Multiplication | `2 / 23 * 1`                         | `2 / 23 * 1`
-Float Division/Multiplication   | `2.0 /. 23.0 *. 1.0`                 | `2.0 / 23.0 * 1.0`
-Float Exponentiation            | `2.0 ** 3.0`                         | `Math.pow(2.0, 3.0)`
-String Concatenation            | `"Hello " ++ "World"`                | `"Hello " + "World"`
-Comparison                      | `>`, `<`, `>=`, `<=`                 | `>`, `<`, `>=`, `<=`
-Boolean operation               | `!`, `&&`, `\|\|`                    | `!`, `&&`, `\|\|`
-Shallow and deep Equality       | `===`, `==`                          | `===`, `==`
-List (disrecommended)           | `list{1, 2, 3}`                      | `{hd: 1, tl: {hd: 2, tl: {hd: 3, tl: 0}}}`
-List Prepend                    | `list{a1, a2, ...oldList}`           | `{hd: a1, tl: {hd: a2, tl: theRest}}`
-Array                           | `[1, 2, 3]`                          | `[1, 2, 3]`
-Record                          | `type t = {b: int}; let a = {b: 10}` | `var a = {b: 10}`
-Multiline Comment               | `/* Comment here */`                 | Not in output
-Single line Comment             | `// Comment here`                    | Not in output
-
-_Note that this is a cleaned-up comparison table; a few examples' JavaScript output are slightly different in reality._
diff --git a/pages/docs/manual/v9.0.0/pattern-matching-destructuring.mdx b/pages/docs/manual/v9.0.0/pattern-matching-destructuring.mdx
deleted file mode 100644
index ac09f9c3a..000000000
--- a/pages/docs/manual/v9.0.0/pattern-matching-destructuring.mdx
+++ /dev/null
@@ -1,876 +0,0 @@
----
-title: "Pattern Matching / Destructuring"
-description: "Pattern matching and destructuring complex data structures in ReScript"
-canonical: "/docs/manual/latest/pattern-matching-destructuring"
----
-
-# Pattern Matching / Destructuring
-
-One of ReScript's **best** feature is our pattern matching. Pattern matching combines 3 brilliant features into one:
-
-- Destructuring.
-- `switch` based on shape of data.
-- Exhaustiveness check.
-
-We'll dive into each aspect below.
-
-## Destructuring
-
-Even JavaScript has destructuring, which is "opening up" a data structure to extract the parts we want and assign variable names to them:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let coordinates = (10, 20, 30)
-let (x, _, _) = coordinates
-Js.log(x) // 10
-```
-```js
-var coordinates = [10, 20, 30];
-var x = 10;
-console.log(10);
-```
-
-</CodeTab>
-
-Destructuring works with most built-in data structures:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Record
-type student = {name: string, age: int}
-let student1 = {name: "John", age: 10}
-let {name} = student1 // "John" assigned to `name`
-
-// Variant
-type result =
-  | Success(string)
-let myResult = Success("You did it!")
-let Success(message) = myResult // "You did it!" assigned to `message`
-```
-```js
-var student1 = {
-  name: "John",
-  age: 10
-};
-var name = "John";
-
-var myResult = /* Success */{
-  _0: "You did it!"
-};
-var message = "You did it!"
-
-var myArray = [1, 2, 3];
-if (myArray.length !== 2) {
-  throw {
-    RE_EXN_ID: "Match_failure",
-    _1: [
-      "playground.res",
-      14,
-      4
-    ],
-    Error: new Error()
-  };
-}
-var item1 = myArray[0];
-var item2 = myArray[1];
-
-var myList = {
-  hd: 1,
-  tl: {
-    hd: 2,
-    tl: {
-      hd: 3,
-      tl: /* [] */0
-    }
-  }
-};
-// ...
-```
-
-</CodeTab>
-
-You can also use destructuring anywhere you'd usually put a binding:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type result =
-  | Success(string)
-let displayMessage = (Success(m)) => {
-  // we've directly extracted the success message
-  // string by destructuring the parameter
-  Js.log(m)
-}
-displayMessage(Success("You did it!"))
-```
-```js
-function displayMessage(m) {
-  console.log(m._0);
-}
-
-displayMessage(/* Success */{
-  _0: "You did it!"
-});
-```
-
-</CodeTab>
-
-For a record, you can rename the field while destructuring:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let {name: n} = student1 // "John" assigned to `n`
-```
-```js
-var n = "John";
-```
-
-</CodeTab>
-
-You _can_ in theory destructure array and list at the top level too:
-
-```res
-let myArray = [1, 2, 3]
-let [item1, item2, _] = myArray
-// 1 assigned to `item1`, 2 assigned to `item2`, 3rd item ignored
-
-let myList = list{1, 2, 3}
-let list{head, ...tail} = myList
-// 1 assigned to `head`, `list{2, 3}` assigned to tail
-```
-
-But the array example is **highly disrecommended** (use tuple instead) and the list example will error on you. They're only there for completeness' sake. As you'll see below, the proper way of using destructuring array and list is using `switch`.
-
-## `switch` Based on Shape of Data
-
-While the destructuring aspect of pattern matching is nice, it doesn't really change the way you think about structuring your code. One paradigm-changing way of thinking about your code is to execute some code based on the shape of the data.
-
-Consider a variant:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type payload =
-  | BadResult(int)
-  | GoodResult(string)
-  | NoResult
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-We'd like to handle each of the 3 cases differently. For example, print a success message if the value is `GoodResult(...)`, do something else when the value is `NoResult`, etc.
-
-In other languages, you'd end up with a series of if-elses that are hard to read and error-prone. In ReScript, you can instead use the supercharged `switch` pattern matching facility to destructure the value while calling the right code based on what you destructured:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let data = GoodResult("Product shipped!")
-switch data {
-| GoodResult(theMessage) =>
-  Js.log("Success! " ++ theMessage)
-| BadResult(errorCode) =>
-  Js.log("Something's wrong. The error code is: " ++ Js.Int.toString(errorCode))
-| NoResult =>
-  Js.log("Bah.")
-}
-```
-```js
-var data = {
-  TAG: /* GoodResult */1,
-  _0: "Product shipped!"
-};
-
-if (typeof data === "number") {
-  console.log("Bah.");
-} else if (data.TAG === /* BadResult */ 0) {
-  console.log("Something's wrong. The error code is: " + "Product shipped!".toString());
-} else {
-  console.log("Success! Product shipped!");
-}
-```
-
-</CodeTab>
-
-In this case, `message` will have the value `"Success! Product shipped!"`.
-
-Suddenly, your if-elses that messily checks some structure of the value got turned into a clean, compiler-verified, linear list of code to execute based on exactly the shape of the value.
-
-### Complex Examples
-
-Here's a real-world scenario that'd be a headache to code in other languages. Given this data structure:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type status = Vacations(int) | Sabbatical(int) | Sick | Present
-type reportCard = {passing: bool, gpa: float}
-type person =
-  | Teacher({
-    name: string,
-    age: int,
-  })
-  | Student({
-    name: string,
-    status: status,
-    reportCard: reportCard,
-  })
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Imagine this requirement:
-
-- Informally greet a person who's a teacher and if his name is Mary or Joe.
-- Greet other teachers formally.
-- If the person's a student, congratulate him/her score if they passed the semester.
-- If the student has a gpa of 0 and is on vacations or sabbatical, display a different message.
-- A catch-all message for a student.
-
-ReScript can do this easily!
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let person1 = Teacher({name: "Jane", age: 35})
-
-let message = switch person1 {
-| Teacher({name: "Mary" | "Joe"}) =>
-  `Hey, still going to the party on Saturday?`
-| Teacher({name}) =>
-  // this is matched only if `name` isn't "Mary" or "Joe"
-  `Hello ${name}.`
-| Student({name, reportCard: {passing: true, gpa}}) =>
-  `Congrats ${name}, nice GPA of ${Js.Float.toString(gpa)} you got there!`
-| Student({
-    reportCard: {gpa: 0.0},
-    status: Vacations(daysLeft) | Sabbatical(daysLeft)
-  }) =>
-  `Come back in ${Js.Int.toString(daysLeft)} days!`
-| Student({status: Sick}) =>
-  `How are you feeling?`
-| Student({name}) =>
-  `Good luck next semester ${name}!`
-}
-```
-```js
-var person1 = {
-  TAG: /* Teacher */0,
-  name: "Jane",
-  age: 35
-};
-
-var message;
-
-if (person1.TAG) {
-  var match$1 = person1.status;
-  var name = person1.name;
-  var match$2 = person1.reportCard;
-  message = match$2.passing
-    ? "Congrats " +
-      name +
-      ", nice GPA of " +
-      match$2.gpa.toString() +
-      " you got there!"
-    : typeof match$1 === "number"
-    ? match$1 !== 0
-      ? "Good luck next semester " + name + "!"
-      : "How are you feeling?"
-    : person1.reportCard.gpa !== 0.0
-    ? "Good luck next semester " + name + "!"
-    : "Come back in " + match$1._0.toString() + " days!";
-} else {
-  var name$1 = person1.name;
-  switch (name$1) {
-    case "Joe":
-    case "Mary":
-      message = "Hey, still going to the party on Saturday?";
-      break;
-    default:
-      message = "Hello " + name$1 + ".";
-  }
-}
-```
-
-</CodeTab>
-
-**Note** how we've:
-- drilled deep down into the value concisely
-- using a **nested pattern check** `"Mary" | "Joe"` and `Vacations | Sabbatical`
-- while extracting the `daysLeft` number from the latter case
-- and assigned the greeting to the binding `message`.
-
-Here's another example of pattern matching, this time on an inline tuple.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type animal = Dog | Cat | Bird
-let categoryId = switch (isBig, myAnimal) {
-| (true, Dog) => 1
-| (true, Cat) => 2
-| (true, Bird) => 3
-| (false, Dog | Cat) => 4
-| (false, Bird) => 5
-}
-```
-```js
-var categoryId = isBig ? (myAnimal + 1) | 0 : myAnimal >= 2 ? 5 : 4;
-```
-
-</CodeTab>
-
-**Note** how pattern matching on a tuple is equivalent to a 2D table:
-
-isBig \ myAnimal | Dog | Cat | Bird
------------------|-----|-----|------
-true             |  1  |  2  |  3
-false            |  4  |  4  |  5
-
-### Fall-Through Patterns
-
-The nested pattern check, demonstrated in the earlier `person` example, also works at the top level of a `switch`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let myStatus = Vacations(10)
-
-switch myStatus {
-| Vacations(days)
-| Sabbatical(days) => Js.log(`Come back in ${Js.Int.toString(days)} days!`)
-| Sick
-| Present => Js.log("Hey! How are you?")
-}
-```
-```js
-var myStatus = {
-  TAG: /* Vacations */0,
-  _0: 10
-};
-
-if (typeof myStatus === "number") {
-  console.log("Hey! How are you?");
-} else {
-  console.log("Come back in " + (10).toString() + " days!");
-}
-```
-
-</CodeTab>
-
-Having multiple cases fall into the same handling can clean up certain types of logic.
-
-### Ignore Part of a Value
-
-If you have a value like `Teacher(payload)` where you just want to pattern match on the `Teacher` part and ignore the `payload` completely, you can use the `_` wildcard like this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch person1 {
-| Teacher(_) => Js.log("Hi teacher")
-| Student(_) => Js.log("Hey student")
-}
-```
-```js
-if (person1.TAG) {
-  console.log("Hey student");
-} else {
-  console.log("Hi teacher");
-}
-```
-
-</CodeTab>
-
-`_` also works at the top level of the `switch`, serving as a catch-all condition:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch myStatus {
-| Vacations(_) => Js.log("Have fun!")
-| _ => Js.log("Ok.")
-}
-```
-```js
-if (typeof myStatus === "number" || myStatus.TAG) {
-  console.log("Ok.");
-} else {
-  console.log("Have fun!");
-}
-```
-
-</CodeTab>
-
-**Do not** abuse a top-level catch-all condition. Instead, prefer writing out all the cases:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch myStatus {
-| Vacations(_) => Js.log("Have fun!")
-| Sabbatical(_) | Sick | Present => Js.log("Ok.")
-}
-```
-```js
-if (typeof myStatus === "number" || myStatus.TAG) {
-  console.log("Ok.");
-} else {
-  console.log("Have fun!");
-}
-```
-
-</CodeTab>
-
-Slightly more verbose, but a one-time writing effort. This helps when you add a new variant case e.g. `Quarantined` to the `status` type and need to update the places that pattern match on it. A top-level wildcard here would have accidentally and silently continued working, potentially causing bugs.
-
-### If Clause
-
-Sometime, you want to check more than the shape of a value. You want to also run some arbitrary check on it. You might be tempted to write this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch person1 {
-| Teacher(_) => () // do nothing
-| Student({reportCard: {gpa}}) =>
-  if gpa < 0.5 {
-    Js.log("What's happening")
-  } else {
-    Js.log("Heyo")
-  }
-}
-```
-```js
-if (person1.TAG) {
-  if (person1.reportCard.gpa < 0.5) {
-    console.log("What's happening");
-  } else {
-    console.log("Heyo");
-  }
-}
-```
-
-</CodeTab>
-
-`switch` patterns support a shortcut for the arbitrary `if` check, to keep your pattern linear-looking:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-switch person1 {
-| Teacher(_) => () // do nothing
-| Student({reportCard: {gpa}}) if gpa < 0.5 =>
-  Js.log("What's happening")
-| Student(_) =>
-  // fall-through, catch-all case
-  Js.log("Heyo")
-}
-```
-```js
-if (person1.TAG) {
-  if (person1.reportCard.gpa < 0.5) {
-    console.log("What's happening");
-  } else {
-    console.log("Heyo");
-  }
-}
-```
-
-</CodeTab>
-
-**Note:** In ReScript version < 9.0, the `if` clause is denoted as a `when`, but will be reformatted to `if` in newer versions.
-
-### Match on Exceptions
-
-If the function throws an exception (covered later), you can also match on _that_, in addition to the function's normally returned values.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-switch List.find(i => i === theItem, myItems) {
-| item => Js.log(item)
-| exception Not_found => Js.log("No such item found!")
-}
-```
-```js
-var exit = 0;
-
-var item;
-
-try {
-  item = List.find(function(i) {
-    return i === theItem;
-  }, myItems);
-  exit = 1;
-}
-catch (raw_exn){
-  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-  if (exn.RE_EXN_ID === "Not_found") {
-    console.log("No such item found!");
-  } else {
-    throw exn;
-  }
-}
-
-if (exit === 1) {
-  console.log(item);
-}
-```
-
-</CodeTab>
-
-### Match on Array
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let students = ["Jane", "Harvey", "Patrick"]
-switch students {
-| [] => Js.log("There are no students")
-| [student1] =>
-  Js.log("There's a single student here: " ++ student1)
-| manyStudents =>
-  // display the array of names
-  Js.log2("The students are: ", manyStudents)
-}
-```
-```js
-var students = ["Jane", "Harvey", "Patrick"];
-
-var len = students.length;
-
-if (len !== 1) {
-  if (len !== 0) {
-    console.log("The students are: ", students);
-  } else {
-    console.log("There are no students");
-  }
-} else {
-  var student1 = students[0];
-  console.log("There's a single student here: " + student1);
-}
-```
-
-</CodeTab>
-
-### Match on List
-
-Pattern matching on list is similar to array, but with the extra feature of extracting the tail of a list (all elements except the first one):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let rec printStudents = (students) => {
-  switch students {
-  | list{} => () // done
-  | list{student} => Js.log("Last student: " ++ student)
-  | list{student1, ...otherStudents} =>
-    Js.log(student1)
-    printStudents(otherStudents)
-  }
-}
-printStudents(list{"Jane", "Harvey", "Patrick"})
-```
-```js
-function printStudents(_students) {
-  while(true) {
-    var students = _students;
-    if (!students) {
-      return;
-    }
-    var otherStudents = students.tl;
-    var student = students.hd;
-    if (otherStudents) {
-      console.log(student);
-      _students = otherStudents;
-      continue;
-    }
-    console.log("Last student: " + student);
-    return;
-  };
-}
-
-printStudents({
-  hd: "Jane",
-  tl: {
-    hd: "Harvey",
-    tl: {
-      hd: "Patrick",
-      tl: /* [] */0
-    }
-  }
-});
-```
-
-</CodeTab>
-
-
-### Small Pitfall
-
-**Note**: you can only pass literals (i.e. concrete values) as a pattern, not let-binding names or other things. The following doesn't work as expected:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let coordinates = (10, 20, 30)
-let centerY = 20
-switch coordinates {
-| (x, centerY, _) => Js.log(x)
-}
-```
-```js
-var coordinates = [10, 20, 30];
-var centerY = 20;
-
-console.log(10);
-```
-
-</CodeTab>
-
-A first time ReScript user might accidentally write that code, assuming that it's matching on `coordinates` when the second value is of the same value as `centerY`. In reality, this is interpreted as matching on coordinates and assigning the second value of the tuple to the name `centerY`, which isn't what's intended.
-
-## Exhaustiveness Check
-
-As if the above features aren't enough, ReScript also provides arguably the most important pattern matching feature: **compile-time check of missing patterns**.
-
-Let's revisit one of the above examples:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let message = switch person1 {
-| Teacher({name: "Mary" | "Joe"}) =>
-  `Hey, still going to the party on Saturday?`
-| Student({name, reportCard: {passing: true, gpa}}) =>
-  `Congrats ${name}, nice GPA of ${Js.Float.toString(gpa)} you got there!`
-| Student({
-    reportCard: {gpa: 0.0},
-    status: Vacations(daysLeft) | Sabbatical(daysLeft)
-  }) =>
-  `Come back in ${Js.Int.toString(daysLeft)} days!`
-| Student({status: Sick}) =>
-  `How are you feeling?`
-| Student({name}) =>
-  `Good luck next semester ${name}!`
-}
-```
-```js
-if (person1.TAG) {
-  var match$1 = person1.status;
-  var name = person1.name;
-  var match$2 = person1.reportCard;
-  if (match$2.passing) {
-    "Congrats " + name + ", nice GPA of " + match$2.gpa.toString() + " you got there!";
-  } else if (typeof match$1 === "number") {
-    if (match$1 !== 0) {
-      "Good luck next semester " + name + "!";
-    } else {
-      "How are you feeling?";
-    }
-  } else if (person1.reportCard.gpa !== 0.0) {
-    "Good luck next semester " + name + "!";
-  } else {
-    "Come back in " + match$1._0.toString() + " days!";
-  }
-} else {
-  switch (person1.name) {
-    case "Joe":
-    case "Mary":
-      break;
-    default:
-      throw {
-        RE_EXN_ID: "Match_failure",
-        _1: [
-          "playground.res",
-          13,
-          0
-        ],
-        Error: new Error()
-      };
-  }
-}
-```
-
-</CodeTab>
-
-Did you see what we removed? This time, we've omitted the handling of the case where `person1` is `Teacher({name})` when `name` isn't Mary or Joe.
-
-Failing to handle every scenario of a value likely constitutes the majority of program bugs out there. This happens very often when you refactor a piece of code someone else wrote. Fortunately for ReScript, the compiler will tell you so:
-
-```
-Warning 8: this pattern-matching is not exhaustive.
-Here is an example of a value that is not matched:
-Some({name: ""})
-```
-
-**BAM**! You've just erased an entire category of important bugs before you even ran the code. In fact, this is how most of nullable values is handled:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myNullableValue = Some(5)
-
-switch myNullableValue {
-| Some(v) => Js.log("value is present")
-| None => Js.log("value is absent")
-}
-```
-```js
-var myNullableValue = 5;
-
-if (myNullableValue !== undefined) {
-  console.log("value is present");
-} else {
-  console.log("value is absent");
-}
-```
-
-</CodeTab>
-
-If you don't handle the `None` case, the compiler warns. No more `undefined` bugs in your code!
-
-## Conclusion & Tips & Tricks
-
-Hopefully you can see how pattern matching is a game changer for writing correct code, through the concise destructuring syntax, the proper conditions handling of `switch`, and the static exhaustiveness check.
-
-Here are some advices.
-
-Do not abuse the wildcard `_` too much. This prevents the compiler from giving you better exhaustiveness check, which would be especially important after a refactoring where you add a new case to a variant. Try only using `_` against infinite possibilities, e.g. string, int, etc.
-
-Use `when` clause sparingly.
-
-**Flatten your pattern-match whenever you can**. This is a real bug remover. Here's a series of examples, from worst to best:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let optionBoolToBool = opt => {
-  if opt == None {
-    false
-  } else if opt === Some(true) {
-    true
-  } else {
-    false
-  }
-}
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt === undefined) {
-    return false;
-  } else {
-    return opt === true;
-  }
-}
-```
-
-</CodeTab>
-
-Now that's just silly =). Let's turn it into pattern-matching:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let optionBoolToBool = opt => {
-  switch opt {
-  | None => false
-  | Some(a) => a ? true : false
-  }
-}
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt !== undefined && opt) {
-    return true;
-  } else {
-    return false;
-  }
-}
-```
-
-</CodeTab>
-
-Slightly better, but still nested. Pattern-matching allows you to do this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let optionBoolToBool = opt => {
-  switch opt {
-  | None => false
-  | Some(true) => true
-  | Some(false) => false
-  }
-}
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt !== undefined && opt) {
-    return true;
-  } else {
-    return false;
-  }
-}
-```
-
-</CodeTab>
-
-Much more linear-looking! Now, you might be tempted to do this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let optionBoolToBool = opt => {
-  switch opt {
-  | Some(true) => true
-  | _ => false
-  }
-}
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt !== undefined && opt) {
-    return true;
-  } else {
-    return false;
-  }
-}
-```
-
-</CodeTab>
-
-Which is much more concise, but kills the exhaustiveness check mentioned above; refrain from using that. This is the best:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let optionBoolToBool = opt => {
-  switch opt {
-  | Some(trueOrFalse) => trueOrFalse
-  | None => false
-  }
-}
-```
-```js
-function optionBoolToBool(opt) {
-  if (opt !== undefined) {
-    return opt;
-  } else {
-    return false;
-  }
-}
-```
-
-</CodeTab>
-
-Pretty darn hard to make a mistake in this code at this point! Whenever you'd like to use an if-else with many branches, prefer pattern matching instead. It's more concise and [performant](variant#design-decisions) too.
diff --git a/pages/docs/manual/v9.0.0/pipe.mdx b/pages/docs/manual/v9.0.0/pipe.mdx
deleted file mode 100644
index 706915d40..000000000
--- a/pages/docs/manual/v9.0.0/pipe.mdx
+++ /dev/null
@@ -1,247 +0,0 @@
----
-title: "Pipe"
-description: "The Pipe operator (->)"
-canonical: "/docs/manual/latest/pipe"
----
-
-# Pipe
-
-ReScript provides a tiny but surprisingly useful operator `->`, called the "pipe", that allows you to "flip" your code inside-out. `a(b)` becomes `b->a`. It's a simple piece of syntax that doesn't have any runtime cost.
-
-Why would you use it? Imagine you have the following:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-validateAge(getAge(parseData(person)))
-```
-```js
-validateAge(getAge(parseData(person)));
-```
-
-</CodeTab>
-
-This is slightly hard to read, since you need to read the code from the innermost part, to the outer parts. Use pipe to streamline it:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-person
-  ->parseData
-  ->getAge
-  ->validateAge
-```
-```js
-validateAge(getAge(parseData(person)));
-```
-
-</CodeTab>
-
-Basically, `parseData(person)` is transformed into `person->parseData`, and `getAge(person->parseData)` is transformed into `person->parseData->getAge`, etc.
-
-**This works when the function takes more than one argument too**.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-a(one, two, three)
-```
-```js
-a(one, two, three);
-```
-
-</CodeTab>
-
-is the same as
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-one->a(two, three)
-```
-```js
-a(one, two, three);
-```
-
-</CodeTab>
-
-This also works with labeled arguments.
-
-Pipes are used to emulate object-oriented programming, e.g. what's `myStudent.getName` in other languages like Java would be `myStudent->getName` in ReScript (aka `getName(myStudent)`). This allows us to have the readability of the good parts of OOP without its downside of dragging in a huge class system just to call a function on a piece of data.
-
-## Tips & Tricks
-
-Do **not** to abuse pipes; they're a means to an end. Inexperienced engineers sometimes shape a library's API to take advantage of the pipe. This is backward.
-
-## JS Method Chaining
-
-_This section requires understanding of [our binding API](bind-to-js-function.md#object-method)_.
-
-JavaScript's APIs are often attached to objects, and often chainable, like so:
-
-```js
-const result = [1, 2, 3].map(a => a + 1).filter(a => a % 2 === 0);
-
-asyncRequest()
-  .setWaitDuration(4000)
-  .send();
-```
-
-Assuming we don't need the chaining behavior above, we'd bind to each case this using `bs.send` from the aforementioned binding API page:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-@bs.send external map: (array<'a>, 'a => 'b) => array<'b> = "map"
-@bs.send external filter: (array<'a>, 'a => bool) => array<'a> = "filter"
-
-type request
-@bs.val external asyncRequest: unit => request = "asyncRequest"
-@bs.send external setWaitDuration: (request, int) => request = "setWaitDuration"
-@bs.send external send: request => unit = "send"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-You'd use them like this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let result = Js.Array2.filter(
-  Js.Array2.map([1, 2, 3], a => a + 1),
-  a => mod(a, 2) == 0
-)
-
-send(setWaitDuration(asyncRequest(), 4000))
-```
-```js
-var result = [1, 2, 3].map(function(a) {
-  return a + 1 | 0;
-}).filter(function(a) {
-  return a % 2 === 0;
-});
-
-asyncRequest().setWaitDuration(4000).send();
-```
-
-</CodeTab>
-
-This looks much worse than the JS counterpart! Clean it up visually with pipe:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let result = [1, 2, 3]
-  ->map(a => a + 1)
-  ->filter(a => mod(a, 2) == 0)
-
-asyncRequest()->setWaitDuration(4000)->send
-```
-```js
-var result = [1, 2, 3].map(function(a) {
-  return a + 1 | 0;
-}).filter(function(a) {
-  return a % 2 === 0;
-});
-
-asyncRequest().setWaitDuration(4000).send();
-```
-
-</CodeTab>
-
-## Pipe Into Variants
-
-You can pipe into a variant's constructor as if it was a function:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result = name->preprocess->Some
-```
-```js
-var result = preprocess(name);
-```
-
-</CodeTab>
-
-We turn this into:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let result = Some(preprocess(name))
-```
-```js
-var result = preprocess(name);
-```
-
-</CodeTab>
-
-**Note** that using a variant constructor as a function wouldn't work anywhere else beside here.
-
-## Pipe Placeholders
-
-A placeholder is written as an underscore and it tells ReScript that you want to fill in an argument of a function later. These two have equivalent meaning:
-
-```res
-let addTo7 = (x) => add3(3, x, 4)
-let addTo7 = add3(3, _, 4)
-```
-
-Sometimes you don't want to pipe the value you have into the first position. In these cases you can mark a placeholder value to show which argument you would like to pipe into.
-
-Let's say you have a function `namePerson`, which takes a `person` then a `name` argument. If you are transforming a person then pipe will work as-is:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-makePerson(~age=47, ())
-  ->namePerson("Jane")
-```
-```js
-namePerson(makePerson(47), "Jane");
-```
-
-</CodeTab>
-
-If you have a name that you want to apply to a person object, you can use a placeholder:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-getName(input)
-  ->namePerson(personDetails, _)
-```
-```js
-var __x = getName(input);
-namePerson(personDetails, __x);
-```
-
-</CodeTab>
-
-This allows you to pipe into any positional argument. It also works for named arguments:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-getName(input)
-  ->namePerson(~person=personDetails, ~name=_)
-```
-```js
-var __x = getName(input);
-namePerson(personDetails, __x);
-```
-
-</CodeTab>
-
-## Triangle Pipe (Deprecated)
-
-You might see usages of another pipe, `|>`, in some codebases. These are deprecated.
-
-Unlike `->` pipe, the `|>` pipe puts the subject as the last (not first) argument of the function. `a |> f(b)` turns into `f(b, a)`.
-
-For a more thorough discussion on the rationale and differences between the two operators, please refer to the [Data-first and Data-last comparison by Javier Chávarri](https://www.javierchavarri.com/data-first-and-data-last-a-comparison/)
diff --git a/pages/docs/manual/v9.0.0/polymorphic-variant.mdx b/pages/docs/manual/v9.0.0/polymorphic-variant.mdx
deleted file mode 100644
index d411ac432..000000000
--- a/pages/docs/manual/v9.0.0/polymorphic-variant.mdx
+++ /dev/null
@@ -1,454 +0,0 @@
----
-title: "Polymorphic Variant"
-description: "The Polymorphic Variant data structure in ReScript"
-canonical: "/docs/manual/latest/polymorphic-variant"
----
-
-# Polymorphic Variant
-
-Now that we know what [variant types](./variant) are, let's dive into a more specific version, so called polymorphic variants (or poly variants).
-
-First off, here are some key features:
-
-- Poly variants are structurally typed, which means they don't require any explicit type definition to be used as a value, and are not coupled to any specific module. The compiler will infer the type on demand, and compare poly variants by their value, instead of their type name (which would be called nominal typing).
-- They allow easier JavaScript interop (compile to strings / objects with predictable `NAME` and `VAL` attribute) and don't need explicit runtime conversions, unlike common variants.
-- Due to their structural nature, poly variant types may cause tricky type checking errors when types don't match up.
-
-## Basics
-
-Here is how you'd construct a poly variant value:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Note how a poly variant starts with a hashtag (#)
-// We also don't need any explicit type definition
-let myColor = #Red
-```
-
-```js
-var myColor = "Red";
-```
-
-</CodeTab>
-
-This is how you'd define a closed poly variant type with an exact set of constructors:
-
-```res
-// Note the surrounding square brackets, and # for constructors
-type color = [ #Red | #Green | #Blue ]
-```
-
-We can also use poly variant types in annotations without an explicit type definition:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let render = (color: [#Red | #Green | #Blue]) => {
-  switch(color) {
-    | _ => Js.log("...")
-  }
-}
-
-let color: [#Red] = #Red
-```
-
-```js
-function render(color) {
-  console.log("...");
-}
-
-var color = "Red";
-```
-
-</CodeTab>
-
-### Constructor Names
-
-Poly variant constructor names are less restrictive than in common variants (e.g. they don't need to be capitalized):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type users = [ #admin | #moderator | #user ]
-
-let admin = #admin
-```
-
-```js
-var admin = "admin";
-```
-
-</CodeTab>
-
-In rare cases (mostly for JS interop reasons), it's also possible to define "invalid identifiers", such as hypens or numbers:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type numbers = [#"1" | #"2"]
-let one = #"1"
-let oneA = #"1a"
-```
-
-```js
-var one = "1";
-var oneA = "1a";
-```
-
-</CodeTab>
-
-**Note:** For ReScript versions < 9.0 you'll need to use the `\` character as an escape sequence to represent invalid identifiers (e.g. `#\"1"`).
-
-### Constructor Arguments
-
-This is equivalent to what we've [already learned](variant#constructor-arguments) with common variants:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type account = [
-  | #Anonymous
-  | #Instagram(string)
-  | #Facebook(string, int)
-]
-
-let acc: account = #Instagram("test")
-```
-
-```js
-var acc = {
-  NAME: "Instagram",
-  VAL: "test"
-};
-```
-
-</CodeTab>
-
-### Compose and Pattern Match Poly Variants
-
-You can use poly variant types within other poly variant types to create a sum of all constructors:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type red = [#Ruby | #Redwood | #Rust]
-type blue = [#Sapphire | #Neon | #Navy]
-
-// Contains all constructors of red and blue.
-// Also adds #Papayawhip
-type color = [red | blue | #Papayawhip]
-
-let c: color = #Ruby
-```
-
-```js
-var c = "Ruby";
-```
-
-</CodeTab>
-
-There's also some special [pattern matching](./pattern-matching-destructuring) syntax to match on constructors defined in a specific poly variant type:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Continuing the previous example above...
-
-switch #Papayawhip {
-| #...blue => Js.log("This is a blue color")
-| #...red => Js.log("This is a red color")
-| other => Js.log2("Other color than red and blue: ", other)
-}
-```
-
-```js
-// This code got heavily optimized due to the usage of
-// constant values in a switch expression
-console.log("Other color than red and blue: ", "Papayawhip");
-
-var c = "Ruby";
-```
-
-</CodeTab>
-
-The `switch` expression above is a shorter and more convenient version of:
-
-```res
-switch #Papayawhip {
-  | #Sapphire | #Neon | #Navy => Js.log("This is a blue color")
-  | #Ruby | #Redwood | #Rust => Js.log("This is a red color")
-  | other => Js.log2("Other color than red and blue: ", other)
-}
-```
-
-### Recursive Type Definitions
-
-Poly variant types are non-recursive by default. Use the `rec` keyword to allow recursion:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type rec markdown = [
-  | #Text(string)
-  | #Paragraph(markdown)
-  | #Ul(array<markdown>)
-]
-
-let content: markdown = #Paragraph(#Text("hello world"))
-```
-
-```js
-var content = {
-  NAME: "Paragraph",
-  VAL: {
-    NAME: "Text",
-    VAL: "hello world"
-  }
-};
-```
-
-</CodeTab>
-
-### Annotations with Closed / Upper / Lower Bound Constraints
-
-There's also a way to define an "upper" and "lower" bound constraint for a poly variant type. Here is what it looks like in a type annotation:
-
-```res
-// Only #Red allowed, no upper / lower bound (closed poly variant)
-let basic: [#Red] = #Red
-
-// May contain #Red, or any other value (open poly variant)
-// here, foreground will actually be inferred as [> #Red | #Green]
-let foreground: [> #Red] = #Green
-
-// The value must be "one of" #Red | #Blue
-// Only #Red and #Blue are valid values
-let background: [< #Red | #Blue] = #Red
-```
-
-Don't worry about the upper / lower bound feature just yet, since this is a very advanced topic that's often not really needed. For the sake of completeness, we mention a few details about it [later on](#lower--upper-bound-constraints).
-
-
-## Polymorphic Variants are Structurally Typed
-
-As we've already seen in the section above, poly variants don't need any explicit type definition to be used as a value.
-
-The compiler treats every value as an independent type and doesn't couple it to any particular module (like with common variants). It therefore compares different poly variant types by their structure, not by a defined type name.
-
-Here is what the type checker sees whenever you are using a poly variant:
-
-```res
-// inferred as [> #Red]
-let color = #Red
-```
-
-The compiler will automatically infer the `color` binding as a value of type `[> #Red]`, which means `color` will type check with any other poly variant type that defines `#Red` in its constructors.
-
-You can interchangably use variant values from different modules and types as long as a value is part of a constructor set. For example:
-
-```res
-type rgb = [#Red | #Green | #Blue]
-
-let colors: array<rgb> = [#Red]
-
-// `other` is inferred as a type of array<[> #Green]>
-let other = [#Green]
-
-// Because `other` is of type `array<[> Green]>`,
-// this will type check even though we didn't define
-// `other`to be of type rgb
-let all = Belt.Array.concat(colors, other)
-```
-
-As you can see in the example above, the type checker doesn't really care about the fact that `other` is not annotated as an `array<rgb>` type. 
-
-As soon as it hits the first constraint (`Belt.Array.concat`), it will try to check if the structural types of `colors` and `other` unify into one poly variant type. If there's a mismatch, you will get an error on the `Belt.Array.concat` call.
-
-**Be aware that this behavior may cause confusing type errors in the wrong source code locations!**
-
-For instance, if we'd make a typo like this:
-
-```res
-// Note the typo in the #Green constructor
-let other = [#GreeN]
-
-let all = Belt.Array.concat(colors, other)
-```
-
-We'd get an error on the `concat` call, even thought the error was actually caused by the typo in the value assignment of `other`.
-
-## JavaScript Output
-
-Poly variants are a [shared data structure](./shared-data-types), so they are very useful to bind to JavaScript. It is safe to rely on its compiled JS structure.
-
-A value compiles to the following JavaScript output:
-
-- If the variant value is a constructor without any payload, it compiles to a string of the same name
-- Values with a payload get compiled to an object with a `NAME` attribute stating the name of the constructor, and a `VAL` attribute containing the JS representation of the payload.
-
-Check the output in these examples:
-
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let capitalized = #Hello
-let lowercased = #goodbye
-
-let err = #error("oops!")
-
-let num = #\"1"
-```
-
-```js
-var capitalized = "Hello";
-
-var lowercased = "goodbye";
-
-var err = {
-  NAME: "error",
-  VAL: "oops!"
-};
-
-var num = "1";
-```
-
-</CodeTab>
-
-
-### Bind to JS Functions
-
-Poly variants play an important role for binding to functions in JavaScript.
-
-For example, let's assume we want to bind to `Intl.NumberFormat` and want to make sure that our users only pass valid locales, we could define an external binding like this:
-
-```res
-// IntlNumberFormat.res
-type t
-
-@bs.val
-external make: ([#\"de-DE" | #\"en-GB" | #\"en-US" ]) => t = "Intl.NumberFormat"
-```
-
-We could later use our newly created bindings like this:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// MyApp.res
-
-let intl = IntlNumberFormat.make(#\"de-DE")
-```
-
-```js
-var intl = Intl.NumberFormat("de-DE");
-```
-
-</CodeTab>
-
-The JS Output is practically identical to handwritten JS, but we also get to enjoy all the benefits of a variant. 
-
-More usage examples for poly variant interop can be found in [Bind to JS Function](bind-to-js-function#constrain-arguments-better) and [Generate Converters and Helper](generate-converters-accessors#generate-converters-for-js-string-enums-and-polymorphic-variants).
-
-
-### Bind to String Enums
-
-Let's assume we have a TypeScript module that expresses following (stringly typed) enum export:
-
-```js
-// direction.js
-enum Direction {
-  Up = "UP",
-  Down = "DOWN",
-  Left = "LEFT",
-  Right = "RIGHT",
-}
-
-export const myDirection = Direction.Up
-```
-
-For this particular example, we can also inline poly variant type definitions to design the type for the imported `myDirection` value:
-
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type direction = [ #UP | #DOWN | #LEFT | #RIGHT ]
-@bs.module("./direction.js") external myDirection: direction = "myDirection"
-```
-
-```js
-var DirectionJs = require("./direction.js");
-
-var myDirection = DirectionJs.myDirection;
-```
-
-</CodeTab>
-
-Again: since we were using poly variants, the JS Output is practically zero-cost and doesn't add any extra code!
-
-## Lower / Upper Bound Constraints
-
-There are a few different ways to define constraints on a poly variant type, such as `[>`, `[<` and `[`. Some of them were briefly mentioned before, so in this section we will quickly explain what this syntax is about.
-
-**Note:** We added this info for educational purposes. In most cases you will not want to use any of this stuff, since it makes your APIs pretty unreadable / hard to use.
-
-### Closed (`[`)
-
-This is the simplest poly variant definition, and also the most practical one. Like a common variant type, this one defines an exact set of constructors.
-
-```res
-type rgb = [ #Red | #Green | #Blue ]
-
-let color: rgb = #Green
-```
-
-In the example above, `color` will only allow one of the three constructors that are defined in the `rgb` type. This is usually the way how poly variants should be defined.
-
-In case you want to define a type that is extensible in polymorphic ways (or in other words, subtyping allowed sets of constructors), you'll need to use the lower / upper bound syntax. 
-
-### Lower Bound (`[>`)
-
-A lower bound defines the minimum set of constructors a poly variant type is aware of. It is also considered an "open poly variant type", because it doesn't restrict any additional values.
-
-Here is an example on how to make a minimum set of `basicBlueTones` extensible for a new `color` type:
-
-```res
-type basicBlueTone<'a> = [> #Blue | #DeepBlue | #LightBlue ] as 'a
-type color = basicBlueTone<[#Blue | #DeepBlue | #LightBlue | #Purple]>
-
-let color:  color = #Purple
-
-// This will fail due to missing minimum constructors:
-type notWorking = basicBlueTone<[#Purple]>
-```
-
-Here, the compiler will enforce the user to define `#Blue | #DeepBlue | #LightBlue` as the minimum set of constructors when trying to extend `basicBlueTone<'a>`. 
-
-**Note:** Since we want to define an extensible poly variant, we need to provide a type placeholder `<'a>`, and also add `as 'a` after the poly variant declaration, which essentially means: "Given type `'a` is constraint to the minimum set of constructors (`#Blue | #DeepBlue | #LightBlue`) defined in `basicBlueTone`".
-
-### Upper Bound (`[<`)
-
-The upper bound works in the opposite way than a lower bound: the extending type may only use constructors that are stated in the upper bound constraint.
-
-Here another example, but with red colors:
-
-```res
-type validRed<'a> = [< #Fire | #Crimson | #Ash] as 'a
-type myReds = validRed<[#Ash]>
-
-// This will fail due to unlisted constructor not defined by the lower bound
-type notWorking = validRed<[#Purple]>
-```
-
-## Variant vs Polymorphic Variant
-
-One might think that polymorphic variants are fastly superior to common [variants](./variant). As always, it depends on the use case:
-
-- Variants allow better encapsulation for your APIs, because they always come with a type definition that is coupled to a specific module.
-- Variants are conceptionally easier to understand, makes your code easy to refactor and provides better exhaustive pattern matching support
-- Variants usually deliver better type error messages, especially in recursive type definitions
-- Poly variants are useful for expressing strings in JS, and allow different type composition strategies. They can also be defined adhocly in your type definitions.
-
-In most scenarios, we'd recommend to use common variants over polymorphic variants, especially when you are writing plain ReScript code. In case you want to write zero-cost interop bindings or generate clean JS output, poly variants are oftentimes a better option.
diff --git a/pages/docs/manual/v9.0.0/primitive-types.mdx b/pages/docs/manual/v9.0.0/primitive-types.mdx
deleted file mode 100644
index 9276e8682..000000000
--- a/pages/docs/manual/v9.0.0/primitive-types.mdx
+++ /dev/null
@@ -1,171 +0,0 @@
----
-title: "Primitive Types"
-description: "Primitive Data Types in ReScript"
-canonical: "/docs/manual/latest/primitive-types"
----
-
-# Primitive Types
-
-ReScript comes with the familiar primitive types like `string`, `int`, `float`, etc.
-
-<!-- TODO: doc unit -->
-
-## String
-
-ReScript `string`s are delimited using **double** quotes (single quotes are reserved for the character type below).
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let greeting = "Hello world!"
-let multilineGreeting = "Hello
- world!"
-```
-```js
-var greeting = "Hello world!";
-var multilineGreeting = "Hello\n world!";
-```
-
-</CodeTab>
-
-To concatenate strings, use `++`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let greetings = "Hello " ++ "world!"
-```
-```js
-var greetings = "Hello world!";
-```
-
-</CodeTab>
-
-### String Interpolation
-
-There's a special syntax for string that allows
-
-- multiline string just like before
-- no special character escaping
-- Interpolation
-- Proper unicode handling
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let name = "Joe"
-
-let greeting = `Hello
-World
-👋
-${name}
-`
-```
-```js
-var name = "Joe";
-
-var greeting = "Hello\nWorld\n👋\n" + name + "\n";
-```
-
-</CodeTab>
-
-This is just like JavaScript's backtick string interpolation, except without needing to escape special characters.
-
-For interpolation, you'll have to convert the binding (`name` in the example) into a string if it isn't one. If you want the interpolation to implicitly convert a binding into a string, prepend a `j`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let age = 10
-let message = j`Today I am $age years old.`
-```
-```js
-var message = "Today I am " + 10 + " years old.";
-```
-
-</CodeTab>
-
-### Usage
-
-See the familiar `Js.String` API in the [API docs](api/js/string). Since a ReScript string maps to a JavaScript string, you can mix & match the string operations in both standard libraries.
-
-### Tips & Tricks
-
-**You have a good type system now**! In an untyped language, you'd often overload the meaning of string by using it as:
-
-- a unique id: `var BLUE_COLOR = "blue"`
-- an identifier into a data structure: `var BLUE = "blue" var RED = "red" var colors = [BLUE, RED]`
-- the name of an object field: `person["age"] = 24`
-- an enum: `if (audio.canPlayType() === 'probably') {...}` [(ಠ_ಠ)](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/canPlayType#Return_value)
-- other crazy patterns you'll soon find horrible, after getting used to ReScript's alternatives.
-
-The more you overload the poor string type, the less the type system (or a teammate) can help you! ReScript provides concise, fast and maintainable types & data structures alternatives to the use-cases above (e.g. variants, in a later section).
-
-## Char
-
-ReScript has a type for a string with a single letter:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let firstLetterOfAlphabet = 'a'
-```
-```js
-var firstLetterOfAlphabet = /* "a" */97;
-```
-
-</CodeTab>
-
-**Note**: Char doesn't support Unicode or UTF-8 and is therefore not recommended.
-
-To convert a String to a Char, use `String.get("a", 0)`. To convert a Char to a String, use `String.make(1, 'a')`.
-
-## Regular Expression
-
-ReScript regular expressions compile cleanly to their JavaScript counterpart:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let r = %re("/b/g")
-```
-```js
-var r = /b/g;
-```
-
-</CodeTab>
-
-A regular expression like the above has the type `Js.Re.t`. The [Js.Re](api/js/re) module contains the regular expression helpers you have seen in JS.
-
-## Boolean
-
-A ReScript boolean has the type `bool` and can be either `true` or `false`. Common operations:
-
-- `&&`: logical and.
-- `||`: logical or.
-- `!`: logical not.
-- `<=`, `>=`, `<`, `>`
-- `==`: structural equal, compares data structures deeply: `(1, 2) == (1, 2)` is `true`. Convenient, but use with caution.
-- `===`: referential equal, compares shallowly. `(1, 2) === (1, 2)` is `false`. `let myTuple = (1, 2); myTuple === myTuple` is `true`.
-- `!=`: structural unequal.
-- `!==`: referential unequal.
-
-ReScript's `true/false` compiles into a JavaScript `true/false`.
-
-## Integers
-
-32-bits, truncated when necessary. We provide the usual operations on them: `+`, `-`, `*`, `/`, etc. See [Js.Int](api/js/int) for helper functions.
-
-**Careful when you bind to JavaScript numbers**! Long ones might be truncated. Bind JS number (especially Dates) as **float** instead.
-
-To improve readability, you may place underscores in the middle of numeric literals such as `1_000_000`. Note that underscores can be placed anywhere within a number, not just every three digits.
-
-## Floats
-
-Float requires other operators: `+.`, `-.`, `*.`, `/.`, etc. Like `0.5 +. 0.6`. See [Js.Float](api/js/float) for helper functions.
-
-As with integers, you may use underscores within literals to improve readability.
-
-## Unit
-
-The `unit` type has a single value, `()`. It compiles to JavaScript's `undefined`. It's a dummy type used as a placeholder in various places. You won't need it until you see it.
diff --git a/pages/docs/manual/v9.0.0/project-structure.mdx b/pages/docs/manual/v9.0.0/project-structure.mdx
deleted file mode 100644
index 93e77f0f0..000000000
--- a/pages/docs/manual/v9.0.0/project-structure.mdx
+++ /dev/null
@@ -1,57 +0,0 @@
----
-title: "Project Structure"
-description: "Notes on project structure and other rough ReScript guidelines"
-canonical: "/docs/manual/latest/project-structure"
----
-
-# Project Structure
-
-These are the existing, non-codified community practices that are currently propagated through informal agreement. We might remove some of them at one point, and enforce some others. Right now, they're just recommendations for ease of newcomers.
-
-## File Casing
-
-Capitalized file names (aka first letter upper-cased).
-
-**Justification**: Module names can only be capitalized. Newcomers often ask how a file maps to a module, and why `draw.res` maps to the module `Draw`, and sometimes try to refer to a module through uncapitalized identifiers. Using `Draw.res` makes this mapping more straightforward. It also helps certain file names that'd be awkward in uncapitalized form: `uRI.res`.
-
-## Ignore `.merlin` File
-
-This is generated by the build system and you should not have to manually edit it. Don't check it into the repo.
-
-**Justification**: `.merlin` is for editor tooling. The file contains absolute paths, which are also not cross-platform (e.g. Windows paths are different).
-
-## Folders
-
-Try not to have too many nested folders. Keep your project flat, and have fewer files (reminder: you can use nested modules).
-
-**Justification**: The file system is a _tree_, but your code's dependencies are a _graph_. Because of that, any file & folder organization is usually imperfect. While it's still valuable to group related files together in a folder, the time wasted debating & getting decision paralysis over these far outweight their benefits. We'll always recommend you to Get Work Done instead of debating about these issues.
-
-## Third-party Dependencies
-
-Keep them to a minimum.
-
-**Justification**: A compiled, statically typed language cannot model its dependencies easily by muddling along like in a dynamic language, especially when we're still piggy-backing on NPM/Yarn (to reduce learning overhead in the medium-term). Keeping dependencies simple & lean helps reduce possibility of conflicts (e.g. two diamond dependencies, or clashing interfaces).
-
-## Documentation
-
-Have them. Spend more effort making them great (examples, pitfalls) and professional rather than _just_ fancy-looking. Do use examples, and avoid using names such as `foo` and `bar`. There's always more concrete names (it's an example, no need to be abstract/generalized just yet. The API docs will do this plentily). For blog posts, don't repeat the docs themselves, describe the _transition_ from old to new, and why (e.g. "it was a component, now it's a function, because ...").
-
-**Justification**: It's hard for newcomers to distinguish between a simple/decent library and one that's fancy-looking. For the sake of the community, don't try too hard to one-up each other's libraries. Do spread the words, but use your judgement too.
-
-## PPX & Other Meta-tools
-
-Keep them to a minimum. PPX, unless used in renown cases (printer, accessors and serializer/deserializer generation), can cause big learning churn for newcomers; on top of the syntax, semantics, types, build tool & FFI that they already have to learn, learning per-library custom transformations of the code is an extra step. More invasive macros makes the code itself less semantically meaningful too, since the essence would be hiding somewhere else.
-
-## Paradigm
-
-Don't abuse overly fancy features. Do leave some breathing room for future APIs but don't over-architect things.
-
-**Justification**: Simple code helps newcomers understand and potentially contribute to your code. Contributing is the best way for them to learn. The extra help you receive might also surpass the gain of using a slightly more clever language trick. But do try new language tricks in some of more casual projects! You might discover new ways of architecting code.
-
-## Publishing
-
-If it's a wrapper for a JS library, don't publish the JS artifacts. If it's a legit library, publish the artifacts in lib/js if you think JS consumers might use it. This is especially the case when you gradually convert a JS lib to ReScript while not breaking existing JS consumers.
-
-Do put the keywords `"rescript"` in your package.json `keywords` field. This allows us to find the library much more easily for future purposes.
-
-**Justification**: Be nice to JS consumers of your library. They're your future ReScripters.
diff --git a/pages/docs/manual/v9.0.0/promise.mdx b/pages/docs/manual/v9.0.0/promise.mdx
deleted file mode 100644
index 43c96c84e..000000000
--- a/pages/docs/manual/v9.0.0/promise.mdx
+++ /dev/null
@@ -1,77 +0,0 @@
----
-title: "Async & Promise"
-description: "JS Promise handling in ReScript"
-canonical: "/docs/manual/latest/promise"
----
-
-# Async & Promise
-
-ReScript's primary mechanism for async programming is the same as JavaScript's (callbacks and promises), since we compile cleanly to JavaScript and would like to avoid dragging in a heavy custom runtime.
-
-However, it is planned for us to introduce a coroutine-like feature in the future; for that reason, we're postponing introducing the keywords `async` and `await` into the language; though our (upcoming) Promise API bindings revamp + [pipe](pipe) will make your async code already look better than otherwise.
-
-## Promise
-
-ReScript has built-in support for [JavaScript promises](api/js/promise). The 3 functions you generally need are:
-
-- `Js.Promise.resolve: 'a => Js.Promise.t('a)`
-- `Js.Promise.then_: ('a => Js.Promise.t('b), Js.Promise.t('a)) => Js.Promise.t('b)`
-- `Js.Promise.catch: (Js.Promise.error => Js.Promise.t('a), Js.Promise.t('a)) => Js.Promise.t('a)`
-
-Additionally, here's the type signature for creating a promise on the ReScript side:
-
-```res
-Js.Promise.make: (
-  (
-    ~resolve: (. 'a) => unit,
-    ~reject: (. exn) => unit
-  ) => unit
-) => Js.Promise.t<'a>
-```
-
-This type signature means that `make` takes a callback that takes 2 named arguments, `resolve` and `reject`. Both arguments are themselves [uncurried callbacks](
-function.md#uncurried-function) (with a dot). `make` returns the created promise.
-
-## Usage
-
-Using the [pipe operator](pipe.md):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myPromise = Js.Promise.make((~resolve, ~reject) => resolve(. 2))
-
-myPromise->Js.Promise.then_(value => {
-  Js.log(value)
-  Js.Promise.resolve(value + 2)
-}, _)->Js.Promise.then_(value => {
-  Js.log(value)
-  Js.Promise.resolve(value + 3)
-}, _)->Js.Promise.catch(err => {
-  Js.log2("Failure!!", err)
-  Js.Promise.resolve(-2)
-}, _)
-```
-```js
-var myPromise = new Promise(function (resolve, reject) {
-  return resolve(2);
-});
-
-myPromise
-  .then(function (value) {
-    console.log(value);
-    return Promise.resolve((value + 2) | 0);
-  })
-  .then(function (value) {
-    console.log(value);
-    return Promise.resolve((value + 3) | 0);
-  })
-  .catch(function (err) {
-    console.log("Failure!!", err);
-    return Promise.resolve(-2);
-  });
-```
-
-</CodeTab>
-
-
diff --git a/pages/docs/manual/v9.0.0/record.mdx b/pages/docs/manual/v9.0.0/record.mdx
deleted file mode 100644
index d936ce59f..000000000
--- a/pages/docs/manual/v9.0.0/record.mdx
+++ /dev/null
@@ -1,197 +0,0 @@
----
-title: "Record"
-description: "Record types in ReScript"
-canonical: "/docs/manual/latest/record"
----
-
-# Record
-
-Records are like JavaScript objects but:
-
-- are immutable by default
-- have fixed fields (not extensible)
-
-## Type Declaration
-
-A record needs a mandatory type declaration:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type person = {
-  age: int,
-  name: string
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Creation
-
-To create a `person` record (declared above):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let me = {
-  age: 5,
-  name: "Big ReScript"
-}
-```
-```js
-var me = {
-  age: 5,
-  name: "Big ReScript"
-};
-```
-
-</CodeTab>
-
-When you create a new record value, ReScript tries to find a record type declaration that conforms to the shape of the value. So the `me` value here is inferred as of type `person`.
-
-The type is found by looking above the `me` value. **Note**: if the type instead resides in another file or module, you need to explicitly indicate which file or module it is:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// School.res
-type person = {age: int, name: string}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Example.res
-
-let me: School.person = {age: 20, name: "Big ReScript"}
-/* or */
-let me2 = {School.age: 20, name: "Big ReScript"}
-```
-```js
-var me = {
-  age: 20,
-  name: "Big ReScript"
-};
-var me2 = {
-  age: 20,
-  name: "Big ReScript"
-};
-```
-
-</CodeTab>
-
-Either of the above 3 says "this record's definition is found in the School file". The first one, the regular type annotation, is preferred.
-
-## Access
-
-Use the familiar dot notation:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let name = me.name
-```
-```js
-var name = "Big ReScript";
-```
-
-</CodeTab>
-
-## Immutable Update
-
-New records can be created from old records with the `...` spread operator. The original record isn't mutated.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let meNextYear = {...me, age: me.age + 1}
-```
-```js
-var meNextYear = {
-  age: 21,
-  name: "Big ReScript"
-};
-```
-
-</CodeTab>
-
-**Note**: spread cannot add new fields to the record value, as a record's shape is fixed by its type.
-
-## Mutable Update
-
-Record fields can optionally be mutable. This allows you to efficiently update those fields in-place with the `=` operator.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type person = {
-  name: string,
-  mutable age: int
-}
-
-let baby = {name: "Baby ReScript", age: 5}
-baby.age = baby.age + 1 // `baby.age` is now 6. Happy birthday!
-```
-```js
-var baby = {
-  name: "Baby ReScript",
-  age: 5
-};
-
-baby.age = baby.age + 1 | 0;
-```
-
-</CodeTab>
-
-Fields not marked with `mutable` in the type declaration cannot be mutated.
-
-## JavaScript Output
-
-ReScript records compile to straightforward JavaScript objects; see the various JS output tabs above.
-
-## Tips & Tricks
-
-**Record Types Are Found By Field Name**. With records, you **cannot** say "I'd like this function to take any record type, as long as they have the field `age`". The following **won't work as intended**:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type person = {age: int, name: string}
-type monster = {age: int, hasTentacles: bool}
-
-let getAge = (entity) => entity.age
-```
-```js
-function getAge(entity) {
-  return entity.age;
-}
-```
-
-</CodeTab>
-
-Instead, `getAge` will infer that the parameter `entity` must be of type `monster`, the closest record type with the field `age`. The following code's last line fails:
-
-```res
-let kraken = {age: 9999, hasTentacles: true}
-let me = {age: 5, name: "Baby ReScript"}
-
-getAge(kraken)
-getAge(me) // type error!
-```
-
-The type system will complain that `me` is a `person`, and that `getAge` only works on `monster`. If you need such capability, use ReScript objects, described [here](object.md).
-
-## Design Decisions
-
-After reading the constraints in the previous sections, and if you're coming from a dynamic language background, you might be wondering why one would bother with record in the first place instead of straight using object, since the former needs explicit typing and doesn't allow different records with the same field name to be passed to the same function, etc.
-
-1. The truth is that most of the times in your app, your data's shape is actually fixed, and if it's not, it can potentially be better represented as a combination of variant (introduced next) + record instead.
-2. Since a record type is resolved through finding that single explicit type declaration (we call this "nominal typing"), the type error messages end up better than the counterpart ("structural typing", like for tuples). This makes refactoring easier; changing a record type's fields naturally allows the compiler to know that it's still the same record, just misused in some places. Otherwise, under structural typing, it might get hard to tell whether the definition site or the usage site is wrong.
diff --git a/pages/docs/manual/v9.0.0/reserved-keywords.mdx b/pages/docs/manual/v9.0.0/reserved-keywords.mdx
deleted file mode 100644
index aab048bcb..000000000
--- a/pages/docs/manual/v9.0.0/reserved-keywords.mdx
+++ /dev/null
@@ -1,94 +0,0 @@
----
-title: "Reserved Keyword"
-description: "All reserved keywords in ReScript"
-canonical: "/docs/manual/latest/reserved-keywords"
----
-
-# Reserved Keywords
-
-> **Note**: Some of these words are reserved purely for backward compatibility.
->
-> If you _need_ to use one of these names as binding and/or field name, see [Use Illegal Identifier Names](use-illegal-identifier-names.md).
-
-- `and`
-- `as`
-- `assert`
-
-
-<!-- - `begin` -->
-
-
-<!-- - `class` -->
-- `constraint`
-
-
-<!-- - `do` -->
-<!-- - `done` -->
-- `downto`
-
-
-- `else`
-<!-- - `end` -->
-<!-- - `esfun` -->
-- `exception`
-- `external`
-
-
-- `false`
-- `for`
-<!-- - `fun` -->
-<!-- - `function` -->
-<!-- - `functor` -->
-
-
-- `if`
-- `in`
-- `include`
-<!-- - `inherit` -->
-<!-- - `initializer` -->
-
-
-- `lazy`
-- `let`
-
-
-- `module`
-- `mutable`
-
-
-<!-- - `new` -->
-<!-- - `nonrec` -->
-
-
-<!-- - `object` -->
-- `of`
-- `open`
-<!-- - `or` -->
-
-
-<!-- - `pri` -->
-<!-- - `pub` -->
-
-
-- `rec`
-
-
-<!-- - `sig` -->
-<!-- - `struct` -->
-- `switch`
-
-
-<!-- - `then` -->
-- `to`
-- `true`
-- `try`
-- `type`
-
-
-<!-- - `val` -->
-<!-- - `virtual` -->
-
-
-- `when`
-- `while`
-- `with`
diff --git a/pages/docs/manual/v9.0.0/shared-data-types.mdx b/pages/docs/manual/v9.0.0/shared-data-types.mdx
deleted file mode 100644
index d6ae8e914..000000000
--- a/pages/docs/manual/v9.0.0/shared-data-types.mdx
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: "Shared Data Types"
-description: "Data types that share runtime presentation between JS and ReScript"
-canonical: "/docs/manual/latest/shared-data-types"
----
-
-# Shared Data Types
-
-ReScript's built-in values of type `string`, `float`, `array` and a few others have a rather interesting property: they compile to the exact same value in JavaScript!
-
-This means that if you're passing e.g. a ReScript string to the JavaScript side, the JS side can directly use it as a native JS string. It also means that you can import a JS string and pretend it's a native ReScript string.
-
-Unlike most compiled-to-js languages, in ReScript, **you don't need to write data converters back and forth for most of our values**!
-
-**Shared, bidirectionally usable types**:
-- String. ReScript strings are JavaScript strings, vice-versa. (Caveat: only our backtick string `` `hello 👋 ${personName}` `` supports unicode and interpolation).
-- Float. ReScript floats are JS numbers, vice-versa.
-- Array. In addition to the [JS Array API](api/js/array), we provide our own [Belt.Array](api/belt/array#set) API too.
-- Tuple. Compiles to a JS array. You can treat a fixed-sized, heterogenous JS array as ReScript tuple too.
-- Boolean.
-- Record. Record compiles to JS object. Therefore you can also treat JS objects as records. If they're too dynamic, consider modeling them on the ReScript side as a hashmap/dictionary [`Js.Dict`](api/js/dict) or a ReScript object.
-- Object. ReScript objects are JavaScript objects, vice-versa.
-- Function. They compile to clean JS functions.
-- Module. ReScript files are considered top-level modules, and are compiled to JS files 1 to 1. Nested modules are compiled to JavaScript objects.
-- Unit. The `unit` type, which has a single value `()`, compiles to `undefined` too. Likewise, you can treat an incoming JS `undefined` as `()`.
-
-<!-- TODO: talk about poly variant -->
-
-**Types that are slightly different than JS, but that you can still use from JS**:
-- Int. **Ints are 32-bits**! Be careful, you can potentially treat them as JS numbers and vice-versa, but if the number's large, then you better treat JS numbers as floats. For example, we bind to Js.Date using `float`s.
-- Option. The `option` type's `None` value compiles into JS `undefined`. The `Some` value, e.g. `Some(5)`, compiles to `5`. Likewise, you can treat an incoming JS `undefined` as `None`. **JS `null` isn't handled here**. If your JS value can be `null`, use [Js.Nullable](api/js/nullable) helpers.
-- Exception.
-- Variant. Check the compiled JavaScript output of variant to see its shape. We don't recommend exporting a ReScript variant for pure JS usage, but you can do that if you have some interop needs.
-- List, which is just a regular variant.
-
-**Non-shared types (aka internal types)**:
-
-- Character.
-- Int64.
-- Lazy values.
-- Everything else.
-
-Many of these are stable, which means that you can still serialize/deserialize them as-is without manual conversions. But we discourage actively peeking into their structure otherwise.
-
-These types require manual conversions if you want to export them for JS consumption. For a seamless JS/TypeScript/Flow integration experience, you might want to use [genType](https://github.com/cristianoc/gentype) instead of doing conversions by hand.
diff --git a/pages/docs/manual/v9.0.0/try.mdx b/pages/docs/manual/v9.0.0/try.mdx
deleted file mode 100644
index 6dabb9474..000000000
--- a/pages/docs/manual/v9.0.0/try.mdx
+++ /dev/null
@@ -1,93 +0,0 @@
----
-title: "Try"
-description: "Try ReScript via Command Line"
-canonical: "/docs/manual/latest/try"
----
-
-## Try Online
-
-Our [Playground](/try) lets you try ReScript online, and comes with [ReScript-React](/docs/react/latest/introduction) preinstalled.
-
-## Quickly Evaluate Code In Terminal
-
-Use `bsc -e`:
-
-```sh
-❯ bsc -e 'let add = (x, y) => x + y'
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-
-function add(x, y) {
-  return x + y | 0;
-}
-
-exports.add = add;
-/* No side effect */
-```
-
-You can pipe the output to Node to run it:
-
-```sh
-❯ bsc -e 'let add = (x, y) => x + y; Js.log(add(1, 2))' | node
-3
-```
-
-## Quickly Compile A Single File
-
-You can compile a file directly via `bsc MyFile.res`:
-
-```res example
-// MyFile.res
-let rec fib = n => {
-  switch n {
-  | 0 | 1 => n
-  | n => fib(n - 1) + fib(n - 2)
-  }
-}
-Js.log(fib(0))
-```
-
-```sh
-❯ bsc MyFile.res
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-
-function fib(n) {
-  if (n === 0 || n === 1) {
-    return n;
-  } else {
-    return fib(n - 1 | 0) + fib(n - 2 | 0) | 0;
-  }
-}
-
-console.log(fib(0));
-
-exports.fib = fib;
-/*  Not a pure module */
-```
-
-You can also get the inferred type signatures directly via `bsc -i MyFile.res`
-
-```sh
-❯ bsc -i MyFile.res
-let fib: int => int
-```
-
-**Note** that this is for quick tests. For real projects, use our [build system](build-overview.md).
-
-## Format Code
-
-```sh
-❯ bsc -format MyFile.res
-let rec fib = n => {
-  switch n {
-  | 0 | 1 => n
-  | n => fib(n - 1) + fib(n - 2)
-  }
-}
-Js.log(fib(0))
-```
-
-Our [editor plugins](editor-plugins.md) come with formatting by default.
diff --git a/pages/docs/manual/v9.0.0/tuple.mdx b/pages/docs/manual/v9.0.0/tuple.mdx
deleted file mode 100644
index 951584c4f..000000000
--- a/pages/docs/manual/v9.0.0/tuple.mdx
+++ /dev/null
@@ -1,104 +0,0 @@
----
-title: "Tuple"
-description: "Tuple types and values in ReScript"
-canonical: "/docs/manual/latest/tuple"
----
-
-# Tuple
-
-Tuples are a ReScript-specific data structure that don't exist in JavaScript. They are:
-
-- immutable
-- ordered
-- fix-sized at creation time
-- heterogeneous (can contain different types of values)
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let ageAndName = (24, "Lil' ReScript")
-let my3dCoordinates = (20.0, 30.5, 100.0)
-```
-```js
-var ageAndName = [24, "Lil' ReScript"];
-var my3dCoordinates = [20.0, 30.5, 100.0];
-```
-
-</CodeTab>
-
-Tuples' types can be used in type annotations as well. Tuple types visually resemble tuples values.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-let ageAndName: (int, string) = (24, "Lil' ReScript")
-// a tuple type alias
-type coord3d = (float, float, float)
-let my3dCoordinates: coord3d = (20.0, 30.5, 100.0)
-```
-```js
-var ageAndName = [24, "Lil' ReScript"];
-var my3dCoordinates = [20.0, 30.5, 100.0];
-```
-</CodeTab>
-
-**Note**: there's no tuple of size 1. You'd just use the value itself.
-
-## Usage
-
-To get a specific member of a tuple, destructure it:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let (_, y, _) = my3dCoordinates // now you've retrieved y
-```
-```js
-var y = 30.5;
-```
-
-</CodeTab>
-
-The `_` means you're ignoring the indicated members of the tuple.
-
-Tuples aren't meant to be updated mutatively. You'd create new ones by destructuring the old ones:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let coordinates1 = (10, 20, 30)
-let (c1x, _, _) = coordinates1
-let coordinates2 = (c1x + 50, 20, 30)
-```
-```js
-var coordinates1 = [10, 20, 30];
-var c1x = 10;
-var coordinates2 = [60, 20, 30];
-```
-
-</CodeTab>
-
-## Tips & Tricks
-
-You'd use tuples in handy situations that pass around multiple values without too much ceremony. For example, to return many values:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let getCenterCoordinates = () => {
-  let x = doSomeOperationsHere()
-  let y = doSomeMoreOperationsHere()
-  (x, y)
-}
-```
-```js
-function getCenterCoordinates(param) {
-  var x = doSomeOperationsHere(undefined);
-  var y = doSomeMoreOperationsHere(undefined);
-  return [x, y];
-}
-```
-
-</CodeTab>
-
-Try to keep the usage of tuple **local**. For data structures that are long-living and passed around often, prefer a **record**, which has named fields.
diff --git a/pages/docs/manual/v9.0.0/type.mdx b/pages/docs/manual/v9.0.0/type.mdx
deleted file mode 100644
index 905581cb1..000000000
--- a/pages/docs/manual/v9.0.0/type.mdx
+++ /dev/null
@@ -1,278 +0,0 @@
----
-title: "Type"
-description: "Types and type definitions in ReScript"
-canonical: "/docs/manual/latest/type"
----
-
-# Type
-
-Types are the highlight of ReScript! They are:
-- **Strong**. A type can't change into another type. In JavaScript, your variable's type might change when the code runs (aka at runtime). E.g. a `number` variable might change into a `string` sometimes. This is an anti-feature; it makes the code much harder to understand when reading or debugging.
-- **Static**. ReScript types are erased after compilation and don't exist at runtime. Never worry about your types dragging down performance. You don't need type info during runtime; we report all the information (especially all the type errors) during compile time. Catch the bugs earlier!
-- **Sound**. This is our biggest differentiator versus many other typed languages that compile to JavaScript. Our type system is guaranteed to **never** be wrong. Most type systems make a guess at the type of a value and show you a type in your editor that's sometime incorrect. We don't do that. We believe that a type system that is sometime incorrect can end up being dangerous due to expectation mismatches.
-- **Fast**. Many developers underestimate how much of their project's build time goes into type checking. Our type checker is one of the fastest around.
-- **Inferred**. You don't have to write down the types! ReScript can deduce them from their values. Yes, it might seem magical that we can deduce all of your program's types, without incorrectness, without your manual annotation, and do so quickly. Welcome to ReScript =).
-
-The following sections explore more of our type system.
-
-## Inference
-
-This let-binding doesn't contain any written type:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let score = 10
-let add = (a, b) => a + b
-```
-```js
-var score = 10;
-function add(a, b) {
-  return a + b | 0;
-}
-```
-
-</CodeTab>
-
-ReScript knows that `score` is an `int`, judging by the value `10`. This is called **inference**. Likewise, it also knows that the `add` function takes 2 `int`s and returns an `int`, judging from the `+` operator, which works on ints.
-
-## Type Annotation
-
-But you can also optionally write down the type, aka annotate your value:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let score: int = 10
-```
-```js
-var score = 10;
-```
-
-</CodeTab>
-
-If the type annotation for `score` doesn't correspond to our inferred type for it, we'll show you an error during compilation time. We **won't** silently assume your type annotation is correct, unlike many other languages.
-
-You can also wrap any expression in parentheses and annotate it:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-let myInt = 5
-let myInt: int = 5
-let myInt = (5: int) + (4: int)
-let add = (x: int, y: int) : int => x + y
-let drawCircle = (~radius as r: int): circleType => /* code here */
-```
-```js
-var myInt = 9;
-function add(x, y) {
-  return x + y | 0;
-}
-function drawCircle(r) {
-  /* code here */
-}
-```
-
-</CodeTab>
-
-Note: in the last line, `(~radius as r: int)` is a labeled argument. More on this in the [function](function.md) page.
-
-## Type Alias
-
-You can refer to a type by a different name. They'll be equivalent:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type scoreType = int
-let x: scoreType = 10
-```
-```js
-var x = 10;
-```
-
-</CodeTab>
-
-## Type Parameter (Aka Generic)
-
-Types can accept parameters, akin to generics in other languages. The parameters' names **need** to start with `'`.
-
-The use-case of a parameterized type is to kill duplications. Before:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// this is a tuple of 3 items, explained next
-type intCoordinates = (int, int, int)
-type floatCoordinates = (float, float, float)
-
-let a: intCoordinates = (10, 20, 20)
-let b: floatCoordinates = (10.5, 20.5, 20.5)
-```
-```js
-var a = [10, 20, 20];
-var b = [10.5, 20.5, 20.5];
-```
-
-</CodeTab>
-
-After:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type coordinates<'a> = ('a, 'a, 'a)
-
-let a: coordinates<int> = (10, 20, 20)
-let b: coordinates<float> = (10.5, 20.5, 20.5)
-```
-```js
-var a = [10, 20, 20];
-var b = [10.5, 20.5, 20.5];
-```
-
-</CodeTab>
-
-Note that the above codes are just contrived examples for illustration purposes. Since the types are inferred, you could have just written:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let buddy = (10, 20, 20)
-```
-```js
-var buddy = [10, 20, 20];
-```
-
-</CodeTab>
-
-The type system infers that it's a `(int, int, int)`. Nothing else needed to be written down.
-
-Type arguments appear in many places. Our `array<'a>` type is such a type that requires a type parameter
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// inferred as `array<string>`
-let greetings = ["hello", "world", "how are you"]
-```
-```js
-// inferred as `array<string>`
-var greetings = ["hello", "world", "how are you"];
-```
-
-</CodeTab>
-
-If types didn't accept parameters, the standard library would need to define the types `arrayOfString`, `arrayOfInt`, `arrayOfTuplesOfInt`, etc. That'd be tedious.
-
-Types can receive many arguments, and be composable.
-
-<!-- TODO: too early for this example -->
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type result<'a, 'b> =
-  | Ok('a)
-  | Error('b)
-
-type myPayload = {data: string}
-
-type myPayloadResults<'errorType> = array<result<myPayload, 'errorType>>
-
-let payloadResults: myPayloadResults<string> = [
-  Ok({data: "hi"}),
-  Ok({data: "bye"}),
-  Error("Something wrong happened!")
-]
-```
-```js
-var payloadResults = [
-  {
-    TAG: /* Ok */0,
-    _0: {data: "hi"}
-  },
-  {
-    TAG: /* Ok */0,
-    _0: {data: "bye"}
-  },
-  {
-    TAG: /* Error */1,
-    _0: "Something wrong happened!"
-  }
-];
-```
-
-</CodeTab>
-
-## Recursive Types
-
-Just like a functions, a type can reference itself within itself using `rec`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type rec person = {
-  name: string,
-  friends: array<person>
-}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Mutually Recursive Types
-
-Types can also be _mutually_ recursive through `and`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type rec student = {taughtBy: teacher}
-and teacher = {students: array<student>}
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-## Type Escape Hatch
-
-ReScript's type system is robust and does not allow dangerous, unsafe stuff like implicit type casting, randomly guessing a value's type, etc. However, out of pragmatism, we expose a single escape hatch for you to "lie" to the type system:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-external myShadyConversion: myType1 => myType2 = "%identity"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-This declaration converts a `myType1` of your choice to `myType2` of your choice. You can use it like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-external convertToFloat : int => float = "%identity"
-let age = 10
-let gpa = 2.1 +. convertToFloat(age)
-```
-```js
-var age = 10;
-var gpa = 2.1 + 10;
-```
-
-</CodeTab>
-
-Obviously, do **not** abuse this feature. Use it tastefully when you're working with existing, overly dynamic JS code, for example.
-
-More on externals [here](external.md).
-
-**Note**: this particular `external` is the only one that isn't preceded by a `@bs` annotation.
diff --git a/pages/docs/manual/v9.0.0/unboxed.mdx b/pages/docs/manual/v9.0.0/unboxed.mdx
deleted file mode 100644
index 6ebe3c4b3..000000000
--- a/pages/docs/manual/v9.0.0/unboxed.mdx
+++ /dev/null
@@ -1,157 +0,0 @@
----
-title: "Unboxed"
-description: "Unbox a wrapper"
-canonical: "/docs/manual/latest/unboxed"
----
-
-# Unboxed
-
-Consider a ReScript variant with a single payload, and a record with a single field:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-type name = Name(string)
-let studentName = Name("Joe")
-
-type greeting = {message: string}
-let hi = {message: "hello!"}
-```
-```js
-var studentName = /* Name */{
-  _0: "Joe"
-};
-
-var hi = {
-  message: "hello!"
-};
-```
-
-</CodeTab>
-
-If you check the JavaScript output, you'll see the `studentName` and `hi` JS object, as expected (see the [variant JS output](variant#javascript-output) and [record JS output](record#javascript-output) sections for details).
-
-For performance and certain JavaScript interop situations, ReScript offers a way to unwrap (aka unbox) the JS object wrappers from the output for records with a single field and variants with a single constructor and single payload. Annotate their type declaration with the attribute `@unboxed`:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-@unboxed
-type name = Name(string)
-let studentName = Name("Joe")
-
-@unboxed
-type greeting = {message: string}
-let hi = {message: "hello!"}
-```
-```js
-var studentName = "Joe";
-
-var hi = "hello!";
-```
-
-</CodeTab>
-
-Check the new output! Clean.
-
-## Usage
-
-Why would you ever want a variant or a record with a single payload? Why not just... pass the payload? Here's one use-case for variant.
-
-Suppose you have a game with a local/global coordinate system:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type coordinates = {x: float, y: float}
-
-let renderDot = (coordinates) => {
-  Js.log3("Pretend to draw at:", coordinates.x, coordinates.y)
-}
-
-let toWorldCoordinates = (localCoordinates) => {
-  {
-    x: localCoordinates.x +. 10.,
-    y: localCoordinates.x +. 20.,
-  }
-}
-
-let playerLocalCoordinates = {x: 20.5, y: 30.5}
-
-renderDot(playerLocalCoordinates)
-```
-```js
-function renderDot(coordinates) {
-  console.log("Pretend to draw at:", coordinates.x, coordinates.y);
-}
-
-function toWorldCoordinates(localCoordinates) {
-  return {
-    x: localCoordinates.x + 10,
-    y: localCoordinates.x + 20
-  };
-}
-
-var playerLocalCoordinates = {
-  x: 20.5,
-  y: 30.5
-};
-
-renderDot(playerLocalCoordinates);
-```
-
-</CodeTab>
-
-Oops, that's wrong! `renderDot` should have taken global coordinates, not local ones... Let's prevent passing the wrong kind of coordinates:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type coordinates = {x: float, y: float}
-@unboxed type localCoordinates = Local(coordinates)
-@unboxed type worldCoordinates = World(coordinates)
-
-let renderDot = (World(coordinates)) => {
-  Js.log3("Pretend to draw at:", coordinates.x, coordinates.y)
-}
-
-let toWorldCoordinates = (Local(coordinates)) => {
-  World({
-    x: coordinates.x +. 10.,
-    y: coordinates.x +. 20.,
-  })
-}
-
-let playerLocalCoordinates = Local({x: 20.5, y: 30.5})
-
-// This now errors!
-// renderDot(playerLocalCoordinates)
-// We're forced to do this instead:
-renderDot(playerLocalCoordinates->toWorldCoordinates)
-```
-```js
-function renderDot(coordinates) {
-  console.log("Pretend to draw at:", coordinates.x, coordinates.y);
-}
-
-function toWorldCoordinates(coordinates) {
-  return {
-    x: coordinates.x + 10,
-    y: coordinates.x + 20
-  };
-}
-
-var playerLocalCoordinates = {
-  x: 20.5,
-  y: 30.5
-};
-
-renderDot(toWorldCoordinates(playerLocalCoordinates));
-```
-
-</CodeTab>
-
-Now `renderDot` only takes `worldCoordinates`. Through a nice combination of using distinct variant types + argument destructuring, we've achieved better safety **without compromising on performance**: the `unboxed` attribute compiled to clean, variant-wrapper-less JS code! Check the output.
-
-As for a record with a single field, the use-cases are a bit more edgy. We won't mention them here.
-
diff --git a/pages/docs/manual/v9.0.0/use-illegal-identifier-names.mdx b/pages/docs/manual/v9.0.0/use-illegal-identifier-names.mdx
deleted file mode 100644
index a1e2eaf58..000000000
--- a/pages/docs/manual/v9.0.0/use-illegal-identifier-names.mdx
+++ /dev/null
@@ -1,51 +0,0 @@
----
-title: "Use Illegal Identifier Names"
-description: "Handling (JS) naming collisions in ReScript"
-canonical: "/docs/manual/latest/use-illegal-identifier-names"
----
-
-# Use Illegal Identifier Names
-
-Sometime, for e.g. a let binding or a record field, you might want to use:
-- A capitalized name.
-- A name that contains illegal characters (e.g. emojis, hyphen, space).
-- A name that's one of ReScript's reserved keywords.
-
-We provide an escape hatch syntax for these cases:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let \"my-🍎" = 10
-
-type element = {
-  \"aria-label": string
-}
-
-let myElement = {
-  \"aria-label": "close"
-}
-
-let label = myElement.\"aria-label"
-
-let calculate = (~\"Props") => {
-  \"Props" + 1
-}
-```
-```js
-var my$$unknown$unknown$unknown$unknown = 10;
-
-var myElement = {
-  "aria-label": "close"
-};
-
-var label = myElement["aria-label"];
-
-function calculate(Props) {
-  return Props + 1 | 0;
-}
-```
-
-</CodeTab>
-
-See the output. **Use them only when necessary**, for interop with JavaScript. This is a last-resort feature. If you abuse this, many of the compiler guarantees will go away.
diff --git a/pages/docs/manual/v9.0.0/variant.mdx b/pages/docs/manual/v9.0.0/variant.mdx
deleted file mode 100644
index 5ce99deb0..000000000
--- a/pages/docs/manual/v9.0.0/variant.mdx
+++ /dev/null
@@ -1,358 +0,0 @@
----
-title: "Variant"
-description: "Variant data structures in ReScript"
-canonical: "/docs/manual/latest/variant"
----
-
-# Variant
-
-So far, most of ReScript's data structures might look familiar to you. This section introduces an extremely important, and perhaps unfamiliar, data structure: variant.
-
-Most data structures in most languages are about "this **and** that". A variant allows us to express "this **or** that".
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type myResponse =
-  | Yes
-  | No
-  | PrettyMuch
-
-let areYouCrushingIt = Yes
-```
-```js
-var areYouCrushingIt = /* Yes */0;
-```
-
-</CodeTab>
-
-`myResponse` is a variant type with the cases `Yes`, `No` and `PrettyMuch`, which are called "variant constructors" (or "variant tag"). The `|` bar separates each constructor.
-
-**Note**: a variant's constructors need to be capitalized.
-
-## Variant Needs an Explicit Definition
-
-If the variant you're using is in a different file, bring it into scope like you'd do [for a record](record.md#record-needs-an-explicit-definition):
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// Zoo.res
-type animal = Dog | Cat | Bird
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res
-// Example.res
-let pet: Zoo.animal = Dog // preferred
-// or
-let pet2 = Zoo.Dog
-```
-```js
-var pet = /* Dog */0;
-var pet2 = /* Dog */0;
-```
-
-</CodeTab>
-
-## Constructor Arguments
-
-A variant's constructors can hold extra data separated by comma.
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res prelude
-type account =
-  | None
-  | Instagram(string)
-  | Facebook(string, int)
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-Here, `Instagram` holds a `string`, and `Facebook` holds a `string` and an `int`. Usage:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let myAccount = Facebook("Josh", 26)
-let friendAccount = Instagram("Jenny")
-```
-```js
-var myAccount = {
-  TAG: /* Facebook */1,
-  _0: "Josh",
-  _1: 26
-};
-var friendAccount = {
-  TAG: /* Instagram */0,
-  _0: "Jenny"
-};
-```
-
-</CodeTab>
-
-### Labeled Variant Payloads (Inline Record)
-
-If a variant payload has multiple fields, you can use a record-like syntax to label them for better readability:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type user =
-  | Number(int)
-  | Id({name: string, password: string})
-
-let me = Id({name: "Joe", password: "123"})
-```
-```js
-var me = {
-  TAG: /* Id */1,
-  name: "Joe",
-  password: "123"
-};
-```
-
-</CodeTab>
-
-This is technically called an "inline record", and only allowed within a variant constructor. You cannot inline a record type declaration anywhere else in ReScript.
-
-Of course, you can just put a regular record type in a variant too:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type u = {name: string, password: string}
-type user =
-  | Number(int)
-  | Id(u)
-
-let me = Id({name: "Joe", password: "123"})
-```
-```js
-var me = {
-  TAG: /* Id */1,
-  _0: {
-    name: "Joe",
-    password: "123"
-  }
-};
-```
-
-</CodeTab>
-
-The output is slightly uglier and less performant than the former.
-
-### Pattern Matching On Variant
-
-See the [Pattern Matching/Destructuring](pattern-matching-destructuring.md) section later.
-
-## JavaScript Output
-
-A variant value compiles to 3 possible JavaScript outputs depending on its type declaration:
-
-- If the variant value is a constructor with no payload, it compiles to a number.
-- If it's a constructor with a payload, it compiles to an object with the field `TAG` and the field `_0` for the first payload, `_1` for the second payload, etc.
-- An exception to the above is a variant whose type declaration contains only a single constructor with payload. In that case, the constructor compiles to an object without the `TAG` field.
-- Labeled variant payloads (the inline record trick earlier) compile to an object with the label names instead of `_0`, `_1`, etc. The object might or might not have the `TAG` field as per previous rule.
-
-Check the output in these examples:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type greeting = Hello | Goodbye
-let g1 = Hello
-let g2 = Goodbye
-
-type outcome = Good | Error(string)
-let o1 = Good
-let o2 = Error("oops!")
-
-type family = Child | Mom(int, string) | Dad (int)
-let f1 = Child
-let f2 = Mom(30, "Jane")
-let f3 = Dad(32)
-
-type person = Teacher | Student({gpa: float})
-let p1 = Teacher
-let p2 = Student({gpa: 99.5})
-
-type s = {score: float}
-type adventurer = Warrior(s) | Wizard(string)
-let a1 = Warrior({score: 10.5})
-let a2 = Wizard("Joe")
-```
-```js
-var g1 = /* Hello */0;
-var g2 = /* Goodbye */1;
-
-var o1 = /* Good */0;
-var o2 = /* Error */{
-  _0: "oops!"
-};
-
-var f1 = /* Child */0;
-var f2 = {
-  TAG: /* Mom */0,
-  _0: 30,
-  _1: "Jane"
-};
-var f3 = {
-  TAG: /* Dad */1,
-  _0: 32
-};
-
-var p1 = /* Teacher */0;
-var p2 = /* Student */{
-  gpa: 99.5
-};
-
-var a1 = {
-  TAG: /* Warrior */0,
-  _0: {
-    score: 10.5
-  }
-};
-var a2 = {
-  TAG: /* Wizard */1,
-  _0: "Joe"
-};
-```
-
-</CodeTab>
-
-## Tips & Tricks
-
-**Be careful** not to confuse a constructor carrying 2 arguments with a constructor carrying a single tuple argument:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type account =
-  | Facebook(string, int) // 2 arguments
-type account2 =
-  | Instagram((string, int)) // 1 argument - happens to be a 2-tuple
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-### Variants Must Have Constructors
-
-If you come from an untyped language, you might be tempted to try `type myType = int | string`. This isn't possible in ReScript; you'd have to give each branch a constructor: `type myType = Int(int) | String(string)`. The former looks nice, but causes lots of trouble down the line.
-
-### Interop with JavaScript
-
-_This section assumes knowledge about our JavaScript interop. Skip this if you haven't felt the itch to use variants for wrapping JS functions yet_.
-
-Quite a few JS libraries use functions that can accept many types of arguments. In these cases, it's very tempting to model them as variants. For example, suppose there's a `myLibrary.draw` JS function that takes in either a `number` or a `string`. You might be tempted to bind it like so:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-// reserved for internal usage
-@bs.module("myLibrary") external draw : 'a => unit = "draw"
-
-type animal =
-  | MyFloat(float)
-  | MyString(string)
-
-let betterDraw = (animal) =>
-  switch animal {
-  | MyFloat(f) => draw(f)
-  | MyString(s) => draw(s)
-  }
-
-betterDraw(MyFloat(1.5))
-```
-```js
-var MyLibrary = require("myLibrary");
-
-function betterDraw(animal) {
-  MyLibrary.draw(animal._0);
-}
-
-betterDraw({
-  TAG: /* MyFloat */0,
-  _0: 1.5
-});
-```
-
-</CodeTab>
-
-**Try not to do that**, as this generates extra noisy output. Alternatively, define two `external`s that both compile to the same JS call:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-@bs.module("myLibrary") external drawFloat: float => unit = "draw"
-@bs.module("myLibrary") external drawString: string => unit = "draw"
-```
-```js
-// Empty output
-```
-
-</CodeTab>
-
-ReScript also provides [a few other ways](bind-to-js-function.md#modeling-polymorphic-function) to do this.
-
-### Variant Types Are Found By Field Name
-
-Please refer to this [record section](record#record-types-are-found-by-field-name). Variants are the same: a function can't accept an arbitrary constructor shared by two different variants. Again, such feature exists; it's called a polymorphic variant. We'll talk about this in the future =).
-
-## Design Decisions
-
-Variants, in their many forms (polymorphic variant, open variant, GADT, etc.), are likely _the_ feature of a type system such as ReScript's. The aforementioned `option` variant, for example, obliterates the need for nullable types, a major source of bugs in other languages. Philosophically speaking, a problem is composed of many possible branches/conditions. Mishandling these conditions is the majority of what we call bugs. **A type system doesn't magically eliminate bugs; it points out the unhandled conditions and asks you to cover them**\*. The ability to model "this or that" correctly is crucial.
-
-For example, some folks wonder how the type system can safely eliminate badly formatted JSON data from propagating into their program. They don't, not by themselves! But if the parser returns the `option` type `None | Some(actualData)`, then you'd have to handle the `None` case explicitly in later call sites. That's all there is.
-
-Performance-wise, a variant can potentially tremendously speed up your program's logic. Here's a piece of JavaScript:
-
-```js
-let data = 'dog'
-if (data === 'dog') {
-  ...
-} else if (data === 'cat') {
-  ...
-} else if (data === 'bird') {
-  ...
-}
-```
-
-There's a linear amount of branch checking here (`O(n)`). Compare this to using a ReScript variant:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-type animal = Dog | Cat | Bird
-let data = Dog
-switch data {
-| Dog => Js.log("Wof")
-| Cat => Js.log("Meow")
-| Bird => Js.log("Kashiiin")
-}
-```
-```js
-console.log("Wof");
-
-var data = /* Dog */0;
-```
-
-</CodeTab>
-
-The compiler sees the variant, then
-
-1. conceptually turns them into `type animal = 0 | 1 | 2`
-2. compiles `switch` to a constant-time jump table (`O(1)`).
diff --git a/pages/docs/manual/v12.0.0/variant.mdx b/pages/docs/manual/variant.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/variant.mdx
rename to pages/docs/manual/variant.mdx
diff --git a/pages/docs/manual/v12.0.0/warning-numbers.mdx b/pages/docs/manual/warning-numbers.mdx
similarity index 100%
rename from pages/docs/manual/v12.0.0/warning-numbers.mdx
rename to pages/docs/manual/warning-numbers.mdx
diff --git a/public/static/favicon/favicon.ico b/public/favicon.ico
similarity index 100%
rename from public/static/favicon/favicon.ico
rename to public/favicon.ico
diff --git a/react-router.config.mjs b/react-router.config.mjs
new file mode 100644
index 000000000..ec4376195
--- /dev/null
+++ b/react-router.config.mjs
@@ -0,0 +1,14 @@
+import { init } from "react-router-mdx/server";
+const mdx = init({ paths: ["blogs"], aliases: ["blog"] });
+
+
+export default {
+    ssr: false,
+    async prerender({ getStaticPaths }) {
+        return [
+            ...(await getStaticPaths()),
+            ...(await mdx.paths())
+        ]
+    },
+
+}
\ No newline at end of file
diff --git a/rescript.json b/rescript.json
index 87790843e..82390fc8b 100644
--- a/rescript.json
+++ b/rescript.json
@@ -12,6 +12,10 @@
     "-open WebAPI.Global"
   ],
   "sources": [
+    {
+      "dir": "app",
+      "subdirs": true
+    },
     {
       "dir": "src",
       "subdirs": true
@@ -35,4 +39,4 @@
     "shims": [],
     "module": "es6"
   }
-}
+}
\ No newline at end of file
diff --git a/src/Playground.res b/src/Playground.res
index f78c520f1..b369e2998 100644
--- a/src/Playground.res
+++ b/src/Playground.res
@@ -1478,10 +1478,6 @@ let make = (~versions: array<string>) => {
     (),
   )
 
-  let overlayState = React.useState(() => false)
-
-  let windowWidth = CodeMirror.useWindowWidth()
-
   let (keyMap, setKeyMap) = React.useState(() => {
     Dom.Storage2.localStorage
     ->Dom.Storage2.getItem("vimMode")
diff --git a/src/bindings/ReactRouter.res b/src/bindings/ReactRouter.res
new file mode 100644
index 000000000..948563234
--- /dev/null
+++ b/src/bindings/ReactRouter.res
@@ -0,0 +1,4 @@
+module Outlet = {
+    @module("react-router") @react.component
+    external make: unit => React.element = "Outlet"
+}
diff --git a/src/entry.browser.jsx b/src/entry.browser.jsx
new file mode 100644
index 000000000..8f455c893
--- /dev/null
+++ b/src/entry.browser.jsx
@@ -0,0 +1,49 @@
+import {
+    createFromReadableStream,
+    createTemporaryReferenceSet,
+    encodeReply,
+    setServerCallback,
+} from "@vitejs/plugin-rsc/browser";
+import { startTransition, StrictMode } from "react";
+import { hydrateRoot } from "react-dom/client";
+import {
+    unstable_createCallServer as createCallServer,
+    unstable_getRSCStream as getRSCStream,
+    unstable_RSCHydratedRouter as RSCHydratedRouter,
+} from "react-router";
+
+// Create and set the callServer function to support post-hydration server actions.
+setServerCallback(
+  createCallServer({
+    createFromReadableStream,
+    createTemporaryReferenceSet,
+    encodeReply,
+  }),
+);
+
+// Get and decode the initial server payload.
+createFromReadableStream(
+  getRSCStream(),
+).then((payload) => {
+  startTransition(async () => {
+    const formState =
+      payload.type === "render"
+        ? await payload.formState
+        : undefined;
+
+    hydrateRoot(
+      document,
+      <StrictMode>
+        <RSCHydratedRouter
+          createFromReadableStream={
+            createFromReadableStream
+          }
+          payload={payload}
+        />
+      </StrictMode>,
+      {
+        formState,
+      },
+    );
+  });
+});
\ No newline at end of file
diff --git a/src/entry.rsc.jsx b/src/entry.rsc.jsx
new file mode 100644
index 000000000..8e9aca426
--- /dev/null
+++ b/src/entry.rsc.jsx
@@ -0,0 +1,48 @@
+import {
+  createTemporaryReferenceSet,
+  decodeAction,
+  decodeFormState,
+  decodeReply,
+  loadServerAction,
+  renderToReadableStream,
+} from "@vitejs/plugin-rsc/rsc";
+import { unstable_matchRSCServerRequest as matchRSCServerRequest } from "react-router";
+
+import { routes } from "../routes/config.mjs";
+
+function fetchServer(request) {
+  return matchRSCServerRequest({
+    // Provide the React Server touchpoints.
+    createTemporaryReferenceSet,
+    decodeAction,
+    decodeFormState,
+    decodeReply,
+    loadServerAction,
+    // The incoming request.
+    request,
+    // The app routes.
+    routes: routes(),
+    // Encode the match with the React Server implementation.
+    generateResponse(match) {
+      return new Response(
+        renderToReadableStream(match.payload),
+        {
+          status: match.statusCode,
+          headers: match.headers,
+        },
+      );
+    },
+  });
+}
+
+export default async function handler(request) {
+  console.log("SSR request:", request.url);
+  // Import the generateHTML function from the client environment
+  const ssr = await import.meta.viteRsc.loadModule("ssr", "index");
+
+
+
+  const html = ssr.generateHTML(request, fetchServer);
+
+  return html
+}
\ No newline at end of file
diff --git a/src/entry.ssr.jsx b/src/entry.ssr.jsx
new file mode 100644
index 000000000..d087edc68
--- /dev/null
+++ b/src/entry.ssr.jsx
@@ -0,0 +1,41 @@
+import { createFromReadableStream } from "@vitejs/plugin-rsc/ssr";
+import { renderToReadableStream as renderHTMLToReadableStream } from "react-dom/server.edge";
+import {
+    unstable_routeRSCServerRequest as routeRSCServerRequest,
+    unstable_RSCStaticRouter as RSCStaticRouter,
+} from "react-router";
+
+export async function generateHTML(
+  request,
+  fetchServer,
+) {
+  return await routeRSCServerRequest({
+    // The incoming request.
+    request,
+    // How to call the React Server.
+    fetchServer,
+    // Provide the React Server touchpoints.
+    createFromReadableStream,
+    // Render the router to HTML.
+    async renderHTML(getPayload) {
+      const payload = await getPayload();
+      const formState =
+        payload.type === "render"
+          ? await payload.formState
+          : undefined;
+
+      const bootstrapScriptContent =
+        await import.meta.viteRsc.loadBootstrapScriptContent(
+          "index",
+        );
+
+      return await renderHTMLToReadableStream(
+        <RSCStaticRouter getPayload={getPayload} />,
+        {
+          bootstrapScriptContent,
+          formState,
+        },
+      );
+    },
+  });
+}
\ No newline at end of file
diff --git a/vite.config.mjs b/vite.config.mjs
new file mode 100644
index 000000000..a3e2f6d1a
--- /dev/null
+++ b/vite.config.mjs
@@ -0,0 +1,10 @@
+import { reactRouter } from "@react-router/dev/vite";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  plugins: [
+    reactRouter({
+      ssr: true
+    })
+  ],
+});
\ No newline at end of file
