# Module Dom

    module Dom: sig .. end

DOM binding

This is a partial binding to the DOM Core API.

## DOM objects

    class type ['node] nodeList = object .. end

Specification of `NodeList` objects.

    type nodeType =

`|` | `OTHER`
`|` | `ELEMENT`
`|` | `ATTRIBUTE`
`|` | `TEXT`
`|` | `CDATA_SECTION`
`|` | `ENTITY_REFERENCE`
`|` | `ENTITY`
`|` | `PROCESSING_INSTRUCTION`
`|` | `COMMENT`
`|` | `DOCUMENT`
`|` | `DOCUMENT_TYPE`
`|` | `DOCUMENT_FRAGMENT`
`|` | `NOTATION`

    val document_position_disconnected : int

    val document_position_preceding : int

    val document_position_following : int

    val document_position_contains : int

    val document_position_contained_by : int

    val document_position_implementation_specific : int

    class type node = object .. end

Specification of `Node` objects.

    class type attr = object .. end

Specification of `Attr` objects.

    class type [attr] namedNodeMap = object .. end

Specification of `NamedNodeMap` objects.

    class type element = object .. end

Specification of `Element` objects.

    class type characterData = object .. end

Specification of `CharacterData` objects.

    class type text = characterData

Specification of `Text` objects.

    class type documentFragment = node

Specification of `DocumentFragment` objects.

    class type ['element] document = object .. end

Specification of `Document` objects.

## Helper functions

    val insertBefore : #node Js.t -> #node Js.t -> #node Js.t Js.opt -> unit

`insertBefore p n c` inserts node `n` as child of node `p`, just before node `c`, or as last child if `p` is empty. The expression `insertBefore n c p` behave the same as `p##insertBefore(n, c)` but avoid the need of coercing the different objects to `node t`.

    val replaceChild : #node Js.t -> #node Js.t -> #node Js.t -> unit

The expression `replaceChild p n c` behave the same as `p##replaceChild(n, c)` (replace `c` by `n` in `p`) but avoid the need of coercing the different objects to `node t`.

    val removeChild : #node Js.t -> #node Js.t -> unit

The expression `removeChild n c` behave the same as `n##removeChild(c)` (remove `c` from `n`) but avoid the need of coercing the different objects to `node t`.

    val appendChild : #node Js.t -> #node Js.t -> unit

The expression `appendChild n c` behave the same as `n##appendChild(c)` (appends `c` to `n`) but avoid the need of coercing the different objects to `node t`.

    val list_of_nodeList : 'a nodeList Js.t -> 'a Js.t list

    type node_type =

`|` | `Element of `element Js.t``
`|` | `Attr of `attr Js.t``
`|` | `Text of `text Js.t``
`|` | `Other of `node Js.t``

    val nodeType : #node Js.t -> node_type

    module CoerceTo: sig .. end

## Events

    type (-'a, -'b) event_listener

The type of event listener functions. The first type parameter `'a` is the type of the target object; the second parameter `'b` is the type of the event object.

    class type ['a] event = object .. end

## Event handlers

    val no_handler : ('a, 'b) event_listener

Void event handler (Javascript `null` value).

    val handler : (('e #event as 'b) Js.t -> bool Js.t) -> ('a, 'b Js.t) event_listener

Create an event handler that invokes the provided function. If the handler returns false, the default action is prevented.

    val full_handler : ('a -> ('e #event as 'b) Js.t -> bool Js.t) ->
           ('a, 'b Js.t) event_listener

Create an event handler that invokes the provided function. The event target (implicit parameter `this`) is also passed as argument to the function.

    val invoke_handler : ('a, 'b) event_listener -> 'a -> 'b -> bool Js.t

Invoke an existing handler. Useful to chain event handlers.

    val eventTarget : (< .. > as 'a) #event Js.t -> 'a Js.t

Returns which object is the target of this event.

    type event_listener_id

    module Event: sig .. end

    val addEventListener : (< .. > as 'a) Js.t ->
           'b Event.typ ->
           ('a Js.t, 'b) event_listener -> bool Js.t -> event_listener_id

Add an event listener. This function matches the `addEventListener` DOM method, except that it returns an id for removing the listener.

    val removeEventListener : event_listener_id -> unit

Remove the given event listener.

    val preventDefault : 'a #event Js.t -> unit

Call this to prevent the default handler for the event. To stop propagation of the event, call `Dom_html.stopPropagation`.

## Other DOM objects

    class type stringList = object .. end