Up

module Html5_sigs

: sig
#
module type T = sig
#
module Xml : Xml_sigs.Wrapped
#
module Svg : Svg_sigs.T with module Xml := Xml
#
module Info : Xml_sigs.Info
#
type 'a wrap
#
type 'a list_wrap
#
type uri = Xml.uri
#
val string_of_uri : uri -> string
#
val uri_of_string : string -> uri

Common Attributes

#
type +'a attrib
#
val to_xmlattribs : 'a attrib list -> Xml.attrib list
#
val to_attrib : Xml.attrib -> 'a attrib

'a is known as a phantom type. The implementation is actually monomorphic (the different element types are distinguished by a homogeneous variable, such as their textual representation) and the type variable `a is just used by the type checker.

NB: It might be possible to use polymorphic variants directly, without phantom types, but the implementation is likely to be more involved.

#
val a_autocomplete : [<
| `On
| `Off
] wrap -> [>
| `Autocomplete
] attrib
#
val a_async : [<
| `Async
] wrap -> [>
| `Async
] attrib
#
val a_autofocus : [<
| `Autofocus
] wrap -> [>
| `Autofocus
] attrib
#
val a_autoplay : [<
| `Autoplay
] wrap -> [>
| `Autoplay
] attrib
#
val a_muted : [<
| `Muted
] wrap -> [>
| `Muted
] attrib
#
val a_crossorigin : [<
| `Anonymous
| `Use_credentials
] wrap -> [>
| `Crossorigin
] attrib
#
val a_mediagroup : string wrap -> [>
| `Mediagroup
] attrib
#
val a_challenge : Html5_types.text wrap -> [>
| `Challenge
] attrib
#
val a_contenteditable : bool wrap -> [>
| `Contenteditable
] attrib
#
val a_contextmenu : Html5_types.idref wrap -> [>
| `Contextmenu
] attrib
#
val a_controls : [<
| `Controls
] wrap -> [>
| `Controls
] attrib
#
val a_dir : [<
| `Rtl
| `Ltr
] wrap -> [>
| `Dir
] attrib
#
val a_draggable : bool wrap -> [>
| `Draggable
] attrib
#
val a_form : Html5_types.idref wrap -> [>
| `Form
] attrib
#
val a_formaction : Xml.uri wrap -> [>
| `Formaction
] attrib
#
val a_formenctype : Html5_types.contenttype wrap -> [>
| `Formenctype
] attrib
#
val a_formmethod : [<
| `Get
| `Post
| `Put
| `Delete
] wrap -> [>
| `Formmethod
] attrib
#
val a_formnovalidate : [<
| `Formnovalidate
] wrap -> [>
| `Formnovalidate
] attrib
#
val a_formtarget : Html5_types.text wrap -> [>
| `Formtarget
] attrib
#
val a_hidden : [<
| `Hidden
] wrap -> [>
| `Hidden
] attrib
#
val a_high : Html5_types.float_number wrap -> [>
| `High
] attrib
#
val a_icon : Xml.uri wrap -> [>
| `Icon
] attrib
#
val a_ismap : [<
| `Ismap
] wrap -> [>
| `Ismap
] attrib
#
val a_keytype : Html5_types.text wrap -> [>
| `Keytype
] attrib
#
val a_list : Html5_types.idref wrap -> [>
| `List
] attrib
#
val a_loop : [<
| `Loop
] wrap -> [>
| `Loop
] attrib
#
val a_low : Html5_types.float_number wrap -> [>
| `High
] attrib
#
val a_max : Html5_types.float_number wrap -> [>
| `Max
] attrib
#
val a_input_max : Html5_types.float_number wrap -> [>
| `Input_Max
] attrib
#
val a_min : Html5_types.float_number wrap -> [>
| `Min
] attrib
#
val a_input_min : Html5_types.float_number wrap -> [>
| `Input_Min
] attrib
#
val a_novalidate : [<
| `Novalidate
] wrap -> [>
| `Novalidate
] attrib
#
val a_open : [<
| `Open
] wrap -> [>
| `Open
] attrib
#
val a_optimum : Html5_types.float_number wrap -> [>
| `Optimum
] attrib
#
val a_pattern : Html5_types.text wrap -> [>
| `Pattern
] attrib
#
val a_placeholder : Html5_types.text wrap -> [>
| `Placeholder
] attrib
#
val a_poster : Xml.uri wrap -> [>
| `Poster
] attrib
#
val a_preload : [<
| `None
| `Metadata
| `Audio
] wrap -> [>
| `Preload
] attrib
#
val a_pubdate : [<
| `Pubdate
] wrap -> [>
| `Pubdate
] attrib
#
val a_radiogroup : Html5_types.text wrap -> [>
| `Radiogroup
] attrib
#
val a_required : [<
| `Required
] wrap -> [>
| `Required
] attrib
#
val a_reversed : [<
| `Reversed
] wrap -> [>
| `Reversed
] attrib
#
val a_sandbox : [<
| `AllowSameOrigin
| `AllowForms
| `AllowScript
| `AllowPointerLock
| `AllowPopups
| `AllowTopNavigation
] list wrap -> [>
| `Sandbox
] attrib
#
val a_spellcheck : bool wrap -> [>
| `Spellcheck
] attrib
#
val a_scoped : [<
| `Scoped
] wrap -> [>
| `Scoped
] attrib
#
val a_seamless : [<
| `Seamless
] wrap -> [>
| `Seamless
] attrib
#
val a_sizes : [<
| `Sizes of (Html5_types.number * Html5_types.number) list
| `Any
] wrap -> [>
| `Sizes
] attrib
#
val a_span : Html5_types.number wrap -> [>
| `Span
] attrib
#
val a_srclang : Html5_types.nmtoken wrap -> [>
| `XML_lang
] attrib

This attribute is deprecated, you should use a_xml_lang.

#
val a_start : Html5_types.number wrap -> [>
| `Start
] attrib
#
val a_step : Html5_types.float_number option wrap -> [>
| `Step
] attrib
#
val a_wrap : [<
| `Soft
| `Hard
] wrap -> [>
| `Wrap
] attrib
#
val a_class : Html5_types.nmtokens wrap -> [>
| `Class
] attrib

This attribute assigns a class name or set of class names to an element. Any number of elements may be assigned the same class name or names.

#
val a_user_data : Html5_types.nmtoken -> Html5_types.text wrap -> [>
| `User_data
] attrib

May be used to specify custom attribs. The example given by the W3C is as follows : 

<ol>
      <li data-length="2m11s">Beyond The Sea</li>
      </ol>

It should be used for preprocessing ends only.

#
val a_id : Html5_types.text wrap -> [>
| `Id
] attrib

This attribute assigns a name to an element. This name must be unique in a document. The text should be without any space.

#
val a_title : Html5_types.text wrap -> [>
| `Title
] attrib

This attribute offers advisory information about the element for which it is set.

Values of the title attribute may be rendered by user agents in a variety of ways. For instance, visual browsers frequently display the title as a tool tip (a short message that appears when the pointing device pauses over an object). Audio user agents may speak the title information in a similar context.

The title attribute has an additional role when used with the link element to designate an external style sheet. Please consult the section on links and style sheets for details.

I18N

#
val a_xml_lang : Html5_types.languagecode wrap -> [>
| `XML_lang
] attrib
#
val a_lang : Html5_types.languagecode wrap -> [>
| `Lang
] attrib

Events

#
val a_onabort : Xml.event_handler -> [>
| `OnAbort
] attrib

Javascript events

#
val a_onafterprint : Xml.event_handler -> [>
| `OnAfterPrint
] attrib
#
val a_onbeforeprint : Xml.event_handler -> [>
| `OnBeforePrint
] attrib
#
val a_onbeforeunload : Xml.event_handler -> [>
| `OnBeforeUnload
] attrib
#
val a_onblur : Xml.event_handler -> [>
| `OnBlur
] attrib
#
val a_oncanplay : Xml.event_handler -> [>
| `OnCanPlay
] attrib
#
val a_oncanplaythrough : Xml.event_handler -> [>
| `OnCanPlayThrough
] attrib
#
val a_onchange : Xml.event_handler -> [>
| `OnChange
] attrib
#
val a_ondurationchange : Xml.event_handler -> [>
| `OnDurationChange
] attrib
#
val a_onemptied : Xml.event_handler -> [>
| `OnEmptied
] attrib
#
val a_onended : Xml.event_handler -> [>
| `OnEnded
] attrib
#
val a_onerror : Xml.event_handler -> [>
| `OnError
] attrib
#
val a_onfocus : Xml.event_handler -> [>
| `OnFocus
] attrib
#
val a_onformchange : Xml.event_handler -> [>
| `OnFormChange
] attrib
#
val a_onforminput : Xml.event_handler -> [>
| `OnFormInput
] attrib
#
val a_onhashchange : Xml.event_handler -> [>
| `OnHashChange
] attrib
#
val a_oninput : Xml.event_handler -> [>
| `OnInput
] attrib
#
val a_oninvalid : Xml.event_handler -> [>
| `OnInvalid
] attrib
#
val a_onmousewheel : Xml.event_handler -> [>
| `OnMouseWheel
] attrib
#
val a_onoffline : Xml.event_handler -> [>
| `OnOffLine
] attrib
#
val a_ononline : Xml.event_handler -> [>
| `OnOnLine
] attrib
#
val a_onpause : Xml.event_handler -> [>
| `OnPause
] attrib
#
val a_onplay : Xml.event_handler -> [>
| `OnPlay
] attrib
#
val a_onplaying : Xml.event_handler -> [>
| `OnPlaying
] attrib
#
val a_onpagehide : Xml.event_handler -> [>
| `OnPageHide
] attrib
#
val a_onpageshow : Xml.event_handler -> [>
| `OnPageShow
] attrib
#
val a_onpopstate : Xml.event_handler -> [>
| `OnPopState
] attrib
#
val a_onprogress : Xml.event_handler -> [>
| `OnProgress
] attrib
#
val a_onratechange : Xml.event_handler -> [>
| `OnRateChange
] attrib
#
val a_onreadystatechange : Xml.event_handler -> [>
| `OnReadyStateChange
] attrib
#
val a_onredo : Xml.event_handler -> [>
| `OnRedo
] attrib
#
val a_onresize : Xml.event_handler -> [>
| `OnResize
] attrib
#
val a_onscroll : Xml.event_handler -> [>
| `OnScroll
] attrib
#
val a_onseeked : Xml.event_handler -> [>
| `OnSeeked
] attrib
#
val a_onseeking : Xml.event_handler -> [>
| `OnSeeking
] attrib
#
val a_onselect : Xml.event_handler -> [>
| `OnSelect
] attrib
#
val a_onshow : Xml.event_handler -> [>
| `OnShow
] attrib
#
val a_onstalled : Xml.event_handler -> [>
| `OnStalled
] attrib
#
val a_onstorage : Xml.event_handler -> [>
| `OnStorage
] attrib
#
val a_onsubmit : Xml.event_handler -> [>
| `OnSubmit
] attrib
#
val a_onsuspend : Xml.event_handler -> [>
| `OnSuspend
] attrib
#
val a_ontimeupdate : Xml.event_handler -> [>
| `OnTimeUpdate
] attrib
#
val a_onundo : Xml.event_handler -> [>
| `OnUndo
] attrib
#
val a_onunload : Xml.event_handler -> [>
| `OnUnload
] attrib
#
val a_onvolumechange : Xml.event_handler -> [>
| `OnVolumeChange
] attrib
#
val a_onwaiting : Xml.event_handler -> [>
| `OnWaiting
] attrib
#
val a_onload : Xml.event_handler -> [>
| `OnLoad
] attrib
#
val a_onloadeddata : Xml.event_handler -> [>
| `OnLoadedData
] attrib
#
val a_onloadedmetadata : Xml.event_handler -> [>
| `OnLoadedMetaData
] attrib
#
val a_onloadstart : Xml.event_handler -> [>
| `OnLoadStart
] attrib
#
val a_onmessage : Xml.event_handler -> [>
| `OnMessage
] attrib
#
val a_onclick : Xml.mouse_event_handler -> [>
| `OnClick
] attrib

Javascript mouse events

#
val a_oncontextmenu : Xml.mouse_event_handler -> [>
| `OnContextMenu
] attrib
#
val a_ondblclick : Xml.mouse_event_handler -> [>
| `OnDblClick
] attrib
#
val a_ondrag : Xml.mouse_event_handler -> [>
| `OnDrag
] attrib
#
val a_ondragend : Xml.mouse_event_handler -> [>
| `OnDragEnd
] attrib
#
val a_ondragenter : Xml.mouse_event_handler -> [>
| `OnDragEnter
] attrib
#
val a_ondragleave : Xml.mouse_event_handler -> [>
| `OnDragLeave
] attrib
#
val a_ondragover : Xml.mouse_event_handler -> [>
| `OnDragOver
] attrib
#
val a_ondragstart : Xml.mouse_event_handler -> [>
| `OnDragStart
] attrib
#
val a_ondrop : Xml.mouse_event_handler -> [>
| `OnDrop
] attrib
#
val a_onmousedown : Xml.mouse_event_handler -> [>
| `OnMouseDown
] attrib
#
val a_onmouseup : Xml.mouse_event_handler -> [>
| `OnMouseUp
] attrib
#
val a_onmouseover : Xml.mouse_event_handler -> [>
| `OnMouseOver
] attrib
#
val a_onmousemove : Xml.mouse_event_handler -> [>
| `OnMouseMove
] attrib
#
val a_onmouseout : Xml.mouse_event_handler -> [>
| `OnMouseOut
] attrib
#
val a_onkeypress : Xml.keyboard_event_handler -> [>
| `OnKeyPress
] attrib

Javascript keyboard events

#
val a_onkeydown : Xml.keyboard_event_handler -> [>
| `OnKeyDown
] attrib
#
val a_onkeyup : Xml.keyboard_event_handler -> [>
| `OnKeyUp
] attrib
#
val a_version : Html5_types.cdata wrap -> [>
| `Version
] attrib
#
val a_xmlns : [<
| `W3_org_1999_xhtml
] wrap -> [>
| `XMLns
] attrib
#
val a_manifest : Xml.uri wrap -> [>
| `Manifest
] attrib
#
val a_cite : Xml.uri wrap -> [>
| `Cite
] attrib
#
val a_xml_space : [<
| `Default
| `Preserve
] wrap -> [>
| `XML_space
] attrib
#
val a_accesskey : Html5_types.character wrap -> [>
| `Accesskey
] attrib

This attribute assigns an access key to an element. An access key is a single character from the document character set. NB: authors should consider the input method of the expected reader when specifying an accesskey.

#
val a_charset : Html5_types.charset wrap -> [>
| `Charset
] attrib

This attribute specifies the character encoding of the resource designated by the link. Please consult the section on character encodings for more details.

#
val a_accept_charset : Html5_types.charsets wrap -> [>
| `Accept_charset
] attrib
#
val a_accept : Html5_types.contenttypes wrap -> [>
| `Accept
] attrib
#
val a_href : Xml.uri wrap -> [>
| `Href
] attrib

This attribute specifies the location of a Web resource, thus defining a link between the current element (the source anchor) and the destination anchor defined by this attribute.

#
val a_hreflang : Html5_types.languagecode wrap -> [>
| `Hreflang
] attrib

This attribute specifies the base language of the resource designated by href and may only be used when href is specified.

#
val a_rel : Html5_types.linktypes wrap -> [>
| `Rel
] attrib

This attribute describes the relationship from the current document to the anchor specified by the href attribute. The value of this attribute is a space-separated list of link types.

This attribute is used to describe a reverse link from the anchor specified by the href attribute to the current document. The value of this attribute is a space-separated list of link types.

#
val a_tabindex : Html5_types.number wrap -> [>
| `Tabindex
] attrib

This attribute specifies the position of the current element in the tabbing order for the current document. This value must be a number between 0 and 32767. User agents should ignore leading zeros.

#
val a_mime_type : Html5_types.contenttype wrap -> [>
| `Mime_type
] attrib

This attribute gives an advisory hint as to the content type of the content available at the link target address. It allows user agents to opt to use a fallback mechanism rather than fetch the content if they are advised that they will get content in a content type they do not support.Authors who use this attribute take responsibility to manage the risk that it may become inconsistent with the content available at the link target address.

#
val a_datetime : Html5_types.cdata wrap -> [>
| `Datetime
] attrib
#
val a_action : Xml.uri wrap -> [>
| `Action
] attrib

This attribute specifies a form processing agent. User agent behavior for a value other than an HTTP URI is undefined.

#
val a_checked : [<
| `Checked
] wrap -> [>
| `Checked
] attrib

When the type attribute has the value "radio" or "checkbox", this boolean attribute specifies that the button is on. User agents must ignore this attribute for other control types.

#
val a_cols : Html5_types.number wrap -> [>
| `Cols
] attrib

This attribute specifies the visible width in average character widths. Users should be able to enter longer lines than this, so user agents should provide some means to scroll through the contents of the control when the contents extend beyond the visible area. User agents may wrap visible text lines to keep long lines visible without the need for scrolling.

#
val a_enctype : Html5_types.contenttype wrap -> [>
| `Enctype
] attrib
#
val a_for : Html5_types.idref wrap -> [>
| `For
] attrib
#
val a_for_list : Html5_types.idrefs wrap -> [>
| `For_List
] attrib
#
val a_maxlength : Html5_types.number wrap -> [>
| `Maxlength
] attrib
#
val a_method : [<
| `Get
| `Post
| `Put
| `Delete
] wrap -> [>
| `Method
] attrib
#
val a_multiple : [<
| `Multiple
] wrap -> [>
| `Multiple
] attrib
#
val a_name : Html5_types.text wrap -> [>
| `Name
] attrib

This attribute assigns the control name.

#
val a_rows : Html5_types.number wrap -> [>
| `Rows
] attrib

This attribute specifies the number of visible text lines. Users should be able to enter more lines than this, so user agents should provide some means to scroll through the contents of the control when the contents extend beyond the visible area.

#
val a_selected : [<
| `Selected
] wrap -> [>
| `Selected
] attrib

When set, this boolean attribute specifies that this option is pre-selected.

#
val a_size : Html5_types.number wrap -> [>
| `Size
] attrib
#
val a_src : Xml.uri wrap -> [>
| `Src
] attrib
#
val a_input_type : [<
| `Url
| `Tel
| `Text
| `Time
| `Search
| `Password
| `Checkbox
| `Range
| `Radio
| `Submit
| `Reset
| `Number
| `Hidden
| `Month
| `Week
| `File
| `Email
| `Image
| `Datetime_local
| `Datetime
| `Date
| `Color
| `Button
] wrap -> [>
| `Input_Type
] attrib
#
val a_text_value : Html5_types.text wrap -> [>
| `Text_Value
] attrib

This attribute specifies the initial value of the control. If this attribute is not set, the initial value is set to the contents of the option element.

#
val a_int_value : Html5_types.number wrap -> [>
| `Int_Value
] attrib
#
val a_value : Html5_types.cdata wrap -> [>
| `Value
] attrib
#
val a_float_value : Html5_types.float_number wrap -> [>
| `Float_Value
] attrib
#
val a_disabled : [<
| `Disabled
] wrap -> [>
| `Disabled
] attrib
#
val a_readonly : [<
| `ReadOnly
] wrap -> [>
| `ReadOnly
] attrib
#
val a_button_type : [<
| `Button
| `Submit
| `Reset
] wrap -> [>
| `Button_Type
] attrib
#
val a_command_type : [<
| `Command
| `Checkbox
| `Radio
] wrap -> [>
| `Command_Type
] attrib
#
val a_menu_type : [<
| `Context
| `Toolbar
] wrap -> [>
| `Menu_Type
] attrib
#
val a_label : Html5_types.text wrap -> [>
| `Label
] attrib
#
val a_align : [<
| `Left
| `Right
| `Justify
| `Char
] wrap -> [>
| `Align
] attrib
#
val a_axis : Html5_types.cdata wrap -> [>
| `Axis
] attrib
#
val a_colspan : Html5_types.number wrap -> [>
| `Colspan
] attrib
#
val a_headers : Html5_types.idrefs wrap -> [>
| `Headers
] attrib
#
val a_rowspan : Html5_types.number wrap -> [>
| `Rowspan
] attrib
#
val a_scope : [<
| `Row
| `Col
| `Rowgroup
| `Colgroup
] wrap -> [>
| `Scope
] attrib
#
val a_summary : Html5_types.text wrap -> [>
| `Summary
] attrib
#
val a_border : Html5_types.pixels wrap -> [>
| `Border
] attrib
#
val a_cellpadding : Html5_types.length wrap -> [>
| `Cellpadding
] attrib
#
val a_cellspacing : Html5_types.length wrap -> [>
| `Cellspacing
] attrib
#
val a_datapagesize : Html5_types.cdata wrap -> [>
| `Datapagesize
] attrib
#
val a_rules : [<
| `None
| `Groups
| `Rows
| `Cols
| `All
] wrap -> [>
| `Rules
] attrib
#
val a_char : Html5_types.character wrap -> [>
| `Char
] attrib
#
val a_charoff : Html5_types.length wrap -> [>
| `Charoff
] attrib
#
val a_alt : Html5_types.text wrap -> [>
| `Alt
] attrib
#
val a_height : Html5_types.number wrap -> [>
| `Height
] attrib
#
val a_width : Html5_types.number wrap -> [>
| `Width
] attrib
#
type shape = [
| `Rect
| `Circle
| `Poly
| `Default
]
#
val a_shape : shape wrap -> [>
| `Shape
] attrib
#
val a_coords : Html5_types.numbers wrap -> [>
| `Coords
] attrib
#
val a_usemap : Html5_types.idref wrap -> [>
| `Usemap
] attrib
#
val a_data : Xml.uri wrap -> [>
| `Data
] attrib
#
val a_codetype : Html5_types.contenttype wrap -> [>
| `Codetype
] attrib
#
val a_fs_rows : Html5_types.multilengths wrap -> [>
| `FS_Rows
] attrib
#
val a_fs_cols : Html5_types.multilengths wrap -> [>
| `FS_Cols
] attrib
#
val a_frameborder : [<
| `Zero
| `One
] wrap -> [>
| `Frameborder
] attrib
#
val a_marginheight : Html5_types.pixels wrap -> [>
| `Marginheight
] attrib
#
val a_marginwidth : Html5_types.pixels wrap -> [>
| `Marginwidth
] attrib
#
val a_scrolling : [<
| `Yes
| `No
| `Auto
] wrap -> [>
| `Scrolling
] attrib
#
val a_target : Html5_types.frametarget wrap -> [>
| `Target
] attrib
#
val a_content : Html5_types.text wrap -> [>
| `Content
] attrib
#
val a_http_equiv : Html5_types.text wrap -> [>
| `Http_equiv
] attrib
#
val a_defer : [<
| `Defer
] wrap -> [>
| `Defer
] attrib
#
val a_media : Html5_types.mediadesc wrap -> [>
| `Media
] attrib
#
val a_style : string wrap -> [>
| `Style_Attr
] attrib
#
val a_property : string wrap -> [>
| `Property
] attrib

Phantom types and XML elements

#
type +'a elt
#
type ('a, 'b) nullary = ?a:'a attrib list -> unit -> 'b elt
#
type ('a, 'b, 'c) unary = ?a:'a attrib list -> 'b elt wrap -> 'c elt
#
type ('a, 'b, 'c) star = ?a:'a attrib list -> 'b elt list_wrap -> 'c elt

Star '*' denotes any number of children, uncluding zero.

#
type html = [
| `Html
] elt

Root element

Combined Element Sets:

#
val html : ?a:Html5_types.html_attrib attrib list -> [<
| `Head
] elt wrap -> [<
| `Body
] elt wrap -> [>
| `Html
] elt
#
val head : ?a:Html5_types.head_attrib attrib list -> [<
| `Title
] elt wrap -> Html5_types.head_content_fun elt list_wrap -> [>
| Html5_types.head
] elt
#
val base : ([<
| Html5_types.base_attrib
], [>
| Html5_types.base
]) nullary
#
val svg : ?xmlns:string -> ?a:[<
| Html5_types.svg_attrib
] Svg.attrib list -> [<
| Html5_types.svg_content
] Svg.elt list_wrap -> [>
| Html5_types.svg
] elt

Section

#
val footer : ([<
| Html5_types.common
], [<
| Html5_types.flow5_without_header_footer
], [>
| `Footer
]) star
#
val header : ([<
| Html5_types.common
], [<
| Html5_types.flow5_without_header_footer
], [>
| `Header
]) star
#
val nav : ([<
| Html5_types.nav_attrib
], [<
| Html5_types.nav_content_fun
], [>
| Html5_types.nav
]) star
#
val h1 : ([<
| Html5_types.h1_attrib
], [<
| Html5_types.h1_content_fun
], [>
| Html5_types.h1
]) star
#
val h2 : ([<
| Html5_types.h2_attrib
], [<
| Html5_types.h2_content_fun
], [>
| Html5_types.h2
]) star
#
val h3 : ([<
| Html5_types.h3_attrib
], [<
| Html5_types.h3_content_fun
], [>
| Html5_types.h3
]) star
#
val h4 : ([<
| Html5_types.h4_attrib
], [<
| Html5_types.h4_content_fun
], [>
| Html5_types.h4
]) star
#
val h5 : ([<
| Html5_types.h5_attrib
], [<
| Html5_types.h5_content_fun
], [>
| Html5_types.h5
]) star
#
val h6 : ([<
| Html5_types.h6_attrib
], [<
| Html5_types.h6_content_fun
], [>
| Html5_types.h6
]) star

Grouping content

#
val p : ([<
| Html5_types.p_attrib
], [<
| Html5_types.p_content_fun
], [>
| Html5_types.p
]) star
#
val pre : ([<
| Html5_types.pre_attrib
], [<
| Html5_types.pre_content_fun
], [>
| Html5_types.pre
]) star
#
val div : ([<
| Html5_types.div_attrib
], [<
| Html5_types.div_content_fun
], [>
| Html5_types.div
]) star
#
val dl : ([<
| Html5_types.dl_attrib
], [<
| Html5_types.dl_content_fun
], [>
| Html5_types.dl
]) star
#
val ol : ([<
| Html5_types.ol_attrib
], [<
| Html5_types.ol_content_fun
], [>
| Html5_types.ol
]) star
#
val ul : ([<
| Html5_types.ul_attrib
], [<
| Html5_types.ul_content_fun
], [>
| Html5_types.ul
]) star
#
val dd : ([<
| Html5_types.dd_attrib
], [<
| Html5_types.dd_content_fun
], [>
| Html5_types.dd
]) star
#
val dt : ([<
| Html5_types.dt_attrib
], [<
| Html5_types.dt_content_fun
], [>
| Html5_types.dt
]) star
#
val li : ([<
| Html5_types.li_attrib
], [<
| Html5_types.li_content_fun
], [>
| Html5_types.li
]) star

A list element. The 'a type is used to know whether the element has a int_value attribute or not.

#
val figure : ?figcaption:[
| `Top of [<
| `Figcaption
] elt wrap
| `Bottom of [<
| `Figcaption
] elt wrap
] -> ([<
| Html5_types.figure_attrib
], [<
| Html5_types.figure_content_fun
], [>
| Html5_types.figure
]) star
#
val hr : ([<
| Html5_types.hr_attrib
], [>
| Html5_types.hr
]) nullary

Ruby

#
val rt : ([<
| Html5_types.rt_attrib
], [<
| Html5_types.rt_content_fun
], [>
| Html5_types.rt
]) star
#
val rp : ([<
| Html5_types.rp_attrib
], [<
| Html5_types.rp_content_fun
], [>
| Html5_types.rp
]) star

Semantic

#
val b : ([<
| Html5_types.b_attrib
], [<
| Html5_types.b_content_fun
], [>
| Html5_types.b
]) star
#
val i : ([<
| Html5_types.i_attrib
], [<
| Html5_types.i_content_fun
], [>
| Html5_types.i
]) star
#
val u : ([<
| Html5_types.u_attrib
], [<
| Html5_types.u_content_fun
], [>
| Html5_types.u
]) star
#
val sub : ([<
| Html5_types.sub_attrib
], [<
| Html5_types.sub_content_fun
], [>
| Html5_types.sub
]) star
#
val sup : ([<
| Html5_types.sup_attrib
], [<
| Html5_types.sup_content_fun
], [>
| Html5_types.sup
]) star
#
val wbr : ([<
| Html5_types.wbr_attrib
], [>
| Html5_types.wbr
]) nullary
#
val bdo : dir:[<
| `Ltr
| `Rtl
] wrap -> ([<
| Html5_types.common
], [<
| Html5_types.phrasing
], [>
| `Bdo
]) star
#
val br : ([<
| Html5_types.br_attrib
], [>
| Html5_types.br
]) nullary
#
val dfn : ([<
| Html5_types.dfn_attrib
], [<
| Html5_types.dfn_content_fun
], [>
| Html5_types.dfn
]) star
#
val em : ([<
| Html5_types.em_attrib
], [<
| Html5_types.em_content_fun
], [>
| Html5_types.em
]) star
#
val kbd : ([<
| Html5_types.kbd_attrib
], [<
| Html5_types.kbd_content_fun
], [>
| Html5_types.kbd
]) star
#
val q : ([<
| Html5_types.q_attrib
], [<
| Html5_types.q_content_fun
], [>
| Html5_types.q
]) star
#
val var : ([<
| Html5_types.var_attrib
], [<
| Html5_types.var_content_fun
], [>
| Html5_types.var
]) star

Hypertext

#
val a : ([<
| Html5_types.a_attrib
], 'a, [>
| `A of 'a
]) star

Edit

#
val del : ([<
| Html5_types.del_attrib
], 'a, [>
| `Del of 'a
]) star
#
val ins : ([<
| Html5_types.ins_attrib
], 'a, [>
| `Ins of 'a
]) star

Embedded

#
val img : src:Xml.uri wrap -> alt:Html5_types.text wrap -> ([<
| Html5_types.img_attrib
], [>
| Html5_types.img
]) nullary
#
val iframe : ([<
| Html5_types.common
| `Src
| `Name
| `Sandbox
| `Seamless
| `Width
| `Height
], [<
| `PCDATA
], [>
| `Iframe
]) star
#
val object_ : ?params:[<
| `Param
] elt list_wrap -> ([<
| Html5_types.common
| `Data
| `Form
| `Mime_type
| `Height
| `Width
| `Name
| `Usemap
], 'a, [>
| `Object of 'a
]) star
#
val param : ([<
| Html5_types.param_attrib
], [>
| Html5_types.param
]) nullary
#
val embed : ([<
| Html5_types.common
| `Src
| `Height
| `Mime_type
| `Width
], [>
| `Embed
]) nullary
#
val audio : ?src:Xml.uri wrap -> ?srcs:[<
| Html5_types.source
] elt list_wrap -> ([<
| Html5_types.audio_attrib
], 'a, [>
| 'a Html5_types.audio
]) star
#
val video : ?src:Xml.uri wrap -> ?srcs:[<
| Html5_types.source
] elt list_wrap -> ([<
| Html5_types.video_attrib
], 'a, [>
| 'a Html5_types.video
]) star
#
val canvas : ([<
| Html5_types.canvas_attrib
], 'a, [>
| 'a Html5_types.canvas
]) star
#
val source : ([<
| Html5_types.source_attrib
], [>
| Html5_types.source
]) nullary
#
val area : alt:Html5_types.text wrap -> ([<
| Html5_types.common
| `Alt
| `Coords
| `Shape
| `Target
| `Rel
| `Media
| `Hreflang
| `Mime_type
], [>
| `Area
]) nullary
#
val map : ([<
| Html5_types.map_attrib
], 'a, [>
| `A of 'a
]) star

Tables Data

#
val table : ?caption:[<
| Html5_types.caption
] elt wrap -> ?columns:[<
| Html5_types.colgroup
] elt list_wrap -> ?thead:[<
| Html5_types.thead
] elt wrap -> ?tfoot:[<
| Html5_types.tfoot
] elt wrap -> ([<
| Html5_types.table_attrib
], [<
| Html5_types.table_content_fun
], [>
| Html5_types.table
]) star
#
val tablex : ?caption:[<
| Html5_types.caption
] elt wrap -> ?columns:[<
| Html5_types.colgroup
] elt list_wrap -> ?thead:[<
| Html5_types.thead
] elt wrap -> ?tfoot:[<
| Html5_types.tfoot
] elt wrap -> ([<
| Html5_types.tablex_attrib
], [<
| Html5_types.tablex_content_fun
], [>
| Html5_types.tablex
]) star
#
val col : ([<
| Html5_types.col_attrib
], [>
| Html5_types.col
]) nullary
#
val td : ([<
| Html5_types.td_attrib
], [<
| Html5_types.td_content_fun
], [>
| Html5_types.td
]) star
#
val th : ([<
| Html5_types.th_attrib
], [<
| Html5_types.th_content_fun
], [>
| Html5_types.th
]) star
#
val tr : ([<
| Html5_types.tr_attrib
], [<
| Html5_types.tr_content_fun
], [>
| Html5_types.tr
]) star
#
val form : ([<
| Html5_types.form_attrib
], [<
| Html5_types.form_content_fun
], [>
| Html5_types.form
]) star

Forms

#
val fieldset : ?legend:[
| `Legend
] elt wrap -> ([<
| Html5_types.common
| `Disabled
| `Form
| `Name
], [<
| Html5_types.flow5
], [>
| `Fieldset
]) star
#
val label : ([<
| Html5_types.label_attrib
], [<
| Html5_types.label_content_fun
], [>
| Html5_types.label
]) star

Label authorizes only one control inside them that should be labelled with a for attribute (although it is not necessary). Such constraints are not currently enforced by the type-system

#
val input : ([<
| Html5_types.input_attrib
], [>
| Html5_types.input
]) nullary

If the type attribute is not "hidden", must be considered as interactive. Distinction not made for now.

#
val datalist : ?children:[<
| `Options of [<
| `Option
] elt list_wrap
| `Phras of [<
| Html5_types.phrasing
] elt list_wrap
] -> ([<
| Html5_types.common
], [>
| `Datalist
]) nullary
#
val optgroup : label:Html5_types.text wrap -> ([<
| Html5_types.common
| `Disabled
| `Label
], [<
| `Option
], [>
| `Optgroup
]) star
#
val keygen : ([<
| Html5_types.keygen_attrib
], [>
| Html5_types.keygen
]) nullary

Data

#
val pcdata : string wrap -> [>
| `PCDATA
] elt
#
val entity : string -> [>
| `PCDATA
] elt
#
val space : unit -> [>
| `PCDATA
] elt
#
val cdata : string -> [>
| `PCDATA
] elt
#
val cdata_script : string -> [>
| `PCDATA
] elt
#
val cdata_style : string -> [>
| `PCDATA
] elt

Interactive

#
val details : [<
| `Summary
] elt wrap -> ([<
| Html5_types.common
| `Open
], [<
| Html5_types.flow5
], [>
| `Details
]) star
#
val command : label:Html5_types.text wrap -> ([<
| Html5_types.common
| `Icon
| `Disabled
| `Checked
| `Radiogroup
| `Command_Type
], [>
| `Command
]) nullary
#
val menu : ?child:[<
| `Lis of [<
| `Li of [<
| Html5_types.common
]
] elt list_wrap
| `Flows of [<
| Html5_types.flow5
] elt list_wrap
] -> ([<
| Html5_types.common
| `Label
| `Menu_Type
], [>
| `Menu
]) nullary

Scripting

#
val meta : ([<
| Html5_types.meta_attrib
], [>
| Html5_types.meta
]) nullary

Style Sheets

Link

Tools

#
val tot : Xml.elt -> 'a elt
#
val totl : Xml.elt list -> 'a elt list
#
val toelt : 'a elt -> Xml.elt
#
val toeltl : 'a elt list -> Xml.elt list
#
type doc = [
| `Html
] elt
#
val doc_toelt : doc -> Xml.elt
#
module Unsafe : sig

Unsafe features. Warning using this module can break HTML5 validity and may introduce security problems like code injection. Use it with care.

#
val data : string wrap -> 'a elt

Insert raw text without any encoding

#
val node : string -> ?a:'a attrib list -> 'b elt list_wrap -> 'c elt

Insert an XML node that is not implemented in this module. If it is a standard HTML5 node which is missing, please report to the Ocsigen team.

#
val leaf : string -> ?a:'a attrib list -> unit -> 'b elt

Insert an XML node without children that is not implemented in this module. If it is a standard HTML5 node which is missing, please report to the Ocsigen team.

#
val coerce_elt : 'a elt -> 'b elt

Remove phantom type annotation on an element, to make it usable everywhere.

#
val string_attrib : string -> string wrap -> 'a attrib

Insert an attribute that is not implemented in this module. If it is a standard HTML5 attribute which is missing, please report to the Ocsigen team.

#
val float_attrib : string -> float wrap -> 'a attrib

Same, for float attribute

#
val int_attrib : string -> int wrap -> 'a attrib

Same, for int attribute

#
val uri_attrib : string -> uri wrap -> 'a attrib

Same, for URI attribute

#
val space_sep_attrib : string -> string list wrap -> 'a attrib

Same, for a space separated list of values

#
val comma_sep_attrib : string -> string list wrap -> 'a attrib

Same, for a comma separated list of values

end
end

Signature functors

See TARGET NONE: <<a_manual chapter="functors"|the manual of the functorial interface>>.

#
module MakeWrapped : functor (W : Xml_wrap.T) -> functor (Xml : Xml_sigs.Wrapped) -> functor (Svg : Svg_sigs.T with module Xml := Xml) -> sig

Signature functor for Html5_f.MakeWrapped.

#
module type T = T with type Xml.uri = Xml.uri and type Xml.event_handler = Xml.event_handler and type Xml.mouse_event_handler = Xml.mouse_event_handler and type Xml.keyboard_event_handler = Xml.keyboard_event_handler and type Xml.attrib = Xml.attrib and type Xml.elt = Xml.elt and module Svg := Svg and type 'a Xml.wrap = 'a W.t and type 'a wrap = 'a W.t and type 'a Xml.list_wrap = 'a W.tlist and type 'a list_wrap = 'a W.tlist

See Html5_sigs.T.

end
#
module Make : functor (Xml : Xml_sigs.T) -> functor (Svg : Svg_sigs.T with module Xml := Xml) -> sig

Signature functor for Html5_f.Make.

#
module type T = MakeWrapped(Xml_wrap.NoWrap)(Xml)(Svg).T

See Html5_sigs.MakeWrapped and Html5_sigs.T.

end
end