diff --git a/redraw/CHANGELOG.md b/redraw/CHANGELOG.md
index 4d6f0a9..41047a0 100644
--- a/redraw/CHANGELOG.md
+++ b/redraw/CHANGELOG.md
@@ -1,6 +1,8 @@
-## Unreleased
+## v1.1.1 - 2024-12-23
 
+- Add documentation for every functions.
 - Bump minimal required versions.
+- Add `offset_x`, `offset_y`, `altitude_angle` & `azimuth_angle`.
 
 ## v1.1.0 - 2024-21-08
 
diff --git a/redraw/gleam.toml b/redraw/gleam.toml
index 42ad537..33a2295 100644
--- a/redraw/gleam.toml
+++ b/redraw/gleam.toml
@@ -1,6 +1,6 @@
 name = "redraw"
 target = "javascript"
-version = "1.1.0"
+version = "1.1.1"
 
 # Fill out these fields if you intend to generate HTML documentation or publish
 # your project to the Hex package manager.
diff --git a/redraw/src/events.ffi.mjs b/redraw/src/events.ffi.mjs
index 1b36214..6ad84b9 100644
--- a/redraw/src/events.ffi.mjs
+++ b/redraw/src/events.ffi.mjs
@@ -102,6 +102,14 @@ export function clientY(event) {
   return event.clientY
 }
 
+export function offsetX(event) {
+  return event.offsetX
+}
+
+export function offsetY(event) {
+  return event.offsetY
+}
+
 export function metaKey(event) {
   return event.metaKey
 }
@@ -170,6 +178,14 @@ export function isPrimary(event) {
   return event.isPrimary
 }
 
+export function altitudeAngle(event) {
+  return event.altitudeAngle
+}
+
+export function azimuthAngle(event) {
+  return event.azimuthAngle
+}
+
 export function pointerId(event) {
   return event.pointerId
 }
diff --git a/redraw/src/redraw.gleam b/redraw/src/redraw.gleam
index c25522f..63ea6d7 100644
--- a/redraw/src/redraw.gleam
+++ b/redraw/src/redraw.gleam
@@ -7,7 +7,7 @@ import redraw/internals/coerce.{coerce}
 
 // Component creation
 
-/// Default Node in redraw. Use `component`-family functions to create components.
+/// Default Node in Redraw. Use `component`-family functions to create components.
 /// Forwarded ref can be constructed using `forward_ref`-family functions, while
 /// external components can be used with `to_component`-family functions.
 pub type Component
@@ -25,7 +25,10 @@ pub fn component(
 
 /// Create a Redraw component, with a `name`, and a `render` function. This
 /// component does not accept children.
-pub fn component_(name name: String, render render: fn(props) -> Component) {
+pub fn component_(
+  name name: String,
+  render render: fn(props) -> Component,
+) -> fn(props) -> Component {
   render
   |> set_function_name(name)
   |> add_proxy
@@ -33,7 +36,10 @@ pub fn component_(name name: String, render render: fn(props) -> Component) {
 
 /// Create a Redraw component, with a `name` and a `render` function. This
 /// component does not accept children nor props.
-pub fn component__(name name: String, render render: fn() -> Component) {
+pub fn component__(
+  name name: String,
+  render render: fn() -> Component,
+) -> fn() -> Component {
   render
   |> set_function_name(name)
   |> add_empty_proxy
@@ -49,9 +55,6 @@ fn convert_props(gleam_props: gleam_props) -> props
 /// ```gleam
 /// import redraw
 ///
-/// @external(javascript, "my_library", "MyComponent")
-/// fn do_my_component(props: props) -> redraw.Component
-///
 /// pub type MyComponentProps {
 ///   MyComponentProps(
 ///     first_prop: Bool,
@@ -59,14 +62,17 @@ fn convert_props(gleam_props: gleam_props) -> props
 ///   )
 /// }
 ///
-/// pub fn my_component() -> fn(MyComponentProps) -> redraw.Component {
+/// @external(javascript, "my_library", "MyComponent")
+/// fn do_my_component(props: MyComponentProps) -> redraw.Component
+///
+/// pub fn my_component() -> fn(MyComponentProps, List(Component)) -> redraw.Component {
 ///   redraw.to_component("MyComponent", do_my_component)
 /// }
 /// ```
 pub fn to_component(
   name name: String,
   component render: fn(props) -> Component,
-) -> fn(gleam_props, List(Component)) -> Component {
+) -> fn(props, List(Component)) -> Component {
   fn(props, children) { jsx(render, convert_props(props), children) }
   |> set_function_name(name)
 }
@@ -78,9 +84,6 @@ pub fn to_component(
 /// ```gleam
 /// import redraw
 ///
-/// @external(javascript, "my_library", "MyComponent")
-/// fn do_my_component(props: props) -> redraw.Component
-///
 /// pub type MyComponentProps {
 ///   MyComponentProps(
 ///     first_prop: Bool,
@@ -88,6 +91,9 @@ pub fn to_component(
 ///   )
 /// }
 ///
+/// @external(javascript, "my_library", "MyComponent")
+/// fn do_my_component(props: MyComponentProps) -> redraw.Component
+///
 /// pub fn my_component() -> fn(MyComponentProps) -> redraw.Component {
 ///   redraw.to_component_("MyComponent", do_my_component)
 /// }
@@ -95,65 +101,58 @@ pub fn to_component(
 pub fn to_component_(
   name name: String,
   component render: fn(props) -> Component,
-) -> fn(gleam_props) -> Component {
+) -> fn(props) -> Component {
   fn(props) { jsx(render, convert_props(props), Nil) }
   |> set_function_name(name)
 }
 
-/// Create a Redraw component with children with forwarded ref. Take a look at
-///
+/// Create a Redraw component with children with forwarded ref. \
 /// [Documentation](https://fr.react.dev/reference/react/forwardRef)
 pub fn forward_ref(
   name name: String,
   render render: fn(props, Ref(ref), List(Component)) -> Component,
-) {
+) -> fn(props, Ref(ref), List(Component)) -> Component {
   render
   |> set_function_name(name)
   |> add_children_forward_ref
 }
 
-/// Create a Redraw component without children with forwarded ref. Take a look at
-///
+/// Create a Redraw component without children with forwarded ref. \
 /// [Documentation](https://react.dev/reference/react/forwardRef)
 pub fn forward_ref_(
   name name: String,
   render render: fn(props, Ref(ref)) -> Component,
-) {
+) -> fn(props, Ref(ref)) -> Component {
   render
   |> set_function_name(name)
   |> add_forward_ref
 }
 
-/// Memoizes a Redraw component with children.
-///
+/// 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.
-///
+/// 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.
-///
+/// Strict Mode should be enabled during development. \
 /// [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.
-///
+/// Fragment allow to group children, without creating a node in the DOM. \
 /// [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.
-///
+/// Profile allows to measure code performance for a component tree. \
 /// [Documentation](https://react.dev/reference/react/Profiler)
 @external(javascript, "./redraw.ffi.mjs", "strictMode")
 pub fn profiler(children: List(Component)) -> Component
@@ -163,8 +162,7 @@ pub type Suspense {
 }
 
 /// Suspense allow to display a fallback content while waiting for children to
-/// finish loading.
-///
+/// finish loading. \
 /// [Documentation](https://fr.react.dev/reference/react/Suspense)
 @external(javascript, "./redraw.ffi.mjs", "fragment")
 pub fn suspense(props: Suspense, children: List(Component)) -> Component
@@ -172,64 +170,54 @@ pub fn suspense(props: Suspense, children: List(Component)) -> Component
 // Hooks
 
 /// Let you cache a function definition between re-renders.
-/// `dependencies` should be a tuple.
-///
+/// `dependencies` should be a tuple. \
 /// [Documentation](https://react.dev/reference/react/useCallback)
 @external(javascript, "react", "useCallback")
 pub fn use_callback(fun: function, dependencies: dependencies) -> function
 
-/// Let you add a label to a custom Hook in React DevTools.
-///
+/// Let you add a label to a custom Hook in React DevTools. \
 /// [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.
-///
+/// it before. \
 /// [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.
-///
+/// Let you defer updating a part of the UI. \
 /// [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.
-///
+/// Let you synchronize a component with an external system. \
 /// [Documentation](https://react.dev/reference/react/useEffect)
 @external(javascript, "react", "useEffect")
 pub fn use_effect(value: fn() -> Nil, dependencies: a) -> Nil
 
 /// Let you synchronize a component with an external system. Allow to return
-/// a cleanup function.
-///
+/// a cleanup function. \
 /// [Documentation](https://react.dev/reference/react/useEffect)
 @external(javascript, "react", "useEffect")
 pub fn use_effect_(value: fn() -> fn() -> Nil, dependencies: a) -> Nil
 
-/// Version of useEffect that fires before the browser repaints the screen.
-///
+/// Version of useEffect that fires before the browser repaints the screen. \
 /// [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.
-///
+/// Generate unique IDs that can be passed to accessibility attributes. \
 /// [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.
-///
+/// Let you cache the result of a calculation between re-renders. \
 /// [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://react.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. \
 /// [Documentation](https://react.dev/reference/react/useReducer)
 @external(javascript, "react", "useReducer")
 pub fn use_reducer(
@@ -238,8 +226,7 @@ pub fn use_reducer(
 ) -> #(state, fn(action) -> Nil)
 
 /// 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.
-///
+/// Allow to initialize the store in a custom way. \
 /// [Documentation](https://react.dev/reference/react/useReducer)
 @external(javascript, "react", "useReducer")
 pub fn use_reducer_(
@@ -248,36 +235,31 @@ pub fn use_reducer_(
   init: fn(initializer) -> state,
 ) -> #(state, fn(action) -> Nil)
 
-/// Let you add a [state variable](https://react.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. \
 /// [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://react.dev/learn/state-a-components-memory) to your component.
-/// Give an `updater` function instead of a state setter.
-///
+/// Give an `updater` function instead of a state setter. \
 /// [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://react.dev/learn/state-a-components-memory) to your component.
-/// Allow to create the initial value in a lazy way.
-///
+/// Allow to create the initial value in a lazy way. \
 /// [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://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.
-///
+/// Give an `updater` function instead of a state setter. \
 /// [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.
-///
+/// Let you update the state without blocking the UI. \
 /// [Documentation](https://react.dev/reference/react/useTransition)
 @external(javascript, "react", "useTransition")
 pub fn use_transition() -> #(Bool, fn() -> Nil)
@@ -286,8 +268,7 @@ 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.
-///
+/// mutable variable in the component, outside of every component lifecycle. \
 /// [Documentation](https://react.dev/learn/referencing-values-with-refs)
 pub type Ref(a)
 
@@ -303,10 +284,9 @@ pub fn get_current(from ref: Ref(a)) -> a
 /// Most used ref you'll want to create. They're automatically created to `None`,
 /// 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.
-///
+/// you have really strong reasons. \
 /// [Documentation](https://react.dev/reference/react/useRef)
-pub fn use_ref() {
+pub fn use_ref() -> Ref(Option(a)) {
   use_ref_(option.None)
 }
 
@@ -314,25 +294,26 @@ pub fn use_ref() {
 /// Use `use_ref` if you're trying to acquire a reference to a child or to a
 /// 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`.
-///
+/// `set_current`. \
 /// [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://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`.
-///
+/// a ref. It's mostly used in conjuction with `forward_ref`. \
 /// [Documentation](https://react.dev/reference/react/useImperativeHandle)
-pub fn use_imperative_handle(ref, handler, dependencies) {
+pub fn use_imperative_handle(
+  ref: Ref(Option(a)),
+  handler: fn() -> a,
+  dependencies: b,
+) -> Nil {
   use_imperative_handle_(ref, fn() { option.Some(handler()) }, dependencies)
 }
 
 /// 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.
-///
+/// doing. \
 /// [Documentation](https://react.dev/reference/react/useImperativeHandle)
 @external(javascript, "react", "useImperativeHandle")
 pub fn use_imperative_handle_(
@@ -343,26 +324,22 @@ pub fn use_imperative_handle_(
 
 // Contexts
 
-/// Pass data without props drilling.
-///
+/// Pass data without props drilling. \
 /// [Documentation](https://react.dev/learn/passing-data-deeply-with-context)
 pub type Context(a)
 
-/// Let you read and subscribe to [context](https://react.dev/learn/passing-data-deeply-with-context) from your component.
-///
+/// 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://react.dev/learn/passing-data-deeply-with-context) that components can provide or read.
-///
+/// 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.
-///
+/// Wrap your components into a context provider to specify the value of this context for all components inside. \
 /// [Documentation](https://react.dev/reference/react/createContext#provider)
 @external(javascript, "./context.ffi.mjs", "contextProvider")
 pub fn provider(
@@ -516,15 +493,13 @@ pub fn context(name: String, default_value: fn() -> a) -> Context(a) {
 }
 
 // API
-//
-/// Test helper to apply pending React updates before making assertions.
-///
+
+/// Test helper to apply pending React updates before making assertions. \
 /// [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.
-///
+/// Let you update the state without blocking the UI. \
 /// [Documentation](https://react.dev/reference/react/startTransition)
 @external(javascript, "react", "startTransition")
 pub fn start_transition(scope scope: fn() -> Nil) -> Nil
@@ -552,7 +527,7 @@ pub fn keyed(
 }
 
 // FFI
-// Those functions are used internal by Redraw, to setup things correctly.
+// Those functions are used internally by Redraw, to setup things correctly.
 // They should not be accessible from the outside world.
 
 @external(javascript, "./redraw.ffi.mjs", "jsx")
diff --git a/redraw/src/redraw/attribute.gleam b/redraw/src/redraw/attribute.gleam
index 8966a11..6ebcca4 100644
--- a/redraw/src/redraw/attribute.gleam
+++ b/redraw/src/redraw/attribute.gleam
@@ -1,33 +1,51 @@
+//// Implementation for HTML and SVG attributes usable in React and in browser.
+//// Contrarily to Lustre, every attributes can take arbitrary data, because
+//// they're directly bind in the underlying component's props.
+////
+//// All available attributes can be found in the
+//// [React.dev](https://react.dev/reference/react-dom/components/common#common)
+//// documentation for detailed information, as well as on
+//// [MDN](https://developer.mozilla.org/docs/Web/API/Element).
+
 import gleam/option
 import gleam/string
 import redraw
 import redraw/internals/attribute
 
+/// Attribute linked on an HTML or SVG node. Think about like a `prop` in React.
 pub type Attribute =
   attribute.Attribute
 
 pub const attribute = attribute.attribute
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLAnchorElement/href)
 pub fn href(url: String) {
-  attribute.attribute("href", url)
+  attribute("href", url)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLAnchorElement/target)
 pub fn target(value: String) {
-  attribute.attribute("target", value)
+  attribute("target", value)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/src)
 pub fn src(value: String) {
-  attribute.attribute("src", value)
+  attribute("src", value)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/class)
 pub fn class(value: String) {
-  attribute.attribute("className", value)
+  attribute("className", value)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/alt)
 pub fn alt(value: String) {
-  attribute.attribute("alt", value)
+  attribute("alt", value)
 }
 
+/// Inner HTML data are HTML that will not be verified sanitized.
+/// Be careful when using it. You should almost always prefer to use
+/// `redraw/element/html`.
 pub type InnerHTML
 
 /// The `inner_html` data should be created as close to where the HTML is
@@ -35,8 +53,7 @@ pub type InnerHTML
 /// 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))], [])`
-///
+/// `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
@@ -44,11 +61,10 @@ 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.
-///
+/// 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)
+  attribute("dangerouslySetInnerHTML", inner_html)
 }
 
 /// A ref object from `redraw.use_ref`. Your ref will be filled with the DOM
@@ -56,323 +72,419 @@ pub fn dangerously_set_inner_html(inner_html: InnerHTML) {
 /// forced to use an optional type here. Because when using this function, you
 /// want to get a reference from a real DOM node, meaning at the initialization
 /// of the reference, you won't have any data. Use `ref_` when you want full
-/// control over the ref you send to the Component.
+/// control over the ref you send to the Component. \
+/// [Documentation](https://react.dev/reference/react-dom/components/common#manipulating-a-dom-node-with-a-ref)
 pub fn ref(ref: redraw.Ref(option.Option(a))) {
-  attribute.attribute("ref", fn(dom_ref) {
-    redraw.set_current(ref, option.Some(dom_ref))
-  })
+  attribute("ref", fn(dom_ref) { redraw.set_current(ref, option.Some(dom_ref)) })
 }
 
 /// 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.
+/// DOM node or the component. \
+/// [Documentation](https://react.dev/reference/react-dom/components/common#manipulating-a-dom-node-with-a-ref)
 pub fn ref_(ref: fn(a) -> Nil) {
-  attribute.attribute("ref", ref)
+  attribute("ref", ref)
 }
 
+/// If `True`, suppresses the warning that React shows for elements that both
+/// have `children` and `content_editable(True)` (which normally do not work
+/// together). Use this if you’re building a text input library that manages
+/// the `contentEditable` content manually.
 pub fn suppress_content_editable_warning(value: Bool) {
-  attribute.attribute("suppressContentEditableWarning", value)
+  attribute("suppressContentEditableWarning", value)
 }
 
+/// If you use [server rendering](https://react.dev/reference/react-dom/server),
+/// normally there is a warning when the server and the client render different
+/// content. In some rare cases (like timestamps), it is very hard or impossible
+/// to guarantee an exact match. If you set suppressHydrationWarning to true,
+/// React will not warn you about mismatches in the attributes and the content
+/// of that element. It only works one level deep, and is intended to be used
+/// as an escape hatch. Don’t overuse it.
+/// [Read about suppressing hydration errors.](https://react.dev/reference/react-dom/client/hydrateRoot#suppressing-unavoidable-hydration-mismatch-errors)
 pub fn suppress_hydration_warning(value: Bool) {
-  attribute.attribute("suppressHydrationWarning", value)
+  attribute("suppressHydrationWarning", value)
 }
 
 @external(javascript, "../redraw.ffi.mjs", "convertStyle")
 fn convert_style(styles: List(#(String, String))) -> a
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/style)
 pub fn style(styles: List(#(String, String))) {
-  attribute.attribute("style", convert_style(styles))
+  attribute("style", convert_style(styles))
 }
 
 /// Set aria attribute on the node. Should be used like `aria("valuenow", "75")`.
 pub fn aria(key: String, value: String) {
-  attribute.attribute("aria-" <> key, value)
+  attribute("aria-" <> key, value)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/accesskey)
 pub fn access_key(value: String) {
-  attribute.attribute("accessKey", value)
+  attribute("accessKey", value)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/autocapitalize)
 pub fn auto_capitalize(value: String) {
-  attribute.attribute("autoCapitalize", value)
+  attribute("autoCapitalize", value)
 }
 
-/// Alias of `class`.
+/// Alias of `class`. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/class)
 pub fn class_name(value: String) {
-  attribute.attribute("className", value)
+  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
 /// `content_editable(True)` because React will not be able to update its content
-/// after user edits.
+/// after user edits. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTML/Global_attributes/contenteditable)
 pub fn content_editable(value: Bool) {
-  attribute.attribute("contentEditable", value)
+  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.
+/// would usually read data from props or state instead. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/data-*)
 pub fn data(key: String, value: String) {
-  attribute.attribute("data-" <> key, value)
+  attribute("data-" <> key, value)
 }
 
+/// Directionality of an element text.
 pub type Dir {
   Ltr
   Rtl
 }
 
-/// Specifies the text direction of the element.
+/// Specifies the text direction of the element. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/dir)
 pub fn dir(value: Dir) {
   let value = case value {
     Ltr -> "ltr"
     Rtl -> "rtl"
   }
-  attribute.attribute("dir", value)
+  attribute("dir", value)
 }
 
-/// Specifies whether the element is draggable. Part of HTML Drag and Drop API.
+/// Specifies whether the element is draggable. Part of HTML Drag and Drop API. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/draggable)
 pub fn draggable(value: Bool) {
-  attribute.attribute("draggable", value)
+  attribute("draggable", value)
 }
 
-/// Specifies which action to present for the enter key on virtual keyboards.
+/// Specifies which action to present for the enter key on virtual keyboards.\
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/enterkeyhint)
 pub fn enter_key_hint(value: String) {
-  attribute.attribute("enterKeyHint", value)
+  attribute("enterKeyHint", value)
 }
 
 /// For <label> and <output>, lets you associate the label with some control.
-/// Same as for HTML attribute.
+/// Same as for HTML attribute. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Attributes/for)
 pub fn for(value: String) {
-  attribute.attribute("htmlFor", value)
+  attribute("htmlFor", value)
 }
 
-/// Alias of `for`.
+/// Alias of `for`. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Attributes/for)
 pub fn html_for(value: String) {
-  attribute.attribute("htmlFor", value)
+  attribute("htmlFor", value)
 }
 
-/// Specifies whether the element should be hidden.
+/// Specifies whether the element should be hidden. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/hidden)
 pub fn hidden(value: Bool) {
-  attribute.attribute("hidden", value)
+  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.
+/// clashes between multiple instances of the same component. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/id)
 pub fn id(value: String) {
-  attribute.attribute("id", value)
+  attribute("id", value)
 }
 
-/// If specified, the component will behave like a custom element.
+/// If specified, the component will behave like a custom element. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/is)
 pub fn is(value: String) {
-  attribute.attribute("is", value)
+  attribute("is", value)
 }
 
-/// Specifies what kind of keyboard to display (for example, text, number or telephone).
+/// Specifies what kind of keyboard to display (for example, text, number or telephone). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/inputmode)
 pub fn input_mode(value: String) {
-  attribute.attribute("inputMode", value)
+  attribute("inputMode", value)
 }
 
-/// Specifies which property the element represents for structured data crawlers.
+/// Specifies which property the element represents for structured data crawlers. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/itemprop)
 pub fn item_prop(value: String) {
-  attribute.attribute("itemProp", value)
+  attribute("itemProp", value)
 }
 
-/// Specifies the language of the element.
+/// Specifies the language of the element. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/lang)
 pub fn lang(value: String) {
-  attribute.attribute("lang", value)
+  attribute("lang", value)
 }
 
 /// Specifies the element role explicitly for assistive technologies.
 pub fn role(value: String) {
-  attribute.attribute("role", value)
+  attribute("role", value)
 }
 
-/// Specifies the slot name when using shadow DOM.
+/// Specifies the slot name when using shadow DOM. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/slot)
 pub fn slot(value: String) {
-  attribute.attribute("slot", value)
+  attribute("slot", value)
 }
 
-/// If explicitly set to true or false, enables or disables spellchecking.
+/// If explicitly set to true or false, enables or disables spellchecking. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/spellcheck)
 pub fn spell_check(value: Bool) {
-  attribute.attribute("spellCheck", value)
+  attribute("spellCheck", value)
 }
 
-/// Overrides the default Tab button behavior. Avoid using values other than -1 and 0.
+/// Overrides the default Tab button behavior. Avoid using values other than -1 and 0. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/tabindex)
 pub fn tab_index(value: Int) {
-  attribute.attribute("tabIndex", value)
+  attribute("tabIndex", value)
 }
 
-/// Specifies the tooltip text for the element.
+/// Specifies the tooltip text for the element. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/title)
 pub fn title(value: String) {
-  attribute.attribute("title", value)
+  attribute("title", value)
 }
 
+/// Translate of a translatable element.
 pub type Translate {
   Yes
   No
 }
 
-/// Passing No excludes the element content from being translated.
+/// Passing No excludes the element content from being translated. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/translate)
 pub fn translate(value: Translate) {
   let value = case value {
     Yes -> "yes"
     No -> "no"
   }
-  attribute.attribute("translate", value)
-}
-
+  attribute("translate", value)
+}
+
+/// Type of an `input`. Value can be
+/// [`"button"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/button),
+/// [`"checkbox"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/checkbox),
+/// [`"color"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/color),
+/// [`"date"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/date),
+/// [`"datetime-local"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/datetime-local),
+/// [`"email"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/email),
+/// [`"file"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/file),
+/// [`"hidden"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/hidden),
+/// [`"image"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/image),
+/// [`"month"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/month),
+/// [`"number"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/number),
+/// [`"password"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/password),
+/// [`"radio"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/radio),
+/// [`"range"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/range),
+/// [`"reset"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/reset),
+/// [`"search"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/search),
+/// [`"submit"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/submit),
+/// [`"tel"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/tel),
+/// [`"text"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/text),
+/// [`"time"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/time),
+/// [`"url"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/url), or
+/// [`"week"`](https://developer.mozilla.org/docs/Web/HTML/Element/input/week).
 pub fn type_(name: String) {
-  attribute.attribute("type", name)
+  attribute("type", name)
 }
 
+/// [Input Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/input#value) \
+/// [Button Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/button#value)
 pub fn value(val: String) {
-  attribute.attribute("value", val)
+  attribute("value", val)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/input#checked)
 pub fn checked(is_checked: Bool) {
-  attribute.attribute("checked", is_checked)
+  attribute("checked", is_checked)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Attributes/placeholder)
 pub fn placeholder(text: String) {
-  attribute.attribute("placeholder", text)
+  attribute("placeholder", text)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/option#selected)
 pub fn selected(is_selected: Bool) {
-  attribute.attribute("selected", is_selected)
+  attribute("selected", is_selected)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Attributes/accept)
 pub fn accept(types: List(String)) {
-  attribute.attribute("accept", string.join(types, " "))
+  attribute("accept", string.join(types, " "))
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLFormElement/acceptCharset)
 pub fn accept_charset(types: List(String)) {
-  attribute.attribute("acceptCharset", string.join(types, " "))
+  attribute("acceptCharset", string.join(types, " "))
 }
 
 pub fn msg(uri: String) {
-  attribute.attribute("msg", uri)
+  attribute("msg", uri)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Attributes/autocomplete)
 pub fn autocomplete(name: String) {
-  attribute.attribute("autocomplete", name)
+  attribute("autocomplete", name)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Global_attributes/autofocus)
 pub fn autofocus(should_autofocus: Bool) {
-  attribute.attribute("autofocus", should_autofocus)
+  attribute("autofocus", should_autofocus)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Attributes/disabled)
 pub fn disabled(is_disabled: Bool) {
-  attribute.attribute("disabled", is_disabled)
+  attribute("disabled", is_disabled)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLFormElement/name)
 pub fn name(name: String) {
-  attribute.attribute("name", name)
+  attribute("name", name)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Attributes/pattern)
 pub fn pattern(regex: String) {
-  attribute.attribute("pattern", regex)
+  attribute("pattern", regex)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Attributes/readonly)
 pub fn readonly(is_readonly: Bool) {
-  attribute.attribute("readonly", is_readonly)
+  attribute("readonly", is_readonly)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Attributes/required)
 pub fn required(is_required: Bool) {
-  attribute.attribute("required", is_required)
+  attribute("required", is_required)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Attributes/max)
 pub fn max(val: String) {
-  attribute.attribute("max", val)
+  attribute("max", val)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Attributes/min)
 pub fn min(val: String) {
-  attribute.attribute("min", val)
+  attribute("min", val)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Attributes/step)
 pub fn step(val: String) {
-  attribute.attribute("step", val)
+  attribute("step", val)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/cols)
 pub fn cols(val: Int) {
-  attribute.attribute("cols", val)
+  attribute("cols", val)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/rows)
 pub fn rows(val: Int) {
-  attribute.attribute("rows", val)
+  attribute("rows", val)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/wrap)
 pub fn wrap(mode: String) {
-  attribute.attribute("wrap", mode)
+  attribute("wrap", mode)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLAnchorElement/download)
 pub fn download(filename: String) {
-  attribute.attribute("download", filename)
+  attribute("download", filename)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Attributes/rel)
 pub fn rel(relationship: String) {
-  attribute.attribute("rel", relationship)
+  attribute("rel", relationship)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLObjectElement/height)
 pub fn height(val: Int) {
-  attribute.attribute("height", val)
+  attribute("height", val)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLObjectElement/width)
 pub fn width(val: Int) {
-  attribute.attribute("width", val)
+  attribute("width", val)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/autoplay)
 pub fn autoplay(should_autoplay: Bool) {
-  attribute.attribute("autoplay", should_autoplay)
+  attribute("autoplay", should_autoplay)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/controls)
 pub fn controls(visible: Bool) {
-  attribute.attribute("controls", visible)
+  attribute("controls", visible)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/loop)
 pub fn loop(should_loop: Bool) {
-  attribute.attribute("loop", should_loop)
+  attribute("loop", should_loop)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLFormElement/action)
 pub fn action(url: String) {
-  attribute.attribute("action", url)
+  attribute("action", url)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLFormElement/enctype)
 pub fn enctype(value: String) {
-  attribute.attribute("enctype", value)
+  attribute("enctype", value)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLFormElement/method)
 pub fn method(method: String) {
-  attribute.attribute("method", method)
+  attribute("method", method)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLFormElement/novalidate)
 pub fn novalidate(value: Bool) {
-  attribute.attribute("novalidate", value)
+  attribute("novalidate", value)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/button#formaction)
 pub fn form_action(action: String) {
-  attribute.attribute("formaction", action)
+  attribute("formaction", action)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/button#formenctype)
 pub fn form_enctype(value: String) {
-  attribute.attribute("formenctype", value)
+  attribute("formenctype", value)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/button#formmethod)
 pub fn form_method(method: String) {
-  attribute.attribute("formmethod", method)
+  attribute("formmethod", method)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/button#formnovalidate)
 pub fn form_novalidate(value: Bool) {
-  attribute.attribute("formnovalidate", value)
+  attribute("formnovalidate", value)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/button#formtarget)
 pub fn form_target(target: String) {
-  attribute.attribute("formtarget", target)
+  attribute("formtarget", target)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/HTMLDetailsElement/open)
 pub fn open(is_open: Bool) {
-  attribute.attribute("open", is_open)
+  attribute("open", is_open)
 }
diff --git a/redraw/src/redraw/error.gleam b/redraw/src/redraw/error.gleam
index dcf979a..8b7328e 100644
--- a/redraw/src/redraw/error.gleam
+++ b/redraw/src/redraw/error.gleam
@@ -1,9 +1,10 @@
-/// Main error type. Currently, only used in conjuction with `Context` functions.
+/// Main error type. Currently only used in conjuction with `Context` related
+/// functions.
 pub type Error {
-  /// Error thrown in `create_context_`.
+  /// Error returned from `create_context_`.
   /// Context with the corresponding `name` already exists.
   ExistingContext(name: String)
-  /// Error thrown in `get_context`.
+  /// Error returned from `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 55caff1..081f681 100644
--- a/redraw/src/redraw/event.gleam
+++ b/redraw/src/redraw/event.gleam
@@ -1,67 +1,118 @@
+//// Event handlers will receive a React event object. It is also sometimes
+//// known as a “synthetic event”.
+////
+//// ```gleam
+//// import redraw/element/html
+//// import redraw/handler
+////
+//// pub fn render() {
+////   html.button(
+////     [
+////       handler.on_click(fn (event) {
+////         io.debug(event) // React Event
+////       })
+////     ],
+////     [html.text("Exampe")]
+////   )
+//// }
+//// ```
+////
+//// It conforms to the same standard as the underlying DOM events, but fixes
+//// some browser inconsistencies.
+////
+//// Some React events do not map directly to the browser’s native events.
+//// For example in `on_mouse_leave`, `event.native_event(event)` will point to a
+//// `MouseEvent` event.
+//// The specific mapping is not part of the public API and may change in the
+//// future. If you need the underlying browser event for some reason, read it
+//// from `event.native_event(event)`.
+////
+//// Every events have their implementation as `redraw/event/[event_name]`, and
+//// their corresponding functions are implemented in those. Every time you need
+//// to use one of the functions defined here, use `to_event` from the
+//// corresponding module.
+////
+//// [Documentation](https://react.dev/reference/react-dom/components/common#react-event-object)
+
 import gleam/dynamic
 
 /// Synthetic Event sent by React.
-/// It conforms to the same standard as the underlying DOM events, but fixes some browser inconsistencies.
-///
+/// 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.
+/// Returns whether the event bubbles through the DOM. \
+/// [Documetation](https://developer.mozilla.org/docs/Web/API/Event/bubbles)
 @external(javascript, "../events.ffi.mjs", "bubbles")
 pub fn bubbles(event: Event) -> Bool
 
-/// Returns whether the event can be canceled.
+/// Returns whether the event can be canceled. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Event/cancelable)
 @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.
+/// Returns the node to which the current handler is attached in the React tree. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Event/currentTarget)
 @external(javascript, "../events.ffi.mjs", "currentTarget")
 pub fn current_target(event: Event) -> dynamic.Dynamic
 
-/// Returns whether `prevent_default` was called.
+/// Returns whether `prevent_default` was called. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Event/defaultPrevented)
 @external(javascript, "../events.ffi.mjs", "defaultPrevented")
 pub fn default_prevented(event: Event) -> Bool
 
-/// Returns which phase the event is currently in.
+/// Returns which phase the event is currently in. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Event/eventPhase)
 @external(javascript, "../events.ffi.mjs", "eventPhase")
 pub fn event_phase(event: Event) -> Int
 
-/// Returns whether the event was initiated by user.
+/// Returns whether the event was initiated by user. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Event/isTrusted)
 @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).
+/// Returns the node on which the event has occurred (which could be a distant child). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Event/target)
 @external(javascript, "../events.ffi.mjs", "target")
 pub fn target(event: Event) -> dynamic.Dynamic
 
-/// Returns the time when the event occurred.
+/// Returns the time when the event occurred. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Event/timeStamp)
 @external(javascript, "../events.ffi.mjs", "timeStamp")
 pub fn time_stamp(event: Event) -> Int
 
-/// The original browser event object.
+/// The original browser event object. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Event)
 @external(javascript, "../events.ffi.mjs", "nativeEvent")
 pub fn native_event(event: Event) -> dynamic.Dynamic
 
-/// Prevents the default browser action for the event.
+/// Prevents the default browser action for the event. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Event/preventDefault)
 @external(javascript, "../events.ffi.mjs", "preventDefault")
 pub fn prevent_default(event: Event) -> Event
 
-/// Stops the event propagation through the React tree.
+/// Stops the event propagation through the React tree. \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Event/stopPropagation)
 @external(javascript, "../events.ffi.mjs", "stopPropagation")
 pub fn stop_propagation(event: Event) -> Event
 
-/// Returns a boolean value indicating whether `prevent_default` was called.
+/// Returns a boolean value indicating whether `prevent_default` was called. \
+/// React addition, does not exist in standard browsers.
 @external(javascript, "../events.ffi.mjs", "isDefaultPrevented")
 pub fn is_default_prevented(event: Event) -> Bool
 
 /// Returns a boolean value indicating whether `stop_propagation` was called.
+/// React addition, does not exist in standard browsers.
 @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.
+/// Not used with React DOM. With React Native, call this to read event’s properties after the event. \
+/// React addition, does not exist in standard browsers.
 @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.
+/// Not used with React DOM. With React Native, returns whether persist has been called. \
+/// React addition, does not exist in standard browsers.
 @external(javascript, "../events.ffi.mjs", "isPersistent")
 pub fn is_persistent(event: Event) -> Bool
diff --git a/redraw/src/redraw/event/animation.gleam b/redraw/src/redraw/event/animation.gleam
index 382acaa..1c30869 100644
--- a/redraw/src/redraw/event/animation.gleam
+++ b/redraw/src/redraw/event/animation.gleam
@@ -1,17 +1,25 @@
+//// The `AnimationEvent` interface represents events providing information
+//// related to [animations](https://developer.mozilla.org/docs/Web/CSS/CSS_animations/Using_CSS_animations).
+
 import redraw/event.{type Event}
 import redraw/internals/coerce.{coerce}
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/AnimationEvent)
 pub type AnimationEvent
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/AnimationEvent/animationName)
 @external(javascript, "../../events.ffi.mjs", "animationName")
 pub fn animation_name(event: AnimationEvent) -> String
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/AnimationEvent/elapsedTime)
 @external(javascript, "../../events.ffi.mjs", "elapsedTime")
 pub fn elapsed_time(event: AnimationEvent) -> Float
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/AnimationEvent/pseudoElement)
 @external(javascript, "../../events.ffi.mjs", "pseudoElement")
 pub fn pseudo_element(event: AnimationEvent) -> String
 
+/// `AnimationEvent` inherits `Event`.
 pub fn as_event(event: AnimationEvent) -> Event {
   coerce(event)
 }
diff --git a/redraw/src/redraw/event/clipboard.gleam b/redraw/src/redraw/event/clipboard.gleam
index b2bf255..e65800a 100644
--- a/redraw/src/redraw/event/clipboard.gleam
+++ b/redraw/src/redraw/event/clipboard.gleam
@@ -1,12 +1,21 @@
+//// The `ClipboardEvent` interface of the [Clipboard API](https://developer.mozilla.org/docs/Web/API/Clipboard_API) represents events
+//// providing information related to modification of the clipboard, that is
+//// [`cut`](https://developer.mozilla.org/docs/Web/API/Element/cut_event),
+//// [`copy`](https://developer.mozilla.org/docs/Web/API/Element/cut_event), and
+//// [`paste`](https://developer.mozilla.org/docs/Web/API/Element/cut_event) events.
+
 import gleam/dynamic
 import redraw/event.{type Event}
 import redraw/internals/coerce.{coerce}
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/ClipboardEvent)
 pub type ClipboardEvent
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/ClipboardEvent/clipboardData)
 @external(javascript, "../../events.ffi.mjs", "clipboardData")
 pub fn clipboard_data(event: ClipboardEvent) -> dynamic.Dynamic
 
+/// `ClipboardEvent` inherits `Event`.
 pub fn as_event(event: ClipboardEvent) -> Event {
   coerce(event)
 }
diff --git a/redraw/src/redraw/event/composition.gleam b/redraw/src/redraw/event/composition.gleam
index c38ce36..30b8437 100644
--- a/redraw/src/redraw/event/composition.gleam
+++ b/redraw/src/redraw/event/composition.gleam
@@ -1,11 +1,19 @@
+//// The DOM `CompositionEvent` represents events that occur due to the user
+//// indirectly entering text.
+////
+//// [Input Method Editor Documentation](https://developer.mozilla.org/docs/Glossary/Input_method_editor).
+
 import redraw/event.{type Event}
 import redraw/internals/coerce.{coerce}
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/CompositionEvent)
 pub type CompositionEvent
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/CompositionEvent/data)
 @external(javascript, "../../events.ffi.mjs", "data")
 pub fn data(event: CompositionEvent) -> String
 
+/// `CompositionEvent` inherits `Event`.
 pub fn as_event(event: CompositionEvent) -> Event {
   coerce(event)
 }
diff --git a/redraw/src/redraw/event/drag.gleam b/redraw/src/redraw/event/drag.gleam
index a7040ae..7f8579e 100644
--- a/redraw/src/redraw/event/drag.gleam
+++ b/redraw/src/redraw/event/drag.gleam
@@ -1,22 +1,35 @@
+//// The `DragEvent` interface is a DOM event that represents a drag and drop
+//// interaction. The user initiates a drag by placing a pointer device (such as
+//// a mouse) on the touch surface and then dragging the pointer to a new
+//// location (such as another DOM element). Applications are free to interpret
+//// a drag and drop interaction in an application-specific way.
+////
+//// [Drag and Drop API Documentation](https://developer.mozilla.org/docs/Web/API/HTML_Drag_and_Drop_API)
+
 import gleam/dynamic
 import redraw/event.{type Event}
 import redraw/event/mouse.{type MouseEvent}
 import redraw/event/ui.{type UIEvent}
 import redraw/internals/coerce.{coerce}
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/DragEvent)
 pub type DragEvent
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/DragEvent/dataTransfer)
 @external(javascript, "../../events.ffi.mjs", "dataTransfer")
 pub fn data_transfer(event: DragEvent) -> dynamic.Dynamic
 
+/// `DragEvent` inherits from `MouseEvent`.
 pub fn as_mouse_event(event: DragEvent) -> MouseEvent {
   coerce(event)
 }
 
+/// `DragEvent` inherits from `UIEvent`.
 pub fn as_ui_event(event: DragEvent) -> UIEvent {
   coerce(event)
 }
 
+/// `DragEvent` inherits `Event`.
 pub fn as_event(event: DragEvent) -> Event {
   coerce(event)
 }
diff --git a/redraw/src/redraw/event/focus.gleam b/redraw/src/redraw/event/focus.gleam
index 06181df..80bc00f 100644
--- a/redraw/src/redraw/event/focus.gleam
+++ b/redraw/src/redraw/event/focus.gleam
@@ -1,17 +1,27 @@
+//// The `FocusEvent` interface represents focus-related events, including
+//// [`focus`](https://developer.mozilla.org/en-US/docs/Web/API/Element/focus_event),
+//// [`blur`](https://developer.mozilla.org/en-US/docs/Web/API/Element/blur_event),
+//// [`focusin`](https://developer.mozilla.org/en-US/docs/Web/API/Element/focusin_event),
+//// and [`focusout`](https://developer.mozilla.org/en-US/docs/Web/API/Element/focusout_event).
+
 import gleam/dynamic
 import redraw/event.{type Event}
 import redraw/event/ui.{type UIEvent}
 import redraw/internals/coerce.{coerce}
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/FocusEvent)
 pub type FocusEvent
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/FocusEvent/relatedTarget)
 @external(javascript, "../../events.ffi.mjs", "relatedTarget")
 pub fn related_target(event: FocusEvent) -> dynamic.Dynamic
 
+/// `FocusEvent` inherits `UIEvent`.
 pub fn as_ui_event(event: FocusEvent) -> UIEvent {
   coerce(event)
 }
 
+/// `FocusEvent` inherits `Event`.
 pub fn as_event(event: FocusEvent) -> Event {
   coerce(event)
 }
diff --git a/redraw/src/redraw/event/input.gleam b/redraw/src/redraw/event/input.gleam
index 0e9fd81..f68b5c4 100644
--- a/redraw/src/redraw/event/input.gleam
+++ b/redraw/src/redraw/event/input.gleam
@@ -1,11 +1,16 @@
+//// The `InputEvent` interface represents an event notifying the user of editable content changes.
+
 import redraw/event.{type Event}
 import redraw/internals/coerce.{coerce}
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/InputEvent)
 pub type InputEvent
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/InputEvent/data)
 @external(javascript, "../../events.ffi.mjs", "data")
 pub fn data(event: InputEvent) -> String
 
+/// `InputEvent` inherits `Event`.
 pub fn as_event(event: InputEvent) -> Event {
   coerce(event)
 }
diff --git a/redraw/src/redraw/event/keyboard.gleam b/redraw/src/redraw/event/keyboard.gleam
index 60cb977..a4662ee 100644
--- a/redraw/src/redraw/event/keyboard.gleam
+++ b/redraw/src/redraw/event/keyboard.gleam
@@ -1,52 +1,79 @@
+//// `KeyboardEvent` objects describe a user interaction with the keyboard; each
+//// event describes a single interaction between the user and a key (or
+//// combination of a key with modifier keys) on the keyboard. The event type
+//// ([`keydown`](https://developer.mozilla.org/docs/Web/API/Element/keydown_event),
+//// [`keypress`](https://developer.mozilla.org/docs/Web/API/Element/keypress_event),
+//// or [`keyup`](https://developer.mozilla.org/docs/Web/API/Element/keyup_event))
+//// identifies what kind of keyboard activity occurred.
+
 import redraw/event.{type Event}
 import redraw/event/ui.{type UIEvent}
 import redraw/internals/coerce.{coerce}
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/KeyboardEvent)
 pub type KeyboardEvent
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/altKey)
 @external(javascript, "../../events.ffi.mjs", "altKey")
 pub fn alt_key(event: KeyboardEvent) -> Bool
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/charCode)
+@deprecated("This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Do not use this property, as it is deprecated. Instead, get the Unicode value of the character using the key property.")
 @external(javascript, "../../events.ffi.mjs", "charCode")
 pub fn char_code(event: KeyboardEvent) -> Int
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/code)
 @external(javascript, "../../events.ffi.mjs", "code")
 pub fn code(event: KeyboardEvent) -> String
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/ctrlKey)
 @external(javascript, "../../events.ffi.mjs", "ctrlKey")
 pub fn ctrl_key(event: KeyboardEvent) -> Bool
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/key)
 @external(javascript, "../../events.ffi.mjs", "key")
 pub fn key(event: KeyboardEvent) -> String
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/keyCode)
+@deprecated("This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes.")
 @external(javascript, "../../events.ffi.mjs", "keyCode")
 pub fn key_code(event: KeyboardEvent) -> Int
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/locale)
 @external(javascript, "../../events.ffi.mjs", "locale")
 pub fn locale(event: KeyboardEvent) -> String
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/metaKey)
 @external(javascript, "../../events.ffi.mjs", "metaKey")
 pub fn meta_key(event: KeyboardEvent) -> Bool
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/location)
 @external(javascript, "../../events.ffi.mjs", "location")
 pub fn location(event: KeyboardEvent) -> Float
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/repeat)
 @external(javascript, "../../events.ffi.mjs", "repeat")
 pub fn repeat(event: KeyboardEvent) -> Bool
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/shiftKey)
 @external(javascript, "../../events.ffi.mjs", "shiftKey")
 pub fn shift_key(event: KeyboardEvent) -> Bool
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/which)
+@deprecated("This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes.")
 @external(javascript, "../../events.ffi.mjs", "which")
 pub fn which(event: KeyboardEvent) -> Int
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/getModifierState)
 @external(javascript, "../../events.ffi.mjs", "getModifierState")
 pub fn get_modifier_state(event: KeyboardEvent, key: String) -> Bool
 
+/// `KeyboardEvent` inherits `UIEvent`.
 pub fn as_ui_event(event: KeyboardEvent) -> UIEvent {
   coerce(event)
 }
 
+/// `KeyboardEvent` inherits `Event`.
 pub fn as_event(event: KeyboardEvent) -> Event {
   coerce(event)
 }
diff --git a/redraw/src/redraw/event/mouse.gleam b/redraw/src/redraw/event/mouse.gleam
index 6522bcf..003082d 100644
--- a/redraw/src/redraw/event/mouse.gleam
+++ b/redraw/src/redraw/event/mouse.gleam
@@ -1,65 +1,96 @@
+//// The `MouseEvent` interface represents events that occur due to the user
+//// interacting with a pointing device (such as a mouse). Common events using
+//// this interface include [`click`](https://developer.mozilla.org/docs/Web/API/Element/click_event),
+//// [`dblclick`](https://developer.mozilla.org/docs/Web/API/Element/dblclick_event),
+//// [`mouseup`](https://developer.mozilla.org/docs/Web/API/Element/mouseup_event),
+//// [`mousedown`](https://developer.mozilla.org/docs/Web/API/Element/mousedown_event).
+
 import gleam/dynamic
 import redraw/event.{type Event}
 import redraw/event/ui.{type UIEvent}
 import redraw/internals/coerce.{coerce}
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent)
 pub type MouseEvent
 
-@external(javascript, "../../events.ffi.mjs", "clipboardData")
-pub fn clipboard_data(event: MouseEvent) -> dynamic.Dynamic
-
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/altKey)
 @external(javascript, "../../events.ffi.mjs", "altKey")
 pub fn alt_key(event: MouseEvent) -> Bool
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/button)
 @external(javascript, "../../events.ffi.mjs", "button")
 pub fn button(event: MouseEvent) -> Int
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/buttons)
 @external(javascript, "../../events.ffi.mjs", "buttons")
 pub fn buttons(event: MouseEvent) -> Int
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/ctrlKey)
 @external(javascript, "../../events.ffi.mjs", "ctrlKey")
 pub fn ctrl_key(event: MouseEvent) -> Bool
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/clientX)
 @external(javascript, "../../events.ffi.mjs", "clientX")
 pub fn client_x(event: MouseEvent) -> Float
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/clientY)
 @external(javascript, "../../events.ffi.mjs", "clientY")
 pub fn client_y(event: MouseEvent) -> Float
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/metaKey)
 @external(javascript, "../../events.ffi.mjs", "metaKey")
 pub fn meta_key(event: MouseEvent) -> Bool
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/movementX)
 @external(javascript, "../../events.ffi.mjs", "movementX")
 pub fn movement_x(event: MouseEvent) -> Int
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/movementY)
 @external(javascript, "../../events.ffi.mjs", "movementY")
 pub fn movement_y(event: MouseEvent) -> Int
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/pageX)
 @external(javascript, "../../events.ffi.mjs", "pageX")
 pub fn page_x(event: MouseEvent) -> Float
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/pageY)
 @external(javascript, "../../events.ffi.mjs", "pageY")
 pub fn page_y(event: MouseEvent) -> Float
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/offsetX)
+@external(javascript, "../../events.ffi.mjs", "offsetX")
+pub fn offset_x(event: MouseEvent) -> Float
+
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/offsetY)
+@external(javascript, "../../events.ffi.mjs", "offsetY")
+pub fn offset_y(event: MouseEvent) -> Float
+
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/relatedTarget)
 @external(javascript, "../../events.ffi.mjs", "relatedTarget")
 pub fn related_target(event: MouseEvent) -> dynamic.Dynamic
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/screenX)
 @external(javascript, "../../events.ffi.mjs", "screenX")
 pub fn screen_x(event: MouseEvent) -> Float
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/screenY)
 @external(javascript, "../../events.ffi.mjs", "screenY")
 pub fn screen_y(event: MouseEvent) -> Float
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/shiftKey)
 @external(javascript, "../../events.ffi.mjs", "shiftKey")
 pub fn shift_key(event: MouseEvent) -> Bool
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/MouseEvent/getModifierState)
 @external(javascript, "../../events.ffi.mjs", "getModifierState")
 pub fn get_modifier_state(event: MouseEvent, key: String) -> Bool
 
+/// `MouseEvent` inherits `UIEvent`.
 pub fn as_ui_event(event: MouseEvent) -> UIEvent {
   coerce(event)
 }
 
+/// `MouseEvent` inherits `Event`.
 pub fn as_event(event: MouseEvent) -> Event {
   coerce(event)
 }
diff --git a/redraw/src/redraw/event/pointer.gleam b/redraw/src/redraw/event/pointer.gleam
index 4eb4074..bcf1c93 100644
--- a/redraw/src/redraw/event/pointer.gleam
+++ b/redraw/src/redraw/event/pointer.gleam
@@ -1,48 +1,85 @@
+//// The `PointerEvent` interface represents the state of a DOM event produced by
+//// a pointer such as the geometry of the contact point, the device type that
+//// generated the event, the amount of pressure that was applied on the contact
+//// surface, etc.
+////
+//// A pointer is a hardware agnostic representation of input devices (such as a
+//// mouse, pen or contact point on a touch-enable surface). The pointer can
+//// target a specific coordinate (or set of coordinates) on the contact surface
+//// such as a screen.
+////
+//// A pointer's hit test is the process a browser uses to determine the target
+//// element for a pointer event. Typically, this is determined by considering
+//// the pointer's location and also the visual layout of elements in a document
+//// on screen media.
+
 import redraw/event.{type Event}
 import redraw/event/mouse.{type MouseEvent}
 import redraw/event/ui.{type UIEvent}
 import redraw/internals/coerce.{coerce}
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/PointerEvent)
 pub type PointerEvent
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/PointerEvent/altitudeAngle)
+@external(javascript, "../../events.ffi.mjs", "altitudeAngle")
+pub fn altitude_angle(event: PointerEvent) -> Int
+
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/PointerEvent/azimuthAngle)
+@external(javascript, "../../events.ffi.mjs", "azimuthAngle")
+pub fn azimuth_angle(event: PointerEvent) -> Int
+
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/PointerEvent/height)
 @external(javascript, "../../events.ffi.mjs", "height")
 pub fn height(event: PointerEvent) -> Int
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/PointerEvent/isPrimary)
 @external(javascript, "../../events.ffi.mjs", "isPrimary")
 pub fn is_primary(event: PointerEvent) -> Bool
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/PointerEvent/pointerId)
 @external(javascript, "../../events.ffi.mjs", "pointerId")
 pub fn pointer_id(event: PointerEvent) -> Int
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/PointerEvent/pointerType)
 @external(javascript, "../../events.ffi.mjs", "pointerType")
 pub fn pointer_type(event: PointerEvent) -> String
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/PointerEvent/pressure)
 @external(javascript, "../../events.ffi.mjs", "pressure")
 pub fn pressure(event: PointerEvent) -> Float
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/PointerEvent/tangentialPressure)
 @external(javascript, "../../events.ffi.mjs", "tangentialPressure")
 pub fn tangential_pressure(event: PointerEvent) -> Float
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/PointerEvent/tiltX)
 @external(javascript, "../../events.ffi.mjs", "tiltX")
 pub fn tilt_x(event: PointerEvent) -> Int
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/PointerEvent/tiltY)
 @external(javascript, "../../events.ffi.mjs", "tiltY")
 pub fn tilt_y(event: PointerEvent) -> Int
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/PointerEvent/twist)
 @external(javascript, "../../events.ffi.mjs", "twist")
 pub fn twist(event: PointerEvent) -> Int
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/PointerEvent/width)
 @external(javascript, "../../events.ffi.mjs", "width")
 pub fn width(event: PointerEvent) -> Int
 
+/// `PointerEvent` inherits `MouseEvent`.
 pub fn as_mouse_event(event: PointerEvent) -> MouseEvent {
   coerce(event)
 }
 
+/// `PointerEvent` inherits `UIEvent`.
 pub fn as_ui_event(event: PointerEvent) -> UIEvent {
   coerce(event)
 }
 
+/// `PointerEvent` inherits `Event`.
 pub fn as_event(event: PointerEvent) -> Event {
   coerce(event)
 }
diff --git a/redraw/src/redraw/event/touch.gleam b/redraw/src/redraw/event/touch.gleam
index 4af05ff..9e35b79 100644
--- a/redraw/src/redraw/event/touch.gleam
+++ b/redraw/src/redraw/event/touch.gleam
@@ -1,38 +1,71 @@
+//// To provide quality support for touch-based user interfaces, touch events
+//// offer the ability to interpret finger (or stylus) activity on touch screens
+//// or trackpads.
+////
+//// The touch events interfaces are relatively low-level APIs that can be used
+//// to support application-specific multi-touch interactions such as a
+//// two-finger gesture. A multi-touch interaction starts when a finger (or
+//// stylus) first touches the contact surface. Other fingers may subsequently
+//// touch the surface and optionally move across the touch surface. The
+//// interaction ends when the fingers are removed from the surface. During this
+//// interaction, an application receives touch events during the start, move,
+//// and end phases.
+////
+//// Touch events are similar to mouse events except they support simultaneous
+//// touches and at different locations on the touch surface. The `TouchEvent`
+//// interface encapsulates all of the touchpoints that are currently active.
+//// The [`Touch`](https://developer.mozilla.org/docs/Web/API/Touch)
+//// interface, which represents a single touchpoint, includes information such
+//// as the position of the touch point relative to the browser viewport.
+////
+//// [Documentation](https://developer.mozilla.org/docs/Web/API/Touch_events)
+
 import gleam/dynamic
 import redraw/event.{type Event}
 import redraw/event/ui.{type UIEvent}
 import redraw/internals/coerce.{coerce}
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/TouchEvent)
 pub type TouchEvent
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/TouchEvent/altKey)
 @external(javascript, "../../events.ffi.mjs", "altKey")
 pub fn alt_key(event: TouchEvent) -> Bool
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/TouchEvent/ctrlKey)
 @external(javascript, "../../events.ffi.mjs", "ctrlKey")
 pub fn ctrl_key(event: TouchEvent) -> Bool
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/TouchEvent/changedTouches)
 @external(javascript, "../../events.ffi.mjs", "changedTouches")
 pub fn changed_touches(event: TouchEvent) -> dynamic.Dynamic
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/TouchEvent/metaKey)
 @external(javascript, "../../events.ffi.mjs", "metaKey")
 pub fn meta_key(event: TouchEvent) -> Bool
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/TouchEvent/shiftKey)
 @external(javascript, "../../events.ffi.mjs", "shiftKey")
 pub fn shift_key(event: TouchEvent) -> Bool
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/TouchEvent/touches)
 @external(javascript, "../../events.ffi.mjs", "touches")
 pub fn touches(event: TouchEvent) -> dynamic.Dynamic
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/TouchEvent/targetTouches)
 @external(javascript, "../../events.ffi.mjs", "targetTouches")
 pub fn target_touches(event: TouchEvent) -> dynamic.Dynamic
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/TouchEvent/getModifierState)
 @external(javascript, "../../events.ffi.mjs", "getModifierState")
 pub fn get_modifier_state(event: TouchEvent, key: String) -> Bool
 
+/// `TouchEvent` inherits `UIEvent`.
 pub fn as_ui_event(event: TouchEvent) -> UIEvent {
   coerce(event)
 }
 
+/// `TouchEvent` inherits `Event`.
 pub fn as_event(event: TouchEvent) -> Event {
   coerce(event)
 }
diff --git a/redraw/src/redraw/event/transition.gleam b/redraw/src/redraw/event/transition.gleam
index 60e7aa5..ce201d0 100644
--- a/redraw/src/redraw/event/transition.gleam
+++ b/redraw/src/redraw/event/transition.gleam
@@ -1,17 +1,25 @@
+//// The `TransitionEvent` interface represents events providing information
+//// related to [transitions](https://developer.mozilla.org/docs/Web/CSS/CSS_transitions/Using_CSS_transitions).
+
 import redraw/event.{type Event}
 import redraw/internals/coerce.{coerce}
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/TransitionEvent)
 pub type TransitionEvent
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/TransitionEvent/elapsedTime)
 @external(javascript, "../../events.ffi.mjs", "elapsedTime")
 pub fn elapsed_time(event: TransitionEvent) -> Int
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/TransitionEvent/propertyName)
 @external(javascript, "../../events.ffi.mjs", "propertyName")
 pub fn property_name(event: TransitionEvent) -> String
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/TransitionEvent/pseudoElement)
 @external(javascript, "../../events.ffi.mjs", "pseudoElement")
 pub fn pseudo_element(event: TransitionEvent) -> String
 
+/// `TransitionEvent` inherits `Event`.
 pub fn as_event(event: TransitionEvent) -> Event {
   coerce(event)
 }
diff --git a/redraw/src/redraw/event/ui.gleam b/redraw/src/redraw/event/ui.gleam
index 684b3fd..878c64d 100644
--- a/redraw/src/redraw/event/ui.gleam
+++ b/redraw/src/redraw/event/ui.gleam
@@ -1,15 +1,21 @@
+//// The `UIEvent` interface represents simple user interface events.
+
 import gleam/dynamic
 import redraw/event.{type Event}
 import redraw/internals/coerce.{coerce}
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/UIEvent)
 pub type UIEvent
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/UIEvent/detail)
 @external(javascript, "../../events.ffi.mjs", "detail")
 pub fn detail(event: UIEvent) -> Int
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/UIEvent/view)
 @external(javascript, "../../events.ffi.mjs", "view")
 pub fn view(event: UIEvent) -> dynamic.Dynamic
 
+/// `UIEvent` inherits `Event`.
 pub fn as_event(event: UIEvent) -> Event {
   coerce(event)
 }
diff --git a/redraw/src/redraw/event/wheel.gleam b/redraw/src/redraw/event/wheel.gleam
index 4d62252..0e87461 100644
--- a/redraw/src/redraw/event/wheel.gleam
+++ b/redraw/src/redraw/event/wheel.gleam
@@ -1,30 +1,57 @@
+//// The `WheelEvent` interface represents events that occur due to the user
+//// moving a mouse wheel or similar input device.
+////
+//// > This is the standard wheel event interface to use. Old versions
+//// of browsers implemented the non-standard and non-cross-browser-compatible
+//// `MouseWheelEvent` and `MouseScrollEvent` interfaces. Use this interface and
+//// avoid the non-standard ones.
+////
+//// Don't confuse the wheel event with the [`scroll`](https://developer.mozilla.org/docs/Web/API/Element/scroll_event) event:
+//// - A `wheel` event doesn't necessarily dispatch a `scroll` event. For example,
+////   the element may be unscrollable at all. Zooming actions using the wheel
+////   or trackpad also fire `wheel` events.
+//// - A `scroll` event isn't necessarily triggered by a `wheel` event. Elements
+////   can also be scrolled by using the keyboard, dragging a scrollbar, or
+////   using JavaScript.
+//// - Even when the `wheel` event does trigger scrolling, the `delta*` values in
+////   the `wheel` event don't necessarily reflect the content's scrolling
+////   direction.
+
 import redraw/event.{type Event}
 import redraw/event/mouse.{type MouseEvent}
 import redraw/event/ui.{type UIEvent}
 import redraw/internals/coerce.{coerce}
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/WheelEvent)
 pub type WheelEvent
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/WheelEvent/deltaMode)
 @external(javascript, "../../events.ffi.mjs", "deltaMode")
 pub fn delta_mode(event: WheelEvent) -> Int
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/WheelEvent/deltaX)
 @external(javascript, "../../events.ffi.mjs", "deltaX")
 pub fn delta_x(event: WheelEvent) -> Float
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/WheelEvent/deltaY)
 @external(javascript, "../../events.ffi.mjs", "deltaY")
 pub fn delta_y(event: WheelEvent) -> Float
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/WheelEvent/deltaZ)
 @external(javascript, "../../events.ffi.mjs", "deltaZ")
 pub fn delta_z(event: WheelEvent) -> Float
 
+/// `WheelEvent` inherits `MouseEvent`.
 pub fn as_mouse_event(event: WheelEvent) -> MouseEvent {
   coerce(event)
 }
 
+/// `WheelEvent` inherits `UIEvent`.
 pub fn as_ui_event(event: WheelEvent) -> UIEvent {
   coerce(event)
 }
 
+/// `WheelEvent` inherits `Event`.
 pub fn as_event(event: WheelEvent) -> Event {
   coerce(event)
 }
diff --git a/redraw/src/redraw/handler.gleam b/redraw/src/redraw/handler.gleam
index 29b7148..2de5d7c 100644
--- a/redraw/src/redraw/handler.gleam
+++ b/redraw/src/redraw/handler.gleam
@@ -1,3 +1,12 @@
+//// Implementation for event listeners usable in React and in browser. \
+//// All of them can be found in the
+//// [React.dev](https://react.dev/reference/react-dom/components/common#common)
+//// documentation for detailed information, as well as on
+//// [MDN](https://developer.mozilla.org/docs/Web/API/Element).
+////
+//// Every event listener are defined as handlers, accepting an event, detailed
+//// in their documentation.
+
 import redraw/event.{type Event}
 import redraw/event/animation.{type AnimationEvent}
 import redraw/event/clipboard.{type ClipboardEvent}
@@ -13,610 +22,914 @@ import redraw/event/transition.{type TransitionEvent}
 import redraw/event/wheel.{type WheelEvent}
 import redraw/internals/attribute
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/animationend_event)
 pub fn on_animation_end(handler: fn(AnimationEvent) -> Nil) {
   attribute.attribute("onAnimationEnd", handler)
 }
 
+/// Alternative version of [`on_animation_end`](#on_animation_end) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/animationend_event)
 pub fn on_animation_end_capture(handler: fn(AnimationEvent) -> Nil) {
   attribute.attribute("onAnimationEndCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/animationiteration_event)
 pub fn on_animation_iteration(handler: fn(AnimationEvent) -> Nil) {
   attribute.attribute("onAnimationIteration", handler)
 }
 
+/// Alternative version of [`on_animation_iteration`](#on_animation_iteration) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/animationiteration_event)
 pub fn on_animation_iteration_capture(handler: fn(AnimationEvent) -> Nil) {
   attribute.attribute("onAnimationIterationCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/animationstart_event)
 pub fn on_animation_start(handler: fn(AnimationEvent) -> Nil) {
   attribute.attribute("onAnimationStart", handler)
 }
 
+/// Alternative version of [`on_animation_start`](#on_animation_start) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/animationstart_event)
 pub fn on_animation_start_capture(handler: fn(AnimationEvent) -> Nil) {
   attribute.attribute("onAnimationStartCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/auxclick_event)
 pub fn on_aux_click(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onAuxClick", handler)
 }
 
+/// Alternative version of [`on_aux_click`](#on_aux_click) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/auxclick_event)
 pub fn on_aux_click_capture(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onAuxClickCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/beforeinput_event)
 pub fn on_before_input(handler: fn(InputEvent) -> Nil) {
   attribute.attribute("onBeforeInput", handler)
 }
 
+/// Alternative version of [`on_before_input`](#on_before_input) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/beforeinput_event)
 pub fn on_before_input_capture(handler: fn(InputEvent) -> Nil) {
   attribute.attribute("onBeforeInputCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/blur_event)
 pub fn on_blur(handler: fn(FocusEvent) -> Nil) {
   attribute.attribute("onBlur", handler)
 }
 
+/// Alternative version of [`on_blur`](#on_blur) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/blur_event)
 pub fn on_blur_capture(handler: fn(FocusEvent) -> Nil) {
   attribute.attribute("onBlurCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/click_event)
 pub fn on_click(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onClick", handler)
 }
 
+/// Alternative version of [`on_click`](#on_click) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/click_event)
 pub fn on_click_capture(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onClickCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/compositionstart_event)
 pub fn on_composition_start(handler: fn(CompositionEvent) -> Nil) {
   attribute.attribute("onCompositionStart", handler)
 }
 
+/// Alternative version of [`on_composition_start`](#on_composition_start) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/compositionstart_event)
 pub fn on_composition_start_capture(handler: fn(CompositionEvent) -> Nil) {
   attribute.attribute("onCompositionStartCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/compositionend_event)
 pub fn on_composition_end(handler: fn(CompositionEvent) -> Nil) {
   attribute.attribute("onCompositionEnd", handler)
 }
 
+/// Alternative version of [`on_composition_end`](#on_composition_end) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/compositionend_event)
 pub fn on_composition_end_capture(handler: fn(CompositionEvent) -> Nil) {
   attribute.attribute("onCompositionEndCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/compositionupdate_event)
 pub fn on_composition_update(handler: fn(CompositionEvent) -> Nil) {
   attribute.attribute("onCompositionUpdate", handler)
 }
 
+/// Alternative version of [`on_composition_update`](#on_composition_update) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/compositionupdate_event)
 pub fn on_composition_update_capture(handler: fn(CompositionEvent) -> Nil) {
   attribute.attribute("onCompositionUpdateCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/context_event)
 pub fn on_context_menu(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onContextMenu", handler)
 }
 
+/// Alternative version of [`on_context_menu`](#on_context_menu) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/context_event)
 pub fn on_context_menu_capture(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onContextMenuCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/copy_event)
 pub fn on_copy(handler: fn(ClipboardEvent) -> Nil) {
   attribute.attribute("onCopy", handler)
 }
 
+/// Alternative version of [`on_copy`](#on_copy) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/copy_event)
 pub fn on_copy_capture(handler: fn(ClipboardEvent) -> Nil) {
   attribute.attribute("onCopyCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/cut_event)
 pub fn on_cut(handler: fn(ClipboardEvent) -> Nil) {
   attribute.attribute("onCut", handler)
 }
 
+/// Alternative version of [`on_cut`](#on_cut) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/cut_event)
 pub fn on_cut_capture(handler: fn(ClipboardEvent) -> Nil) {
   attribute.attribute("onCutCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/dblclick_event)
 pub fn on_double_click(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onDoubleClick", handler)
 }
 
+/// Alternative version of [`on_double_click`](#on_double_click) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/dblclick_event)
 pub fn on_double_click_capture(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onDoubleClickCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/drag_event)
 pub fn on_drag(handler: fn(DragEvent) -> Nil) {
   attribute.attribute("onDrag", handler)
 }
 
+/// Alternative version of [`on_drag`](#on_drag) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/drag_event)
 pub fn on_drag_capture(handler: fn(DragEvent) -> Nil) {
   attribute.attribute("onDragCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/dragend_event)
 pub fn on_drag_end(handler: fn(DragEvent) -> Nil) {
   attribute.attribute("onDragEnd", handler)
 }
 
+/// Alternative version of [`on_drag_end`](#on_drag_end) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/dragend_event)
 pub fn on_drag_end_capture(handler: fn(DragEvent) -> Nil) {
   attribute.attribute("onDragEndCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/dragenter_event)
 pub fn on_drag_enter(handler: fn(DragEvent) -> Nil) {
   attribute.attribute("onDragEnter", handler)
 }
 
+/// Alternative version of [`on_drag_enter`](#on_drag_enter) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/dragenter_event)
 pub fn on_drag_enter_capture(handler: fn(DragEvent) -> Nil) {
   attribute.attribute("onDragEnterCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/dragover_event)
 pub fn on_drag_over(handler: fn(DragEvent) -> Nil) {
   attribute.attribute("onDragOver", handler)
 }
 
+/// Alternative version of [`on_drag_over`](#on_drag_over) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/dragover_event)
 pub fn on_drag_over_capture(handler: fn(DragEvent) -> Nil) {
   attribute.attribute("onDragOverCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/dragstart_event)
 pub fn on_drag_start(handler: fn(DragEvent) -> Nil) {
   attribute.attribute("onDragStart", handler)
 }
 
+/// Alternative version of [`on_drag_start`](#on_drag_start) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/dragstart_event)
 pub fn on_drag_start_capture(handler: fn(DragEvent) -> Nil) {
   attribute.attribute("onDragStartCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/drop_event)
 pub fn on_drop(handler: fn(DragEvent) -> Nil) {
   attribute.attribute("onDrop", handler)
 }
 
+/// Alternative version of [`on_drop`](#on_drop) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/drop_event)
 pub fn on_drop_capture(handler: fn(DragEvent) -> Nil) {
   attribute.attribute("onDropCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/focus_event)
 pub fn on_focus(handler: fn(FocusEvent) -> Nil) {
   attribute.attribute("onFocus", handler)
 }
 
+/// Alternative version of [`on_focus`](#on_focus) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/focus_event)
 pub fn on_focus_capture(handler: fn(FocusEvent) -> Nil) {
   attribute.attribute("onFocusCapture", handler)
 }
 
+/// Alternative version of [`on_got_pointer`](#on_got_pointer) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/gotpointercapture_event)
 pub fn on_got_pointer_capture(handler: fn(PointerEvent) -> Nil) {
   attribute.attribute("onGotPointerCapture", handler)
 }
 
+/// Alternative version of [`on_got_pointer_capture`](#on_got_pointer_capture) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/gotpointercapture_event)
 pub fn on_got_pointer_capture_capture(handler: fn(PointerEvent) -> Nil) {
   attribute.attribute("onGotPointerCaptureCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/keydown_event)
 pub fn on_key_down(handler: fn(KeyboardEvent) -> Nil) {
   attribute.attribute("onKeyDown", handler)
 }
 
+/// Alternative version of [`on_key_down`](#on_key_down) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/keydown_event)
 pub fn on_key_down_capture(handler: fn(KeyboardEvent) -> Nil) {
   attribute.attribute("onKeyDownCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/keypress_event)
 pub fn on_key_press(handler: fn(KeyboardEvent) -> Nil) {
   attribute.attribute("onKeyPress", handler)
 }
 
+/// Alternative version of [`on_key_press`](#on_key_press) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/keypress_event)
 pub fn on_key_press_capture(handler: fn(KeyboardEvent) -> Nil) {
   attribute.attribute("onKeyPressCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/keyup_event)
 pub fn on_key_up(handler: fn(KeyboardEvent) -> Nil) {
   attribute.attribute("onKeyUp", handler)
 }
 
+/// Alternative version of [`on_key_up`](#on_key_up) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/keyup_event)
 pub fn on_key_up_capture(handler: fn(KeyboardEvent) -> Nil) {
   attribute.attribute("onKeyUpCapture", handler)
 }
 
+/// Alternative version of [`on_lost_pointer`](#on_lost_pointer) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/lostpointercapture_event)
 pub fn on_lost_pointer_capture(handler: fn(PointerEvent) -> Nil) {
   attribute.attribute("onLostPointerCapture", handler)
 }
 
+/// Alternative version of [`on_lost_pointer_capture`](#on_lost_pointer_capture) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/lostpointercapture_event)
 pub fn on_lost_pointer_capture_capture(handler: fn(PointerEvent) -> Nil) {
   attribute.attribute("onLostPointerCaptureCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/mousedown_event)
 pub fn on_mouse_down(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onMouseDown", handler)
 }
 
+/// Alternative version of [`on_mouse_down`](#on_mouse_down) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/mousedown_event)
 pub fn on_mouse_down_capture(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onMouseDownCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/mouseenter_event)
 pub fn on_mouse_enter(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onMouseEnter", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/mouseleave_event)
 pub fn on_mouse_leave(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onMouseLeave", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/mousemove_event)
 pub fn on_mouse_move(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onMouseMove", handler)
 }
 
+/// Alternative version of [`on_mouse_move`](#on_mouse_move) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/mousemove_event)
 pub fn on_mouse_move_capture(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onMouseMoveCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/mouseout_event)
 pub fn on_mouse_out(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onMouseOut", handler)
 }
 
+/// Alternative version of [`on_mouse_out`](#on_mouse_out) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/mouseout_event)
 pub fn on_mouse_out_capture(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onMouseOutCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/mouseup_event)
 pub fn on_mouse_up(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onMouseUp", handler)
 }
 
+/// Alternative version of [`on_mouse_up`](#on_mouse_up) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/mouseup_event)
 pub fn on_mouse_up_capture(handler: fn(MouseEvent) -> Nil) {
   attribute.attribute("onMouseUpCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/pointercancel_event)
 pub fn on_pointer_cancel(handler: fn(PointerEvent) -> Nil) {
   attribute.attribute("onPointerCancel", handler)
 }
 
+/// Alternative version of [`on_pointer_cancel`](#on_pointer_cancel) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/pointercancel_event)
 pub fn on_pointer_cancel_capture(handler: fn(PointerEvent) -> Nil) {
   attribute.attribute("onPointerCancelCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/pointerdown_event)
 pub fn on_pointer_down(handler: fn(PointerEvent) -> Nil) {
   attribute.attribute("onPointerDown", handler)
 }
 
+/// Alternative version of [`on_pointer_down`](#on_pointer_down) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/pointerdown_event)
 pub fn on_pointer_down_capture(handler: fn(PointerEvent) -> Nil) {
   attribute.attribute("onPointerDownCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/pointerenter_event)
 pub fn on_pointer_enter(handler: fn(PointerEvent) -> Nil) {
   attribute.attribute("onPointerEnter", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/pointerleave_event)
 pub fn on_pointer_leave(handler: fn(PointerEvent) -> Nil) {
   attribute.attribute("onPointerLeave", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/pointermove_event)
 pub fn on_pointer_move(handler: fn(PointerEvent) -> Nil) {
   attribute.attribute("onPointerMove", handler)
 }
 
+/// Alternative version of [`on_pointer_move`](#on_pointer_move) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/pointermove_event)
 pub fn on_pointer_move_capture(handler: fn(PointerEvent) -> Nil) {
   attribute.attribute("onPointerMoveCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/pointerout_event)
 pub fn on_pointer_out(handler: fn(PointerEvent) -> Nil) {
   attribute.attribute("onPointerOut", handler)
 }
 
+/// Alternative version of [`on_pointer_out`](#on_pointer_out) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/pointerout_event)
 pub fn on_pointer_out_capture(handler: fn(PointerEvent) -> Nil) {
   attribute.attribute("onPointerOutCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/pointerup_event)
 pub fn on_pointer_up(handler: fn(PointerEvent) -> Nil) {
   attribute.attribute("onPointerUp", handler)
 }
 
+/// Alternative version of [`on_pointer_up`](#on_pointer_up) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/pointerup_event)
 pub fn on_pointer_up_capture(handler: fn(PointerEvent) -> Nil) {
   attribute.attribute("onPointerUpCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/paste_event)
 pub fn on_paste(handler: fn(ClipboardEvent) -> Nil) {
   attribute.attribute("onPaste", handler)
 }
 
+/// Alternative version of [`on_paste`](#on_paste) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/paste_event)
 pub fn on_paste_capture(handler: fn(ClipboardEvent) -> Nil) {
   attribute.attribute("onPasteCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/scroll_event)
 pub fn on_scroll(handler: fn(Event) -> Nil) {
   attribute.attribute("onScroll", handler)
 }
 
+/// Alternative version of [`on_scroll`](#on_scroll) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/scroll_event)
 pub fn on_scroll_capture(handler: fn(Event) -> Nil) {
   attribute.attribute("onScrollCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/select_event)
 pub fn on_select(handler: fn(Event) -> Nil) {
   attribute.attribute("onSelect", handler)
 }
 
+/// Alternative version of [`on_select`](#on_select) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/select_event)
 pub fn on_select_capture(handler: fn(Event) -> Nil) {
   attribute.attribute("onSelectCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/touchcancel_event)
 pub fn on_touch_cancel(handler: fn(TouchEvent) -> Nil) {
   attribute.attribute("onTouchCancel", handler)
 }
 
+/// Alternative version of [`on_touch_cancel`](#on_touch_cancel) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/touchcancel_event)
 pub fn on_touch_cancel_capture(handler: fn(TouchEvent) -> Nil) {
   attribute.attribute("onTouchCancelCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/touchend_event)
 pub fn on_touch_end(handler: fn(TouchEvent) -> Nil) {
   attribute.attribute("onTouchEnd", handler)
 }
 
+/// Alternative version of [`on_touch_end`](#on_touch_end) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/touchend_event)
 pub fn on_touch_end_capture(handler: fn(TouchEvent) -> Nil) {
   attribute.attribute("onTouchEndCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/touchmove_event)
 pub fn on_touch_move(handler: fn(TouchEvent) -> Nil) {
   attribute.attribute("onTouchMove", handler)
 }
 
+/// Alternative version of [`on_touch_move`](#on_touch_move) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/touchmove_event)
 pub fn on_touch_move_capture(handler: fn(TouchEvent) -> Nil) {
   attribute.attribute("onTouchMoveCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/touchstart_event)
 pub fn on_touch_start(handler: fn(TouchEvent) -> Nil) {
   attribute.attribute("onTouchStart", handler)
 }
 
+/// Alternative version of [`on_touch_start`](#on_touch_start) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/touchstart_event)
 pub fn on_touch_start_capture(handler: fn(TouchEvent) -> Nil) {
   attribute.attribute("onTouchStartCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/transitionend_event)
 pub fn on_transition_end(handler: fn(TransitionEvent) -> Nil) {
   attribute.attribute("onTransitionEnd", handler)
 }
 
+/// Alternative version of [`on_transition_end`](#on_transition_end) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/transitionend_event)
 pub fn on_transition_end_capture(handler: fn(TransitionEvent) -> Nil) {
   attribute.attribute("onTransitionEndCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/wheel_event)
 pub fn on_wheel(handler: fn(WheelEvent) -> Nil) {
   attribute.attribute("onWheel", handler)
 }
 
+/// Alternative version of [`on_wheel`](#on_wheel) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/wheel_event)
 pub fn on_wheel_capture(handler: fn(WheelEvent) -> Nil) {
   attribute.attribute("onWheelCapture", handler)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/reset_event)
 pub fn on_reset(callback: fn(Event) -> Nil) {
   attribute.attribute("onReset", callback)
 }
 
+/// Alternative version of [`on_reset`](#on_reset) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/reset_event)
 pub fn on_reset_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onResetCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/submit_event)
 pub fn on_submit(callback: fn(Event) -> Nil) {
   attribute.attribute("onSubmit", callback)
 }
 
+/// Alternative version of [`on_submit`](#on_submit) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/submit_event)
 pub fn on_submit_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onSubmitCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/cancel_event)
 pub fn on_cancel(callback: fn(Event) -> Nil) {
   attribute.attribute("onCancel", callback)
 }
 
+/// Alternative version of [`on_cancel`](#on_cancel) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/cancel_event)
 pub fn on_cancel_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onCancelCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/close_event)
 pub fn on_close(callback: fn(Event) -> Nil) {
   attribute.attribute("onClose", callback)
 }
 
+/// Alternative version of [`on_close`](#on_close) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/close_event)
 pub fn on_close_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onCloseCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/toggle_event)
 pub fn on_toggle(callback: fn(Event) -> Nil) {
   attribute.attribute("onToggle", callback)
 }
 
+/// Alternative version of [`on_toggle`](#on_toggle) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/toggle_event)
 pub fn on_toggle_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onToggleCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/load_event)
 pub fn on_load(callback: fn(Event) -> Nil) {
   attribute.attribute("onLoad", callback)
 }
 
+/// Alternative version of [`on_load`](#on_load) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/load_event)
 pub fn on_load_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onLoadCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/error_event)
 pub fn on_error(callback: fn(Event) -> Nil) {
   attribute.attribute("onError", callback)
 }
 
+/// Alternative version of [`on_error`](#on_error) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/error_event)
 pub fn on_error_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onErrorCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/abort_event)
 pub fn on_abort(callback: fn(Event) -> Nil) {
   attribute.attribute("onAbort", callback)
 }
 
+/// Alternative version of [`on_abort`](#on_abort) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/abort_event)
 pub fn on_abort_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onAbortCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/canplay_event)
 pub fn on_can_play(callback: fn(Event) -> Nil) {
   attribute.attribute("onCanPlay", callback)
 }
 
+/// Alternative version of [`on_can_play`](#on_can_play) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/canplay_event)
 pub fn on_can_play_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onCanPlayCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/canplaythrough_event)
 pub fn on_can_play_through(callback: fn(Event) -> Nil) {
   attribute.attribute("onCanPlayThrough", callback)
 }
 
+/// Alternative version of [`on_can_play_through`](#on_can_play_through) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/canplaythrough_event)
 pub fn on_can_play_through_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onCanPlayThroughCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/durationchange_event)
 pub fn on_duration_change(callback: fn(Event) -> Nil) {
   attribute.attribute("onDurationChange", callback)
 }
 
+/// Alternative version of [`on_duration_change`](#on_duration_change) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/durationchange_event)
 pub fn on_duration_change_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onDurationChangeCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/emptied_event)
 pub fn on_emptied(callback: fn(Event) -> Nil) {
   attribute.attribute("onEmptied", callback)
 }
 
+/// Alternative version of [`on_emptied`](#on_emptied) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/emptied_event)
 pub fn on_emptied_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onEmptiedCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/encrypted_event)
 pub fn on_encrypted(callback: fn(Event) -> Nil) {
   attribute.attribute("onEncrypted", callback)
 }
 
+/// Alternative version of [`on_encrypted`](#on_encrypted) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/encrypted_event)
 pub fn on_encrypted_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onEncryptedCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/ended_event)
 pub fn on_ended(callback: fn(Event) -> Nil) {
   attribute.attribute("onEnded", callback)
 }
 
+/// Alternative version of [`on_ended`](#on_ended) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/ended_event)
 pub fn on_ended_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onEndedCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/loadeddata_event)
 pub fn on_loaded_data(callback: fn(Event) -> Nil) {
   attribute.attribute("onLoadedData", callback)
 }
 
+/// Alternative version of [`on_loaded_data`](#on_loaded_data) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/loadeddata_event)
 pub fn on_loaded_data_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onLoadedDataCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/loadedmetadata_event)
 pub fn on_loaded_metadata(callback: fn(Event) -> Nil) {
   attribute.attribute("onLoadedMetadata", callback)
 }
 
+/// Alternative version of [`on_loaded_metadata`](#on_loaded_metadata) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/loadedmetadata_event)
 pub fn on_loaded_metadata_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onLoadedMetadataCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/loadstart_event)
 pub fn on_load_start(callback: fn(Event) -> Nil) {
   attribute.attribute("onLoadStart", callback)
 }
 
+/// Alternative version of [`on_load_start`](#on_load_start) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/loadstart_event)
 pub fn on_load_start_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onLoadStartCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/pause_event)
 pub fn on_pause(callback: fn(Event) -> Nil) {
   attribute.attribute("onPause", callback)
 }
 
+/// Alternative version of [`on_pause`](#on_pause) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/pause_event)
 pub fn on_pause_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onPauseCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/play_event)
 pub fn on_play(callback: fn(Event) -> Nil) {
   attribute.attribute("onPlay", callback)
 }
 
+/// Alternative version of [`on_play`](#on_play) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/play_event)
 pub fn on_play_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onPlayCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/playing_event)
 pub fn on_playing(callback: fn(Event) -> Nil) {
   attribute.attribute("onPlaying", callback)
 }
 
+/// Alternative version of [`on_playing`](#on_playing) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/playing_event)
 pub fn on_playing_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onPlayingCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/progress_event)
 pub fn on_progress(callback: fn(Event) -> Nil) {
   attribute.attribute("onProgress", callback)
 }
 
+/// Alternative version of [`on_progress`](#on_progress) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/progress_event)
 pub fn on_progress_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onProgressCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/ratechange_event)
 pub fn on_rate_change(callback: fn(Event) -> Nil) {
   attribute.attribute("onRateChange", callback)
 }
 
+/// Alternative version of [`on_rate_change`](#on_rate_change) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/ratechange_event)
 pub fn on_rate_change_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onRateChangeCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/resize_event)
 pub fn on_resize(callback: fn(Event) -> Nil) {
   attribute.attribute("onResize", callback)
 }
 
+/// Alternative version of [`on_resize`](#on_resize) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/resize_event)
 pub fn on_resize_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onResizeCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/seeked_event)
 pub fn on_seeked(callback: fn(Event) -> Nil) {
   attribute.attribute("onSeeked", callback)
 }
 
+/// Alternative version of [`on_seeked`](#on_seeked) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/seeked_event)
 pub fn on_seeked_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onSeekedCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/seeking_event)
 pub fn on_seeking(callback: fn(Event) -> Nil) {
   attribute.attribute("onSeeking", callback)
 }
 
+/// Alternative version of [`on_seeking`](#on_seeking) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/seeking_event)
 pub fn on_seeking_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onSeekingCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/stalled_event)
 pub fn on_stalled(callback: fn(Event) -> Nil) {
   attribute.attribute("onStalled", callback)
 }
 
+/// Alternative version of [`on_stalled`](#on_stalled) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/stalled_event)
 pub fn on_stalled_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onStalledCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/suspend_event)
 pub fn on_suspend(callback: fn(Event) -> Nil) {
   attribute.attribute("onSuspend", callback)
 }
 
+/// Alternative version of [`on_suspend`](#on_suspend) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/suspend_event)
 pub fn on_suspend_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onSuspendCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/timeupdate_event)
 pub fn on_time_update(callback: fn(Event) -> Nil) {
   attribute.attribute("onTimeUpdate", callback)
 }
 
+/// Alternative version of [`on_time_update`](#on_time_update) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/timeupdate_event)
 pub fn on_time_update_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onTimeUpdateCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/volumechange_event)
 pub fn on_volume_change(callback: fn(Event) -> Nil) {
   attribute.attribute("onVolumeChange", callback)
 }
 
+/// Alternative version of [`on_volume_change`](#on_volume_change) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/volumechange_event)
 pub fn on_volume_change_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onVolumeChangeCapture", callback)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/waiting_event)
 pub fn on_waiting(callback: fn(Event) -> Nil) {
   attribute.attribute("onWaiting", callback)
 }
 
+/// Alternative version of [`on_waiting`](#on_waiting) that runs during
+/// [capture phase](https://react.dev/learn/responding-to-events#capture-phase-events). \
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Element/waiting_event)
 pub fn on_waiting_capture(callback: fn(Event) -> Nil) {
   attribute.attribute("onWaitingCapture", callback)
 }
diff --git a/redraw/src/redraw/html.gleam b/redraw/src/redraw/html.gleam
index e66820b..3ebe58f 100644
--- a/redraw/src/redraw/html.gleam
+++ b/redraw/src/redraw/html.gleam
@@ -1,566 +1,687 @@
+//// All built-in browser components, such as `<div>`, `<span>`, etc. support
+//// common props and events. \
+//// To stay compatible with the Lustre API, Redraw defines the entire set of
+//// HTML elements. They're instantiated with JSX under-the-hood, and requires
+//// a modern runtime to get them working.
+////
+//// [Find detailed documentation on MDN](https://developer.mozilla.org/docs/Web/HTML/Element).
+
 import redraw.{type Component}
 import redraw/internals/attribute.{to_props}
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/html)
 pub fn html(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("html", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/link)
 pub fn link(attrs) {
   let attrs = to_props(attrs)
   redraw.jsx("link", attrs, Nil)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/meta)
 pub fn meta(attrs) {
   let attrs = to_props(attrs)
   redraw.jsx("meta", attrs, Nil)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/script)
 pub fn script(attrs) {
   let attrs = to_props(attrs)
   redraw.jsx("script", attrs, Nil)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/style)
 pub fn style(attrs, content) {
   let attrs = to_props(attrs)
   redraw.jsx("style", attrs, [text(content)])
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/title)
 pub fn title(attrs, content) {
   let attrs = to_props(attrs)
   redraw.jsx("title", attrs, [text(content)])
 }
 
+/// Empty node. Does not render anything in the DOM.
 pub fn none() {
   redraw.jsx("none_", Nil, Nil)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/API/Text)
 pub fn text(content: String) -> Component {
   redraw.jsx("text_", Nil, content)
 }
 
 // DOM nodes
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/a)
 pub fn a(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("a", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/abbr)
 pub fn abbr(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("abbr", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/address)
 pub fn address(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("address", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/area)
 pub fn area(attrs) -> Component {
   let attrs = to_props(attrs)
   redraw.jsx("area", attrs, Nil)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/article)
 pub fn article(attrs, children: List(Component)) -> Component {
   let attrs = to_props(attrs)
   redraw.jsx("article", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/aside)
 pub fn aside(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("aside", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/audio)
 pub fn audio(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("audio", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/b)
 pub fn b(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("b", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/base)
 pub fn base(attrs) {
   let attrs = to_props(attrs)
   redraw.jsx("base", attrs, Nil)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/bdi)
 pub fn bdi(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("bdi", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/bdo)
 pub fn bdo(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("bdo", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/blockquote)
 pub fn blockquote(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("blockquote", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/body)
 pub fn body(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("body", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/br)
 pub fn br(attrs) {
   let attrs = to_props(attrs)
   redraw.jsx("br", attrs, Nil)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/button)
 pub fn button(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("button", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/canvas)
 pub fn canvas(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("canvas", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/caption)
 pub fn caption(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("caption", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/cite)
 pub fn cite(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("cite", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/code)
 pub fn code(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("code", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/col)
 pub fn col(attrs) {
   let attrs = to_props(attrs)
   redraw.jsx("col", attrs, Nil)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/colgroup)
 pub fn colgroup(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("colgroup", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/data)
 pub fn data(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("data", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/datalist)
 pub fn datalist(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("datalist", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/dd)
 pub fn dd(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("dd", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/del)
 pub fn del(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("del", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/details)
 pub fn details(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("details", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/dfn)
 pub fn dfn(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("dfn", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/dialog)
 pub fn dialog(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("dialog", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/div)
 pub fn div(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("div", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/dl)
 pub fn dl(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("dl", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/dt)
 pub fn dt(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("dt", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/em)
 pub fn em(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("em", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/embed)
 pub fn embed(attrs) {
   let attrs = to_props(attrs)
   redraw.jsx("embed", attrs, Nil)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/fieldset)
 pub fn fieldset(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("fieldset", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/figcaption)
 pub fn figcaption(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("figcaption", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/figure)
 pub fn figure(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("figure", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/footer)
 pub fn footer(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("footer", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/form)
 pub fn form(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("form", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/h1)
 pub fn h1(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("h1", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/h2)
 pub fn h2(attrs, children) -> Component {
   let attrs = to_props(attrs)
   redraw.jsx("h2", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/h3)
 pub fn h3(attrs, children) -> Component {
   let attrs = to_props(attrs)
   redraw.jsx("h3", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/h4)
 pub fn h4(attrs, children) -> Component {
   let attrs = to_props(attrs)
   redraw.jsx("h4", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/h5)
 pub fn h5(attrs, children) -> Component {
   let attrs = to_props(attrs)
   redraw.jsx("h5", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/h6)
 pub fn h6(attrs, children) -> Component {
   let attrs = to_props(attrs)
   redraw.jsx("h6", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/head)
 pub fn head(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("head", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/header)
 pub fn header(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("header", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/hgroup)
 pub fn hgroup(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("hgroup", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/hr)
 pub fn hr(attrs) {
   let attrs = to_props(attrs)
   redraw.jsx("hr", attrs, Nil)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/i)
 pub fn i(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("i", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/iframe)
 pub fn iframe(attrs) {
   let attrs = to_props(attrs)
   redraw.jsx("iframe", attrs, Nil)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/img)
 pub fn img(attrs) {
   let attrs = to_props(attrs)
   redraw.jsx("img", attrs, Nil)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/input)
 pub fn input(attrs) {
   let attrs = to_props(attrs)
   redraw.jsx("input", attrs, Nil)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/ins)
 pub fn ins(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("ins", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/kbd)
 pub fn kbd(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("kbd", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/label)
 pub fn label(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("label", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/legend)
 pub fn legend(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("legend", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/li)
 pub fn li(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("li", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/main)
 pub fn main(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("main", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/map)
 pub fn map(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("map", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/mark)
 pub fn mark(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("mark", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/menu)
 pub fn menu(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("menu", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/meter)
 pub fn meter(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("meter", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/nav)
 pub fn nav(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("nav", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/noscript)
 pub fn noscript(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("noscript", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/object)
 pub fn object(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("object", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/ol)
 pub fn ol(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("ol", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/optgroup)
 pub fn optgroup(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("optgroup", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/option)
 pub fn option(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("option", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/output)
 pub fn output(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("output", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/p)
 pub fn p(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("p", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/picture)
 pub fn picture(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("picture", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/pre)
 pub fn pre(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("pre", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/progress)
 pub fn progress(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("progress", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/q)
 pub fn q(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("q", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/rp)
 pub fn rp(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("rp", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/rt)
 pub fn rt(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("rt", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/ruby)
 pub fn ruby(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("ruby", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/s)
 pub fn s(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("s", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/samp)
 pub fn samp(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("samp", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/section)
 pub fn section(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("section", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/select)
 pub fn select(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("select", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/slot)
 pub fn slot(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("slot", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/small)
 pub fn small(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("small", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/source)
 pub fn source(attrs) {
   let attrs = to_props(attrs)
   redraw.jsx("source", attrs, Nil)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/span)
 pub fn span(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("span", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/strong)
 pub fn strong(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("strong", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/sub)
 pub fn sub(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("sub", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/summary)
 pub fn summary(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("summary", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/sup)
 pub fn sup(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("sup", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/table)
 pub fn table(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("table", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/tbody)
 pub fn tbody(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("tbody", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/td)
 pub fn td(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("td", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/template)
 pub fn template(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("template", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/textarea)
 pub fn textarea(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("textarea", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/tfoot)
 pub fn tfoot(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("tfoot", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/th)
 pub fn th(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("th", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/thead)
 pub fn thead(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("thead", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/time)
 pub fn time(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("time", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/tr)
 pub fn tr(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("tr", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/track)
 pub fn track(attrs) {
   let attrs = to_props(attrs)
   redraw.jsx("track", attrs, Nil)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/u)
 pub fn u(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("u", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/ul)
 pub fn ul(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("ul", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/var)
 pub fn var(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("var", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/video)
 pub fn video(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("video", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/HTML/Element/wbr)
 pub fn wbr(attrs) {
   let attrs = to_props(attrs)
   redraw.jsx("wbr", attrs, Nil)
diff --git a/redraw/src/redraw/internals/attribute.gleam b/redraw/src/redraw/internals/attribute.gleam
index 413fb19..95c350b 100644
--- a/redraw/src/redraw/internals/attribute.gleam
+++ b/redraw/src/redraw/internals/attribute.gleam
@@ -5,6 +5,7 @@ pub type Attribute {
 }
 
 @external(javascript, "../../redraw.ffi.mjs", "toProps")
+@internal
 pub fn to_props(attrs: List(Attribute)) -> a
 
 pub fn attribute(key: String, content: a) {
diff --git a/redraw/src/redraw/svg.gleam b/redraw/src/redraw/svg.gleam
index 1919d3a..eecf886 100644
--- a/redraw/src/redraw/svg.gleam
+++ b/redraw/src/redraw/svg.gleam
@@ -1,331 +1,405 @@
+//// All built-in browser components, such as `<svg>`, `<g>`, etc. support
+//// common props and events. \
+//// To stay compatible with the Lustre API, Redraw defines the entire set of
+//// SVG elements. They're instantiated with JSX under-the-hood, and requires
+//// a modern runtime to get them working.
+////
+//// [Find detailed documentation on MDN](https://developer.mozilla.org/docs/Web/SVG/Element).
+
 import redraw.{type Component}
 import redraw/internals/attribute.{to_props}
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/a)
 pub fn a(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("a", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/animate)
 pub fn animate(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("animate", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/animateMotion)
 pub fn animate_motion(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("animateMotion", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/animateTransform)
 pub fn animate_transform(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("animateTransform", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/circle)
 pub fn circle(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("circle", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/clipPath)
 pub fn clip_path(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("clipPath", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/defs)
 pub fn defs(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("defs", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/desc)
 pub fn desc(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("desc", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/discard)
 pub fn discard(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("discard", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/ellipse)
 pub fn ellipse(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("ellipse", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feBlend)
 pub fn fe_blend(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feBlend", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feColorMatrix)
 pub fn fe_color_matrix(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feColorMatrix", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feComponentTransfer)
 pub fn fe_component_transfer(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feComponentTransfer", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feComposite)
 pub fn fe_composite(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feComposite", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feConvolveMatrix)
 pub fn fe_convolve_matrix(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feConvolveMatrix", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feDiffuseLighting)
 pub fn fe_diffuse_lighting(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feDiffuseLighting", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feDisplacementMap)
 pub fn fe_displacement_map(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feDisplacementMap", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feDistantLight)
 pub fn fe_distant_light(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feDistantLight", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feDropShadow)
 pub fn fe_drop_shadow(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feDropShadow", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feFlood)
 pub fn fe_flood(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feFlood", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feFuncA)
 pub fn fe_func_a(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feFuncA", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feFuncB)
 pub fn fe_func_b(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feFuncB", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feFuncG)
 pub fn fe_func_g(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feFuncG", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feFuncR)
 pub fn fe_func_r(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feFuncR", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feGaussianBlur)
 pub fn fe_gaussian_blur(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feGaussianBlur", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feImage)
 pub fn fe_image(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feImage", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feMerge)
 pub fn fe_merge(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feMerge", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feMergeNode)
 pub fn fe_merge_node(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feMergeNode", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feMorphology)
 pub fn fe_morphology(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feMorphology", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feOffset)
 pub fn fe_offset(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feOffset", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/fePointLight)
 pub fn fe_point_light(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("fePointLight", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feSpecularLighting)
 pub fn fe_specular_lighting(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feSpecularLighting", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feSpotLight)
 pub fn fe_spot_light(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feSpotLight", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feTile)
 pub fn fe_tile(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feTile", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/feTurbulence)
 pub fn fe_turbulence(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("feTurbulence", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/filter)
 pub fn filter(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("filter", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/foreignObject)
 pub fn foreign_object(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("foreignObject", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/g)
 pub fn g(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("g", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/hatch)
 pub fn hatch(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("hatch", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/hatchpath)
 pub fn hatchpath(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("hatchpath", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/image)
 pub fn image(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("image", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/line)
 pub fn line(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("line", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/linearGradient)
 pub fn linear_gradient(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("linearGradient", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/marker)
 pub fn marker(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("marker", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/mask)
 pub fn mask(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("mask", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/metadata)
 pub fn metadata(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("metadata", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/mpath)
 pub fn mpath(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("mpath", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/path)
 pub fn path(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("path", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/pattern)
 pub fn pattern(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("pattern", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/polygon)
 pub fn polygon(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("polygon", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/polyline)
 pub fn polyline(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("polyline", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/radialGradient)
 pub fn radial_gradient(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("radialGradient", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/rect)
 pub fn rect(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("rect", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/script)
 pub fn script(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("script", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/set)
 pub fn set(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("set", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/stop)
 pub fn stop(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("stop", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/style)
 pub fn style(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("style", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/svg)
 pub fn svg(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("svg", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/switch)
 pub fn switch(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("switch", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/symbol)
 pub fn symbol(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("symbol", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/text)
 pub fn text(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("text", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/textPath)
 pub fn text_path(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("textPath", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/title)
 pub fn title(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("title", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/tspan)
 pub fn tspan(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("tspan", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/use)
 pub fn use_(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("use", attrs, children)
 }
 
+/// [Documentation](https://developer.mozilla.org/docs/Web/SVG/Element/view)
 pub fn view(attrs, children: List(Component)) {
   let attrs = to_props(attrs)
   redraw.jsx("view", attrs, children)