diff --git a/redraw/gleam.toml b/redraw/gleam.toml
index a06d63c..3d430cc 100644
--- a/redraw/gleam.toml
+++ b/redraw/gleam.toml
@@ -1,6 +1,6 @@
 name = "redraw"
-version = "1.0.0"
 target = "javascript"
+version = "1.0.0"
 
 # Fill out these fields if you intend to generate HTML documentation or publish
 # your project to the Hex package manager.
@@ -8,15 +8,15 @@ target = "javascript"
 description = "React bindings for Gleam! Supports everything modern React provides, with full Gleam Type-Checking system!"
 internal_modules = ["redraw/internals", "redraw/internals/*"]
 licences = ["MIT"]
-repository = { type = "github", user = "ghivert", repo = "redraw" }
-links = [{ title = "Sponsor", href = "https://github.com/sponsors/ghivert" }]
+links = [{title = "Sponsor", href = "https://github.com/sponsors/ghivert"}]
+repository = {type = "github", user = "ghivert", repo = "redraw"}
 
 # For a full reference of all the available options, you can have a look at
 # https://gleam.run/writing-gleam/gleam-toml/.
 
 [dependencies]
-gleam_stdlib = ">= 0.34.0 and < 2.0.0"
 gleam_javascript = ">= 0.11.0 and < 1.0.0"
+gleam_stdlib = ">= 0.34.0 and < 2.0.0"
 
 [dev-dependencies]
 gleeunit = ">= 1.0.0 and < 2.0.0"
diff --git a/redraw/src/redraw.gleam b/redraw/src/redraw.gleam
index c3861b2..853cbde 100644
--- a/redraw/src/redraw.gleam
+++ b/redraw/src/redraw.gleam
@@ -101,7 +101,8 @@ pub fn to_component_(
 }
 
 /// Create a Redraw component with children with forwarded ref. Take a look at
-/// [redraw.dev documentation to get more info.](https://fr.redraw.dev/reference/redraw/forwardRef)
+///
+/// [Documentation](https://fr.react.dev/reference/react/forwardRef)
 pub fn forward_ref(
   name name: String,
   render render: fn(props, Ref(ref), List(Component)) -> Component,
@@ -112,7 +113,8 @@ pub fn forward_ref(
 }
 
 /// Create a Redraw component without children with forwarded ref. Take a look at
-/// [redraw.dev documentation to get more info.](https://redraw.dev/reference/redraw/forwardRef)
+///
+/// [Documentation](https://react.dev/reference/react/forwardRef)
 pub fn forward_ref_(
   name name: String,
   render render: fn(props, Ref(ref)) -> Component,
@@ -123,29 +125,36 @@ pub fn forward_ref_(
 }
 
 /// Memoizes a Redraw component with children.
+///
+/// [Documentation](https://react.dev/reference/react/memo)
 @external(javascript, "react", "memo")
 pub fn memo(
   component: fn(props, List(Component)) -> Component,
 ) -> fn(props, List(Component)) -> Component
 
 /// Memoizes a Redraw component without children.
+///
+/// [Documentation](https://react.dev/reference/react/memo)
 @external(javascript, "react", "memo")
 pub fn memo_(component: fn(props) -> Component) -> fn(props) -> Component
 
 // Components
 
 /// Strict Mode should be enabled during development.
-/// [Documentation](https://redraw.dev/reference/redraw/StrictMode)
+///
+/// [Documentation](https://react.dev/reference/react/StrictMode)
 @external(javascript, "./redraw.ffi.mjs", "strictMode")
 pub fn strict_mode(children: List(Component)) -> Component
 
 /// Fragment allow to group children, without creating a node in the DOM.
-/// [Documentation](https://redraw.dev/reference/redraw/Fragment)
+///
+/// [Documentation](https://react.dev/reference/react/Fragment)
 @external(javascript, "./redraw.ffi.mjs", "fragment")
 pub fn fragment(children: List(Component)) -> Component
 
 /// Profile allows to measure code performance for a component tree.
-/// [Documentation](https://redraw.dev/reference/redraw/Profiler)
+///
+/// [Documentation](https://react.dev/reference/react/Profiler)
 @external(javascript, "./redraw.ffi.mjs", "strictMode")
 pub fn profiler(children: List(Component)) -> Component
 
@@ -155,7 +164,8 @@ pub type Suspense {
 
 /// Suspense allow to display a fallback content while waiting for children to
 /// finish loading.
-/// [Documentation](https://fr.redraw.dev/reference/redraw/Suspense)
+///
+/// [Documentation](https://fr.react.dev/reference/react/Suspense)
 @external(javascript, "./redraw.ffi.mjs", "fragment")
 pub fn suspense(props: Suspense, children: List(Component)) -> Component
 
@@ -163,57 +173,67 @@ pub fn suspense(props: Suspense, children: List(Component)) -> Component
 
 /// Let you cache a function definition between re-renders.
 /// `dependencies` should be a tuple.
-/// [Documentation](https://redraw.dev/reference/redraw/useCallback)
+///
+/// [Documentation](https://react.dev/reference/react/useCallback)
 @external(javascript, "react", "useCallback")
 pub fn use_callback(fun: function, dependencies: dependencies) -> a
 
 /// Let you add a label to a custom Hook in React DevTools.
-/// [Documentation](https://redraw.dev/reference/redraw/useDebugValue)
+///
+/// [Documentation](https://react.dev/reference/react/useDebugValue)
 @external(javascript, "react", "useDebugValue")
 pub fn use_debug_value(value: a) -> Nil
 
 /// Let you add a label to a custom Hook in React DevTools, but allow to format
 /// it before.
-/// [Documentation](https://redraw.dev/reference/redraw/useDebugValue)
+///
+/// [Documentation](https://react.dev/reference/react/useDebugValue)
 @external(javascript, "react", "useDebugValue")
 pub fn use_debug_value_(value: a, formatter: fn(a) -> String) -> Nil
 
 /// Let you defer updating a part of the UI.
-/// [Documentation](https://redraw.dev/reference/redraw/useDeferredValue)
+///
+/// [Documentation](https://react.dev/reference/react/useDeferredValue)
 @external(javascript, "react", "useDeferredValue")
 pub fn use_deferred_value(value: a) -> a
 
 /// Let you synchronize a component with an external system.
-/// [Documentation](https://redraw.dev/reference/redraw/useEffect)
+///
+/// [Documentation](https://react.dev/reference/react/useEffect)
 @external(javascript, "react", "useEffect")
 pub fn use_effect(value: fn() -> Nil, dependencies: a) -> Nil
 
 /// Version of useEffect that fires before the browser repaints the screen.
-/// [Documentation](https://redraw.dev/reference/redraw/useLayoutEffect)
+///
+/// [Documentation](https://react.dev/reference/react/useLayoutEffect)
 @external(javascript, "react", "useLayoutEffect")
 pub fn use_layout_effect(value: fn() -> Nil, dependencies: a) -> Nil
 
 /// Generate unique IDs that can be passed to accessibility attributes.
-/// [Documentation](https://redraw.dev/reference/redraw/useId)
+///
+/// [Documentation](https://react.dev/reference/react/useId)
 @external(javascript, "react", "useId")
 pub fn use_id() -> String
 
 /// Let you cache the result of a calculation between re-renders.
-/// [Documentation](https://redraw.dev/reference/redraw/useMemo)
+///
+/// [Documentation](https://react.dev/reference/react/useMemo)
 @external(javascript, "react", "useMemo")
 pub fn use_memo(calculate_value: fn() -> a, dependencies: b) -> a
 
-/// Let you add a [reducer](https://redraw.dev/learn/extracting-state-logic-into-a-reducer) to your component.
-/// [Documentation](https://redraw.dev/reference/redraw/useReducer)
+/// Let you add a [reducer](https://react.dev/learn/extracting-state-logic-into-a-reducer) to your component.
+///
+/// [Documentation](https://react.dev/reference/react/useReducer)
 @external(javascript, "react", "useReducer")
 pub fn use_reducer(
   reducer: fn(state, action) -> state,
   initial_state: state,
 ) -> #(state, fn(action) -> Nil)
 
-/// Let you add a [reducer](https://redraw.dev/learn/extracting-state-logic-into-a-reducer) to your component.
+/// Let you add a [reducer](https://react.dev/learn/extracting-state-logic-into-a-reducer) to your component.
 /// Allow to initialize the store in a custom way.
-/// [Documentation](https://redraw.dev/reference/redraw/useReducer)
+///
+/// [Documentation](https://react.dev/reference/react/useReducer)
 @external(javascript, "react", "useReducer")
 pub fn use_reducer_(
   reducer: fn(state, action) -> state,
@@ -221,32 +241,37 @@ pub fn use_reducer_(
   init: fn(initializer) -> state,
 ) -> #(state, fn(action) -> Nil)
 
-/// Let you add a [state variable](https://redraw.dev/learn/state-a-components-memory) to your component.
-/// [Documentation](https://redraw.dev/reference/redraw/useState)
+/// Let you add a [state variable](https://react.dev/learn/state-a-components-memory) to your component.
+///
+/// [Documentation](https://react.dev/reference/react/useState)
 @external(javascript, "react", "useState")
 pub fn use_state(initial_value: a) -> #(a, fn(a) -> Nil)
 
-/// Let you add a [state variable](https://redraw.dev/learn/state-a-components-memory) to your component.
+/// Let you add a [state variable](https://react.dev/learn/state-a-components-memory) to your component.
 /// Give an `updater` function instead of a state setter.
-/// [Documentation](https://redraw.dev/reference/redraw/useState)
+///
+/// [Documentation](https://react.dev/reference/react/useState)
 @external(javascript, "react", "useState")
 pub fn use_state_(initial_value: a) -> #(a, fn(fn(a) -> a) -> Nil)
 
-/// Let you add a [state variable](https://redraw.dev/learn/state-a-components-memory) to your component.
+/// Let you add a [state variable](https://react.dev/learn/state-a-components-memory) to your component.
 /// Allow to create the initial value in a lazy way.
-/// [Documentation](https://redraw.dev/reference/redraw/useState)
+///
+/// [Documentation](https://react.dev/reference/react/useState)
 @external(javascript, "react", "useState")
 pub fn use_lazy_state(initial_value: fn() -> a) -> #(a, fn(a) -> Nil)
 
-/// Let you add a [state variable](https://redraw.dev/learn/state-a-components-memory) to your component.
+/// Let you add a [state variable](https://react.dev/learn/state-a-components-memory) to your component.
 /// Allow to create the initial value in a lazy way.
 /// Give an `updater` function instead of a state setter.
-/// [Documentation](https://redraw.dev/reference/redraw/useState)
+///
+/// [Documentation](https://react.dev/reference/react/useState)
 @external(javascript, "react", "useState")
 pub fn use_lazy_state_(initial_value: fn() -> a) -> #(a, fn(fn(a) -> a) -> Nil)
 
 /// Let you update the state without blocking the UI.
-/// [Documentation](https://redraw.dev/reference/redraw/useTransition)
+///
+/// [Documentation](https://react.dev/reference/react/useTransition)
 @external(javascript, "react", "useTransition")
 pub fn use_transition() -> #(Bool, fn() -> Nil)
 
@@ -255,6 +280,8 @@ pub fn use_transition() -> #(Bool, fn() -> Nil)
 /// A Ref is a mutable data stored in React, persisted across renders.
 /// They allow to keep track of a DOM node, a component data, or to store a
 /// mutable variable in the component, outside of every component lifecycle.
+///
+/// [Documentation](https://react.dev/learn/referencing-values-with-refs)
 pub type Ref(a)
 
 /// Set the current value of a ref, overriding its existing content.
@@ -270,7 +297,8 @@ pub fn get_current(from ref: Ref(a)) -> a
 /// and can be passed to `attribute.ref` or `use_imperative_handle`.
 /// You probably don't want the ref value to be anything than `Option(a)`, unless
 /// you have really strong reasons.
-/// [Documentation](https://redraw.dev/reference/redraw/useRef)
+///
+/// [Documentation](https://react.dev/reference/react/useRef)
 pub fn use_ref() {
   use_ref_(option.None)
 }
@@ -280,22 +308,25 @@ pub fn use_ref() {
 /// component. Use `use_ref_` when you want to keep track of a data, like if
 /// you're doing some side-effects, in conjuction with `get_current` and
 /// `set_current`.
-/// [Documentation](https://redraw.dev/reference/redraw/useRef)
+///
+/// [Documentation](https://react.dev/reference/react/useRef)
 @external(javascript, "react", "useRef")
 pub fn use_ref_(initial_value: a) -> Ref(a)
 
-/// Let you customize the handle exposed as a [ref](https://redraw.dev/learn/manipulating-the-dom-with-refs).
+/// Let you customize the handle exposed as a [ref](https://react.dev/learn/manipulating-the-dom-with-refs).
 /// Use `use_imperative_handle` when you want to customize the data stored in
 /// a ref. It's mostly used in conjuction with `forward_ref`.
-/// [Documentation](https://redraw.dev/reference/redraw/useImperativeHandle)
+///
+/// [Documentation](https://react.dev/reference/react/useImperativeHandle)
 pub fn use_imperative_handle(ref, handler, dependencies) {
   use_imperative_handle_(ref, fn() { option.Some(handler()) }, dependencies)
 }
 
-/// Let you customize the handle exposed as a [ref](https://redraw.dev/learn/manipulating-the-dom-with-refs).
+/// Let you customize the handle exposed as a [ref](https://react.dev/learn/manipulating-the-dom-with-refs).
 /// Use `use_imperative_handle` by default, unless you really know what you're
 /// doing.
-/// [Documentation](https://redraw.dev/reference/redraw/useImperativeHandle)
+///
+/// [Documentation](https://react.dev/reference/react/useImperativeHandle)
 @external(javascript, "react", "useImperativeHandle")
 pub fn use_imperative_handle_(
   ref: Ref(a),
@@ -306,22 +337,26 @@ pub fn use_imperative_handle_(
 // Contexts
 
 /// Pass data without props drilling.
-/// [Documentation](https://redraw.dev/learn/passing-data-deeply-with-context)
+///
+/// [Documentation](https://react.dev/learn/passing-data-deeply-with-context)
 pub type Context(a)
 
-/// Let you read and subscribe to [context](https://redraw.dev/learn/passing-data-deeply-with-context) from your component.
-/// [Documentation](https://redraw.dev/reference/redraw/useContext)
+/// Let you read and subscribe to [context](https://react.dev/learn/passing-data-deeply-with-context) from your component.
+///
+/// [Documentation](https://react.dev/reference/react/useContext)
 @external(javascript, "react", "useContext")
 pub fn use_context(context: Context(a)) -> a
 
-/// Let you create a [context](https://redraw.dev/learn/passing-data-deeply-with-context) that components can provide or read.
-/// [Documentation](https://redraw.dev/reference/redraw/createContext)
+/// Let you create a [context](https://react.dev/learn/passing-data-deeply-with-context) that components can provide or read.
+///
+/// [Documentation](https://react.dev/reference/react/createContext)
 @deprecated("Use redraw/create_context_ instead. redraw/create_context will be removed in 2.0.0. Unusable right now, due to how React handles Context.")
 @external(javascript, "react", "createContext")
 pub fn create_context(default_value default_value: Option(a)) -> Context(a)
 
 /// Wrap your components into a context provider to specify the value of this context for all components inside.
-/// [Documentation](https://redraw.dev/reference/redraw/createContext#provider)
+///
+/// [Documentation](https://react.dev/reference/react/createContext#provider)
 @external(javascript, "./context.ffi.mjs", "contextProvider")
 pub fn provider(
   context context: Context(a),
@@ -329,7 +364,7 @@ pub fn provider(
   children children: List(Component),
 ) -> Component
 
-/// Create a [context](https://redraw.dev/learn/passing-data-deeply-with-context)
+/// Create a [context](https://react.dev/learn/passing-data-deeply-with-context)
 /// that components can provide or read.
 /// Each context is referenced by its name, a little bit like actors in OTP
 /// (if you're familiar with Erlang). Because Gleam cannot execute code outside of
@@ -376,7 +411,8 @@ pub fn provider(
 /// Be careful, `create_context_` fails if the Context is already defined.
 /// Choose a full qualified name, hard to overlap with inattention. If
 /// you want to get a Context in an idempotent way, take a look at [`context()`](#context).
-/// [Documentation](https://redraw.dev/reference/redraw/createContext)
+///
+/// [Documentation](https://react.dev/reference/react/createContext)
 @external(javascript, "./context.ffi.mjs", "createContext")
 pub fn create_context_(
   name: String,
@@ -475,12 +511,14 @@ pub fn context(name: String, default_value: fn() -> a) -> Context(a) {
 // API
 //
 /// Test helper to apply pending React updates before making assertions.
-/// [Documentation](https://redraw.dev/reference/redraw/act)
+///
+/// [Documentation](https://react.dev/reference/react/act)
 @external(javascript, "react", "act")
 pub fn act(act_fn: fn() -> Promise(Nil)) -> Promise(Nil)
 
 /// Let you update the state without blocking the UI.
-/// [Documentation](https://redraw.dev/reference/redraw/startTransition)
+///
+/// [Documentation](https://react.dev/reference/react/startTransition)
 @external(javascript, "react", "startTransition")
 pub fn start_transition(scope scope: fn() -> Nil) -> Nil
 
diff --git a/redraw/src/redraw/attribute.gleam b/redraw/src/redraw/attribute.gleam
index 72b8061..8966a11 100644
--- a/redraw/src/redraw/attribute.gleam
+++ b/redraw/src/redraw/attribute.gleam
@@ -30,10 +30,23 @@ pub fn alt(value: String) {
 
 pub type InnerHTML
 
+/// The `inner_html` data should be created as close to where the HTML is
+/// generated as possible. This ensures that all raw HTML being used in your
+/// code is explicitly marked as such, and that only variables that you expect
+/// to contain HTML are passed to `dangerously_set_inner_html`. It is not
+/// recommended to create the object inline like
+/// `html.div([attribute.dangerously_set_inner_html(attribute.inner_html(markup))], [])`
+///
+/// [Documentation](https://react.dev/reference/react-dom/components/common#dangerously-setting-the-inner-html)
 @external(javascript, "../redraw.ffi.mjs", "innerHTML")
 pub fn inner_html(html: String) -> InnerHTML
 
-/// Overrides the innerHTML property of the DOM node and displays the passed HTML inside. This should be used with extreme caution! If the HTML inside isn’t trusted (for example, if it’s based on user data), you risk introducing an XSS vulnerability.
+/// Overrides the innerHTML property of the DOM node and displays the passed
+/// HTML inside. This should be used with extreme caution! If the HTML inside
+/// isn’t trusted (for example, if it’s based on user data), you risk
+/// introducing an XSS vulnerability.
+///
+/// [Documentation](https://react.dev/reference/react-dom/components/common#dangerously-setting-the-inner-html)
 pub fn dangerously_set_inner_html(inner_html: InnerHTML) {
   attribute.attribute("dangerouslySetInnerHTML", inner_html)
 }
@@ -50,7 +63,9 @@ pub fn ref(ref: redraw.Ref(option.Option(a))) {
   })
 }
 
-/// A ref callback function. The callback will be provided with the DOM element for this node. Use this function to get control on the ref provided by the DOM node or the component.
+/// A ref callback function. The callback will be provided with the DOM element
+/// for this node. Use this function to get control on the ref provided by the
+/// DOM node or the component.
 pub fn ref_(ref: fn(a) -> Nil) {
   attribute.attribute("ref", ref)
 }
@@ -88,12 +103,18 @@ pub fn class_name(value: String) {
   attribute.attribute("className", value)
 }
 
-/// If true, the browser lets the user edit the rendered element directly. This is used to implement rich text input libraries like Lexical. React warns if you try to pass React children to an element with contentEditable={true} because React will not be able to update its content after user edits.
+/// If true, the browser lets the user edit the rendered element directly.
+/// This is used to implement rich text input libraries like Lexical. React
+/// warns if you try to pass React children to an element with
+/// `content_editable(True)` because React will not be able to update its content
+/// after user edits.
 pub fn content_editable(value: Bool) {
   attribute.attribute("contentEditable", value)
 }
 
-/// Data attributes let you attach some string data to the element, for example data-fruit="banana". In React, they are not commonly used because you would usually read data from props or state instead.
+/// Data attributes let you attach some string data to the element, for example
+/// `data("fruit", "banana")`. In React, they are not commonly used because you
+/// would usually read data from props or state instead.
 pub fn data(key: String, value: String) {
   attribute.attribute("data-" <> key, value)
 }
@@ -122,7 +143,8 @@ pub fn enter_key_hint(value: String) {
   attribute.attribute("enterKeyHint", value)
 }
 
-/// For <label> and <output>, lets you associate the label with some control. Same as for HTML attribute. React uses the standard DOM property names (htmlFor) instead of HTML attribute names.
+/// For <label> and <output>, lets you associate the label with some control.
+/// Same as for HTML attribute.
 pub fn for(value: String) {
   attribute.attribute("htmlFor", value)
 }
@@ -137,7 +159,9 @@ pub fn hidden(value: Bool) {
   attribute.attribute("hidden", value)
 }
 
-/// Specifies a unique identifier for this element, which can be used to find it later or connect it with other elements. Generate it with useId to avoid clashes between multiple instances of the same component.
+/// Specifies a unique identifier for this element, which can be used to find
+/// it later or connect it with other elements. Generate it with useId to avoid
+/// clashes between multiple instances of the same component.
 pub fn id(value: String) {
   attribute.attribute("id", value)
 }
diff --git a/redraw/src/redraw/error.gleam b/redraw/src/redraw/error.gleam
index 647f797..dcf979a 100644
--- a/redraw/src/redraw/error.gleam
+++ b/redraw/src/redraw/error.gleam
@@ -1,4 +1,9 @@
+/// Main error type. Currently, only used in conjuction with `Context` functions.
 pub type Error {
+  /// Error thrown in `create_context_`.
+  /// Context with the corresponding `name` already exists.
   ExistingContext(name: String)
+  /// Error thrown in `get_context`.
+  /// Context with the corresponding `name` does not exists.
   UnknownContext(name: String)
 }
diff --git a/redraw/src/redraw/event.gleam b/redraw/src/redraw/event.gleam
index 0e9a234..55caff1 100644
--- a/redraw/src/redraw/event.gleam
+++ b/redraw/src/redraw/event.gleam
@@ -1,48 +1,67 @@
 import gleam/dynamic
 
+/// Synthetic Event sent by React.
+/// It conforms to the same standard as the underlying DOM events, but fixes some browser inconsistencies.
+///
+/// [Documentation](https://react.dev/reference/react-dom/components/common#react-event-object)
 pub type Event
 
+/// Returns whether the event bubbles through the DOM.
 @external(javascript, "../events.ffi.mjs", "bubbles")
 pub fn bubbles(event: Event) -> Bool
 
+/// Returns whether the event can be canceled.
 @external(javascript, "../events.ffi.mjs", "cancelable")
 pub fn cancelable(event: Event) -> Bool
 
+/// Returns the node to which the current handler is attached in the React tree.
 @external(javascript, "../events.ffi.mjs", "currentTarget")
 pub fn current_target(event: Event) -> dynamic.Dynamic
 
+/// Returns whether `prevent_default` was called.
 @external(javascript, "../events.ffi.mjs", "defaultPrevented")
 pub fn default_prevented(event: Event) -> Bool
 
+/// Returns which phase the event is currently in.
 @external(javascript, "../events.ffi.mjs", "eventPhase")
 pub fn event_phase(event: Event) -> Int
 
+/// Returns whether the event was initiated by user.
 @external(javascript, "../events.ffi.mjs", "isTrusted")
 pub fn is_trusted(event: Event) -> Bool
 
+/// Returns the node on which the event has occurred (which could be a distant child).
 @external(javascript, "../events.ffi.mjs", "target")
 pub fn target(event: Event) -> dynamic.Dynamic
 
+/// Returns the time when the event occurred.
 @external(javascript, "../events.ffi.mjs", "timeStamp")
 pub fn time_stamp(event: Event) -> Int
 
+/// The original browser event object.
 @external(javascript, "../events.ffi.mjs", "nativeEvent")
 pub fn native_event(event: Event) -> dynamic.Dynamic
 
+/// Prevents the default browser action for the event.
 @external(javascript, "../events.ffi.mjs", "preventDefault")
 pub fn prevent_default(event: Event) -> Event
 
+/// Stops the event propagation through the React tree.
 @external(javascript, "../events.ffi.mjs", "stopPropagation")
 pub fn stop_propagation(event: Event) -> Event
 
-@external(javascript, "../events.ffi.mjs", "persist")
-pub fn persist(event: Event) -> Event
-
+/// Returns a boolean value indicating whether `prevent_default` was called.
 @external(javascript, "../events.ffi.mjs", "isDefaultPrevented")
 pub fn is_default_prevented(event: Event) -> Bool
 
+/// Returns a boolean value indicating whether `stop_propagation` was called.
 @external(javascript, "../events.ffi.mjs", "isPropagationStopped")
 pub fn is_propagation_stopped(event: Event) -> Bool
 
+/// Not used with React DOM. With React Native, call this to read event’s properties after the event.
+@external(javascript, "../events.ffi.mjs", "persist")
+pub fn persist(event: Event) -> Event
+
+/// Not used with React DOM. With React Native, returns whether persist has been called.
 @external(javascript, "../events.ffi.mjs", "isPersistent")
 pub fn is_persistent(event: Event) -> Bool
diff --git a/redraw_dom/gleam.toml b/redraw_dom/gleam.toml
index 0e02ac6..862b3fb 100644
--- a/redraw_dom/gleam.toml
+++ b/redraw_dom/gleam.toml
@@ -1,14 +1,14 @@
 name = "redraw_dom"
-version = "1.0.0"
 target = "javascript"
+version = "1.0.0"
 
 # Fill out these fields if you intend to generate HTML documentation or publish
 # your project to the Hex package manager.
 
 description = "Redraw DOM renderer. Take a look at Redraw to use it."
 licences = ["MIT"]
-repository = { type = "github", user = "ghivert", repo = "redraw" }
-links = [{ title = "Sponsor", href = "https://github.com/sponsors/ghivert" }]
+links = [{title = "Sponsor", href = "https://github.com/sponsors/ghivert"}]
+repository = {type = "github", user = "ghivert", repo = "redraw/redraw_dom"}
 
 # For a full reference of all the available options, you can have a look at
 # https://gleam.run/writing-gleam/gleam-toml/.
diff --git a/redraw_dom/src/redraw_dom/client.gleam b/redraw_dom/src/redraw_dom/client.gleam
index dae84cc..442441e 100644
--- a/redraw_dom/src/redraw_dom/client.gleam
+++ b/redraw_dom/src/redraw_dom/client.gleam
@@ -1,26 +1,32 @@
 import redraw.{type Component}
 
 /// Root to display React DOM.
-/// [Documentation](https://redraw.dev/reference/react-dom/client/createRoot#createroot)
+///
+/// [Documentation](https://react.dev/reference/react-dom/client/createRoot#createroot)
 pub type Root
 
 /// Let you create a root to display React components inside a browser DOM node.
-/// [Documentation](https://redraw.dev/reference/react-dom/client/createRoot)
+///
+/// [Documentation](https://react.dev/reference/react-dom/client/createRoot)
 @external(javascript, "../redraw_dom.ffi.mjs", "createRoot")
 pub fn create_root(root: String) -> Root
 
 /// Let you display React components inside a browser DOM node whose HTML content
 /// was previously generated by `react-dom/server`.
+///
+/// [Documentation](https://react.dev/reference/react-dom/client/hydrateRoot)
 @external(javascript, "../redraw_dom.ffi.mjs", "hydrateRoot")
 pub fn hydrate_root(root: String, node: Component) -> Root
 
 /// Call `render(root)` to display a piece of JSX (“React node”) into the React
 /// root’s browser DOM node.
-/// [Documentation](https://redraw.dev/reference/react-dom/client/createRoot#root-render)
+///
+/// [Documentation](https://react.dev/reference/react-dom/client/createRoot#root-render)
 @external(javascript, "../redraw_dom.ffi.mjs", "render")
 pub fn render(root: Root, child: Component) -> Nil
 
 /// Let you render some children into a different part of the DOM.
-/// [Documentation](https://redraw.dev/reference/react-dom/createPortal)
+///
+/// [Documentation](https://react.dev/reference/react-dom/createPortal)
 @external(javascript, "../redraw_dom.ffi.mjs", "createPortal")
 pub fn create_portal(children: Component, root: String) -> Component