### Dealing with `null` and `undefined` values.

`type +'a opt`

Type of possibly null values.

`type +'a optdef`

Type of possibly undefined values.

`val null : 'a opt`

The `null` value.

`val some : 'a -> 'a opt`

Consider a value into a possibly null value.

`val undefined : 'a optdef`

The `undefined` value

`val def : 'a -> 'a optdef`

Consider a value into a possibly undefined value.

`module type OPT = sig ... end`

Signatures of a set of standard functions for manipulating optional values.

`module Opt : OPT with type 'a t = 'a opt`

Standard functions for manipulating possibly null values.

`module Optdef : OPT with type 'a t = 'a optdef`

Standard functions for manipulating possibly undefined values.

### Types for specifying method and properties of Javascript objects

`type +'a t`

Type of Javascript objects. The type parameter is used to specify more precisely an object.

`type +'a meth`

Type used to specify method types: a Javascript object `<m : t1 -> t2 -> ... -> tn -> t Js.meth> Js.t` has a Javascript method `m` expecting n arguments of types `t1` to `tn` and returns a value of type `t`.

`type +'a gen_prop`

Type used to specify the properties of Javascript objects. In practice you should rarely need this type directly, but should rather use the type abbreviations below instead.

`type 'a readonly_prop = < get : 'a > gen_prop`

Type of read-only properties: a Javascript object `<p : t Js.readonly_prop> Js.t` has a read-only property `p` of type `t`.

`type 'a writeonly_prop = < set : 'a -> unit > gen_prop`

Type of write-only properties: a Javascript object `<p : t Js.writeonly_prop> Js.t` has a write-only property `p` of type `t`.

`type 'a prop = < get : 'a ; set : 'a -> unit > gen_prop`

Type of read/write properties: a Javascript object `<p : t Js.writeonly_prop> Js.t` has a read/write property `p` of type `t`.

`type 'a optdef_prop = < get : 'a optdef ; set : 'a -> unit > gen_prop`

Type of read/write properties that may be undefined: you can set them to a value of some type `t`, but if you read them, you will get a value of type `t optdef` (that may be `undefined`).

### Object constructors

`type +'a constr`

A value of type `(t1 -> ... -> tn -> t Js.t) Js.constr` is a Javascript constructor expecting n arguments of types `t1` to `tn` and returning a Javascript object of type `t Js.t`. Use the syntax extension `new%js c e1 ... en` to build an object using constructor `c` and arguments `e1` to `en`.

### Callbacks to OCaml

`type (-'a, +'b) meth_callback`

Type of callback functions. A function of type `(u, t1 -> ... -> tn -> t) meth_callback` can be called from Javascript with `this` bound to a value of type `u` and up to n arguments of types `t1` to `tn`. The system takes care of currification, so less than n arguments can be provided. As a special case, a callback of type `(t, unit -> t) meth_callback` can be called from Javascript with no argument. It will behave as if it was called with a single argument of type `unit`.

`type 'a callback = (unit, 'a) meth_callback`

Type of callback functions intended to be called without a meaningful `this` implicit parameter.

`val wrap_callback : ('a -> 'b) -> ('c, 'a -> 'b) meth_callback`

Wrap an OCaml function so that it can be invoked from Javascript.

`val wrap_meth_callback : ('b -> 'a) -> ('b, 'a) meth_callback`

Wrap an OCaml function so that it can be invoked from Javascript. The first parameter of the function will be bound to the value of the `this` implicit parameter.

### Javascript comparisons

`val equals : _ t -> _ t -> bool`

Javascript `==` equality operator.

`val strict_equals : _ t -> _ t -> bool`

Javascript `===` equality operator.

### Javascript standard objects

`val _true : bool t`

Javascript `true` boolean.

`val _false : bool t`

Javascript `false` boolean.

`type match_result_handle`

A handle to a match result. Use function `Js.match_result` to get the corresponding `MatchResult` object. (This type is used to resolved the mutual dependency between string and array type definitions.)

`type string_array`

Opaque type for string arrays. You can get the actual `Array` object using function `Js.str_array`. (This type is used to resolved the mutual dependency between string and array type definitions.)

`type normalization`

Opaque type for Unicode normalization forms.

`val nfd : normalization t`

Canonical Decomposition

`val nfc : normalization t`

Canonical Decomposition, followed by Canonical Composition

`val nfkd : normalization t`

Compatibility Decomposition

`val nfkc : normalization t`

Compatibility Decomposition, followed by Canonical Composition

Specification of Javascript number objects.

`class type number = object ... end`
`class type js_string = object ... end`

Specification of Javascript string objects.

`class type regExp = object ... end`

Specification of Javascript regular expression objects.

`type number_t = number t`
`class type string_constr = object ... end`

Specification of the string constructor, considered as an object.

`val string_constr : string_constr t`

The string constructor, as an object.

`val regExp : (js_string t -> regExp t) constr`

Constructor of `RegExp` objects. The expression `new%js regExp s` builds the regular expression specified by string `s`.

`val regExp_withFlags : (js_string t -> js_string t -> regExp t) constr`

Constructor of `RegExp` objects. The expression `new%js regExp s f` builds the regular expression specified by string `s` using flags `f`.

`val regExp_copy : (regExp t -> regExp t) constr`

Constructor of `RegExp` objects. The expression `new%js regExp r` builds a copy of regular expression `r`.

`class type 'a js_array = object ... end`

Specification of Javascript regular arrays. Use `Js.array_get` and `Js.array_set` to access and set array elements.

`val object_keys : 'a t -> js_string t js_array t`

Returns jsarray containing keys of the object as Object.keys does.

`val array_empty : 'a js_array t constr`

Constructor of `Array` objects. The expression `new%js array_empty` returns an empty array.

`val array_length : (int -> 'a js_array t) constr`

Constructor of `Array` objects. The expression `new%js array_length l` returns an array of length `l`.

`val array_get : 'a js_array t -> int -> 'a optdef`

Array access: `array_get a i` returns the element at index `i` of array `a`. Returns `undefined` if there is no element at this index.

`val array_set : 'a js_array t -> int -> 'a -> unit`

Array update: `array_set a i v` puts `v` at index `i` in array `a`.

`val array_map : ('a -> 'b) -> 'a js_array t -> 'b js_array t`

Array map: `array_map f a` is `a##map(wrap_callback (fun elt idx arr -> f elt))`.

`val array_mapi : (int -> 'a -> 'b) -> 'a js_array t -> 'b js_array t`

Array mapi: `array_mapi f a` is `a##map(wrap_callback (fun elt idx arr -> f idx elt))`.

`class type match_result = object ... end`

Specification of match result objects

`val str_array : string_array t -> js_string t js_array t`

Convert an opaque `string_array t` object into an array of string. (Used to resolved the mutual dependency between string and array type definitions.)

`val match_result : match_result_handle t -> match_result t`

Convert a match result handle into a `MatchResult` object. (Used to resolved the mutual dependency between string and array type definitions.)

`class type date = object ... end`

Specification of Javascript date objects.

`val date_now : date t constr`

Constructor of `Date` objects: `new%js date_now` returns a `Date` object initialized with the current date.

`val date_fromTimeValue : (number_t -> date t) constr`

Constructor of `Date` objects: `new%js date_fromTimeValue t` returns a `Date` object initialized with the time value `t`.

`val date_month : (int -> int -> date t) constr`

Constructor of `Date` objects: `new%js date_fromTimeValue y m` returns a `Date` object corresponding to year `y` and month `m`.

`val date_day : (int -> int -> int -> date t) constr`

Constructor of `Date` objects: `new%js date_fromTimeValue y m d` returns a `Date` object corresponding to year `y`, month `m` and day `d`.

`val date_hour : (int -> int -> int -> int -> date t) constr`

Constructor of `Date` objects: `new%js date_fromTimeValue y m d h` returns a `Date` object corresponding to year `y` to hour `h`.

`val date_min : (int -> int -> int -> int -> int -> date t) constr`

Constructor of `Date` objects: `new%js date_fromTimeValue y m d h m'` returns a `Date` object corresponding to year `y` to minute `m'`.

`val date_sec : (int -> int -> int -> int -> int -> int -> date t) constr`

Constructor of `Date` objects: `new%js date_fromTimeValue y m d h m' s` returns a `Date` object corresponding to year `y` to second `s`.

`val date_ms : (int -> int -> int -> int -> int -> int -> int -> date t) constr`

Constructor of `Date` objects: `new%js date_fromTimeValue y m d h m' s ms` returns a `Date` object corresponding to year `y` to millisecond `ms`.

`class type date_constr = object ... end`

Specification of the date constructor, considered as an object.

`val date : date_constr t`

The date constructor, as an object.

`class type math = object ... end`

Specification of Javascript math object.

`val math : math t`

The Math object

`class type error = object ... end`

Specification of Javascript error object.

`val error_constr : (js_string t -> error t) constr`

Constructor of `Error` objects: `new%js error_constr msg` returns an `Error` object with the message `msg`.

`module Js_error : sig ... end`
`class type json = object ... end`

Specification of Javascript JSON object.

`val _JSON : json t`

JSON object

### Standard Javascript functions

`val decodeURI : js_string t -> js_string t`

Decode a URI: replace by the corresponding byte all escape sequences but the ones corresponding to a URI reserved character and convert the string from UTF-8 to UTF-16.

`val decodeURIComponent : js_string t -> js_string t`

Decode a URIComponent: replace all escape sequences by the corresponding byte and convert the string from UTF-8 to UTF-16.

`val encodeURI : js_string t -> js_string t`

Encode a URI: convert the string to UTF-8 and replace all unsafe bytes by the corresponding escape sequence.

`val encodeURIComponent : js_string t -> js_string t`

Same as `encodeURI`, but also encode URI reserved characters.

`val escape : js_string t -> js_string t`

Escape a string: unsafe UTF-16 code points are replaced by 2-digit and 4-digit escape sequences.

`val unescape : js_string t -> js_string t`

Unescape a string: 2-digit and 4-digit escape sequences are replaced by the corresponding UTF-16 code point.

`val isNaN : 'a -> bool`
`val parseInt : js_string t -> int`
`val parseFloat : js_string t -> number_t`

### Conversion functions between Javascript and OCaml types

`val bool : bool -> bool t`

Conversion of booleans from OCaml to Javascript.

`val to_bool : bool t -> bool`

Conversion of booleans from Javascript to OCaml.

`val string : string -> js_string t`

Conversion of strings from OCaml to Javascript. (The OCaml string is considered to be encoded in UTF-8 and is converted to UTF-16.)

`val to_string : js_string t -> string`

Conversion of strings from Javascript to OCaml.

`val array : 'a array -> 'a js_array t`

Conversion of arrays from OCaml to Javascript.

`val to_array : 'a js_array t -> 'a array`

Conversion of arrays from Javascript to OCaml.

`val bytestring : string -> js_string t`

Conversion of strings of bytes from OCaml to Javascript. (Each byte will be converted in an UTF-16 code point.)

`val to_bytestring : js_string t -> string`

Conversion of strings of bytes from Javascript to OCaml. (The Javascript string should only contain UTF-16 code points below 255.)

`val float : float -> number_t`

Conversion of OCaml floats to Javascript numbers.

`val to_float : number_t -> float`

Conversion of Javascript numbers to OCaml floats.

`val number_of_float : float -> number t`

Conversion of OCaml floats to Javascript number objects.

`val float_of_number : number t -> float`

Conversion of Javascript number objects to OCaml floats.

`val int32 : int32 -> number_t`

Conversion of OCaml floats to Javascript numbers.

`val to_int32 : number_t -> int32`

Conversion of Javascript numbers to OCaml 32-bits. The given floating-point number is truncated to an integer.

`val nativeint : nativeint -> number_t`

Conversion of OCaml 32-bits integers to Javascript numbers.

`val to_nativeint : number_t -> nativeint`

Conversion of Javascript numbers to OCaml native integers. The given floating-point number is truncated to an integer.

### Convenience coercion functions

`val coerce : 'a -> ('a -> 'b Opt.t) -> ('a -> 'b) -> 'b`

Apply a possibly failing coercion function. `coerce v c f` attempts to apply coercion `c` to value `v`. If the coercion returns `null`, function `f` is called.

`val coerce_opt : 'a Opt.t -> ('a -> 'b Opt.t) -> ('a -> 'b) -> 'b`

Apply a possibly failing coercion function. `coerce_opt v c f` attempts to apply coercion `c` to value `v`. If `v` is `null` or the coercion returns `null`, function `f` is called. Typical usage is the following:

    Js.coerce_opt (Dom_html.document##getElementById id)
    Dom_html.CoerceTo.div (fun _ -> assert false)

### Type checking operators.

`val typeof : _ t -> js_string t`

Returns the type of a Javascript object.

`val instanceof : _ t -> _ constr -> bool`

Tests whether a Javascript object is an instance of a given class.

### Debugging operations.

`val debugger : unit -> unit`

Invokes any available debugging functionality. If no debugging functionality is available, it has no effect. In practice, it will insert a "debugger;" statement in the generated javascript.

### Export functionality.

Export values to `module.exports` if it exists or to the global object otherwise.

`val export : string -> 'a -> unit`

`export name value` export `name`

`val export_all : 'a t -> unit`

`export_all obj` export every key of `obj` object.

    export_all
      object%js
        method add x y = x +. y
        method abs x = abs_float x
        val zero = 0.
      end

### Unsafe operations.

`module Unsafe : sig ... end`

Unsafe Javascript operations

### Deprecated functions and types.

`val string_of_error : error t -> string`

- deprecated [since 4.0] Use [Js_error.to_string] instead.

`val raise_js_error : error t -> 'a`

- deprecated [since 4.0] Use [Js_error.raise_] instead.

`val exn_with_js_backtrace : exn -> force:bool -> exn`

Attach a JavasScript error to an OCaml exception. if `force = false` and a JavasScript error is already attached, it will do nothing. This function is useful to store and retrieve information about JavaScript stack traces.

Attaching JavasScript errors will happen automatically when compiling with `--enable with-js-error`.

- deprecated [since 4.0] Use [Js_error.raise_] instead.

`val js_error_of_exn : exn -> error t opt`

Extract a JavaScript error attached to an OCaml exception, if any. This is useful to inspect an eventual stack strace, especially when sourcemap is enabled.

- deprecated [since 4.0] Use [Js_error.of_exn] instead.

`exception Error of error t`

The `Error` exception wrap javascript exceptions when caught by OCaml code. In case the javascript exception is not an instance of javascript `Error`, it will be serialized and wrapped into a `Failure` exception.

- deprecated [since 4.0] Use [Js_error.Exn] instead.

`type float_prop = number_t prop`

- deprecated [since 2.0].

Type of float properties.