var xhr = new XMLHttpRequest;
xhr.open("GET", "http://url");

val xhr = val::global("XMLHttpRequest").new_();
xhr.call<void>("open", std::string("GET"), std::string("http://url"));

const char* state;
switch (xhr["readyState"].as<int>()) {
case 0:
  state = "UNSENT"; break;
case 1:
  state = "OPENED"; break;
default:
  state = "etc";
}

For example, if you want to cache some JavaScript global as a ``val``, you need to retrieve and bind separate instances of that global by its name in each thread.
The easiest way to do this is with a ``thread_local`` declaration:

.. code:: cpp

  thread_local const val Uint8Array = val::global("Uint8Array");

**HamishW** Notes from source FYI: Can/should these be included? ::

  // missing operators:
  // * delete
  // * in
  // * instanceof
  // * ! ~ - + ++ --
  // * * / %
  // * + -
  // * << >> >>>
  // * < <= > >=
  // * == != === !==
  // * & ^ | && || ?:
  //
  // exposing void, comma, and conditional is unnecessary
  // same with: = += -= *= /= %= <<= >>= >>>= &= ^= |=

Creates and returns a new ``Array``.

Creates and returns a new ``Object``.

Creates a ``val`` from a string literal in UTF-8 encoding.

Creates a ``val`` from a string literal in UTF-16 encoding.

Creates a ``val`` that represents ``undefined``.

Creates a ``val`` that represents ``null``.

Returns a raw handle representing this ``val``. This can be used for
passing raw value handles to JavaScript and retrieving the values on the
other side via ``Emval.toValue`` function. Example:

.. code:: cpp

  EM_JS(void, log_value, (EM_VAL val_handle), {
    var value = Emval.toValue(val_handle);
    console.log(value); // 42
  });

  val foo(42);
  log_value(foo.as_handle());

Creates a ``val`` from a raw handle. This can be used for retrieving values
from JavaScript, where the JavaScript side should wrap a value with
``Emval.toHandle``, pass it to C++, and then C++ can use ``take_ownership``
to convert it to a ``val`` instance. Example:

.. code:: cpp

  EM_ASYNC_JS(EM_VAL, fetch_json_from_url, (const char *url), {
    var url = UTF8ToString(url);
    var response = await fetch(url);
    var json = await response.json();
    return Emval.toHandle(json);
  });

  val obj = val::take_ownership(fetch_json_from_url("https://httpbin.org/json"));
  std::string author = obj["slideshow"]["author"].as<std::string>();

Looks up a global value by the specified ``name``.

Looks up a value by the provided ``name`` on the Emscripten Module object.

Constructor.

Creates a ``val`` by conversion from any Embind-compatible C++ type.
For example, ``val(true)`` or ``val(std::string("foo"))``.

Constructs a ``val`` instance from a string literal.

Moves ownership of a value to a new ``val`` instance.

Creates another reference to the same value behind the provided ``val`` instance.

Removes the currently bound value by decreasing its refcount.

Removes a reference to the currently bound value and takes over the provided one.

Removes a reference to the currently bound value and creates another reference to
the value behind the provided ``val`` instance.

Checks if the JavaScript object has own (non-inherited) property with the specified name.

Assumes that current value is a constructor, and creates an instance of it.
Equivalent to a JavaScript expression `new currentValue(...)`.

Get the specified (``key``) property of a JavaScript object.

Set the specified (``key``) property of a JavaScript object (accessed through a ``val``) with the value ``v``.

Assumes that current value is a function, and invokes it with provided arguments.

Invokes the specified method (``name``) on the current object with provided arguments.

Converts current value to the specified C++ type.

Returns the result of a JavaScript ``typeof`` operator invoked on the current value.

Copies a JavaScript array into a ``std::vector<T>``, converting each element via ``.as<T>()``.
For a more efficient but unsafe version working with numbers, see ``convertJSArrayToNumberVector``.

:param val v: The JavaScript array to be copied
:returns: A ``std::vector<T>`` made from the javascript array

Converts a JavaScript array into a ``std::vector<T>`` efficiently, as if using the javascript `Number()` function on each element.
This is way more efficient than ``vecFromJSArray`` on any array with more than 2 values, but is not suitable for arrays of non-numeric values.
No type checking is done, so any invalid array entry will silently be replaced by a NaN value (or 0 for integer types).

:param val v: The JavaScript (typed) array to be copied
:returns: A std::vector<T> made from the javascript array

Pauses the C++ to ``await`` the ``Promise`` / thenable.

:returns: The fulfilled value.

  .. note:: This method requires :ref:`ASYNCIFY` to be enabled.

.. code:: javascript

  async function foo() {
    const response = await fetch("http://url");
    const json = await response.json();
    return json;
  }

  export { foo };

as a C++ coroutine:

.. code:: cpp

  val foo() {
    val response = co_await val::global("fetch")(std::string("http://url"));
    val json = co_await response.call<val>("json");
    return json;
  }

  EMSCRIPTEN_BINDINGS(module) {
    function("foo", &foo);
  }