// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

//! This crate provides raw bindings for the JavaScriptCore public
//! API. It is a pretty direct mapping of the underlying C API
//! provided by JavaScriptCore.

#![allow(non_camel_case_types, non_snake_case)]

use std::ptr;

/// A group that associates JavaScript contexts with one another.
/// Contexts in the same group may share and exchange JavaScript objects.
#[doc(hidden)]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct OpaqueJSContextGroup([u8; 0]);

/// A group that associates JavaScript contexts with one another.
/// Contexts in the same group may share and exchange JavaScript objects.
pub type JSContextGroupRef = *const OpaqueJSContextGroup;

/// A JavaScript execution context. Holds the global object and
/// other execution state.
#[doc(hidden)]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct OpaqueJSContext([u8; 0]);

/// A JavaScript execution context. Holds the global object and
/// other execution state.
pub type JSContextRef = *const OpaqueJSContext;

/// A global JavaScript execution context.
/// A `JSGlobalContext` is a `JSContext`.
pub type JSGlobalContextRef = *mut OpaqueJSContext;

/// A UTF16 character buffer. The fundamental string representation
/// in JavaScript.
#[doc(hidden)]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct OpaqueJSString([u8; 0]);

/// A UTF16 character buffer. The fundamental string representation
/// in JavaScript.
pub type JSStringRef = *mut OpaqueJSString;

/// A JavaScript class.
/// Used with `JSObjectMake` to construct objects with custom behavior.
#[doc(hidden)]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct OpaqueJSClass([u8; 0]);

/// A JavaScript class.
/// Used with `JSObjectMake` to construct objects with custom behavior.
pub type JSClassRef = *mut OpaqueJSClass;

/// An array of JavaScript property names.
#[doc(hidden)]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct OpaqueJSPropertyNameArray([u8; 0]);

/// An array of JavaScript property names.
///
/// Values of this type are obtained via [`JSObjectCopyPropertyNames`].
///
/// Operations:
///
/// * [`JSPropertyNameArrayGetCount`]
/// * [`JSPropertyNameArrayGetNameAtIndex`]
/// * [`JSPropertyNameArrayRelease`]
/// * [`JSPropertyNameArrayRetain`]
///
/// [`JSObjectCopyPropertyNames`]: fn.JSObjectCopyPropertyNames.html
/// [`JSPropertyNameArrayGetCount`]: fn.JSPropertyNameArrayGetCount.html
/// [`JSPropertyNameArrayGetNameAtIndex`]: fn.JSPropertyNameArrayGetNameAtIndex.html
/// [`JSPropertyNameArrayRelease`]: fn.JSPropertyNameArrayRelease.html
/// [`JSPropertyNameArrayRetain`]: fn.JSPropertyNameArrayRetain.html
pub type JSPropertyNameArrayRef = *mut OpaqueJSPropertyNameArray;

/// An ordered set used to collect the names of
/// a JavaScript object's properties.
#[doc(hidden)]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct OpaqueJSPropertyNameAccumulator([u8; 0]);

/// An ordered set used to collect the names of
/// a JavaScript object's properties.
///
/// Values of this type are passed to the [getPropertyNames callback].
/// Names are added to the accumulator using [`JSPropertyNameAccumulatorAddName`].
///
/// [getPropertyNames callback]: type.JSObjectGetPropertyNamesCallback.html
/// [`JSPropertyNameAccumulatorAddName`]: fn.JSPropertyNameAccumulatorAddName.html
pub type JSPropertyNameAccumulatorRef = *mut OpaqueJSPropertyNameAccumulator;

/// A function used to deallocate bytes passed to a Typed Array constructor.
/// The function should take two arguments. The first is a pointer to
/// the bytes that were originally passed to the Typed Array constructor.
/// The second is a pointer to additional information desired at the time
/// the bytes are to be freed.
pub type JSTypedArrayBytesDeallocator =
    ::std::option::Option<
        unsafe extern "C" fn(bytes: *mut ::std::os::raw::c_void,
                             deallocatorContext: *mut ::std::os::raw::c_void),
    >;

/// A JavaScript value.
/// The base type for all JavaScript values, and polymorphic functions on them.
#[doc(hidden)]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct OpaqueJSValue([u8; 0]);

/// A JavaScript value.
/// The base type for all JavaScript values, and polymorphic functions on them.
pub type JSValueRef = *const OpaqueJSValue;

/// A JavaScript object. A `JSObjectRef` is a `JSValueRef`.
pub type JSObjectRef = *mut OpaqueJSValue;

extern "C" {
    /// Evaluates a string of JavaScript.
    ///
    /// * `ctx`: The execution context to use.
    /// * `script`: A `JSString` containing the script to evaluate.
    /// * `thisObject`: The object to use as `this`, or `NULL` to
    ///   use the global object as `this`.
    /// * `sourceURL`: A `JSString` containing a URL for the script's
    ///   source file. This is used by debuggers and when reporting
    ///   exceptions. Pass `NULL` if you do not care to include source
    ///   file information.
    /// * `startingLineNumber`: An integer value specifying the script's
    ///   starting line number in the file located at `sourceURL`. This
    ///   is only used when reporting exceptions. The value is one-based,
    ///   so the first line is line `1` and invalid values are clamped
    ///   to `1`.
    /// * `exception`: A pointer to a `JSValueRef` in which to store an
    ///   exception, if any. Pass `NULL` if you do not care to store an
    ///   exception.
    ///
    /// The `JSValue` that results from evaluating script, or `NULL` if an exception is thrown.
    pub fn JSEvaluateScript(
        ctx: JSContextRef,
        script: JSStringRef,
        thisObject: JSObjectRef,
        sourceURL: JSStringRef,
        startingLineNumber: ::std::os::raw::c_int,
        exception: *mut JSValueRef,
    ) -> JSValueRef;

    /// Checks for syntax errors in a string of JavaScript.
    ///
    /// * `ctx`: The execution context to use.
    /// * `script`: A `JSString` containing the script to check for
    ///   syntax errors.
    /// * `sourceURL`: A `JSString` containing a URL for the script's
    ///   source file. This is only used when reporting exceptions.
    ///   Pass `NULL` if you do not care to include source file
    ///   information in exceptions.
    /// * `startingLineNumber`: An integer value specifying the script's
    ///   starting line number in the file located at `sourceURL`. This
    ///   is only used when reporting exceptions. The value is one-based,
    ///   so the first line is line `1` and invalid values are clamped
    ///   to `1`.
    /// * `exception`: A pointer to a `JSValueRef` in which to store a
    ///   syntax error exception, if any. Pass `NULL` if you do not care
    ///   to store a syntax error exception.
    ///
    /// Returns `true` if the script is syntactically correct, otherwise `false`.
    pub fn JSCheckScriptSyntax(
        ctx: JSContextRef,
        script: JSStringRef,
        sourceURL: JSStringRef,
        startingLineNumber: ::std::os::raw::c_int,
        exception: *mut JSValueRef,
    ) -> bool;

    /// Performs a JavaScript garbage collection.
    ///
    /// JavaScript values that are on the machine stack, in a register,
    /// protected by `JSValueProtect`, set as the global object of an
    /// execution context, or reachable from any such value will not
    /// be collected.
    ///
    /// During JavaScript execution, you are not required to call this
    /// function; the JavaScript engine will garbage collect as needed.
    /// JavaScript values created within a context group are automatically
    /// destroyed when the last reference to the context group is released.
    ///
    /// * `ctx`: The execution context to use.
    pub fn JSGarbageCollect(ctx: JSContextRef);
}

/// A constant identifying the type of a `JSValue`.
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum JSType {
    /// The unique `undefined` value.
    Undefined = 0,
    /// The unique `null` value.
    Null = 1,
    /// A primitive boolean value, one of `true` or `false`.
    Boolean = 2,
    /// A primitive number value.
    Number = 3,
    /// A primitive string value.
    String = 4,
    /// An object value (meaning that this `JSValueRef` is a `JSObjectRef`).
    Object = 5,
}

/// A constant identifying the Typed Array type of a `JSObjectRef`.
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum JSTypedArrayType {
    /// `Int8Array`
    Int8Array = 0,
    /// `Int16Array`
    Int16Array = 1,
    /// `Int32Array`
    Int32Array = 2,
    /// `Uint8Array`
    Uint8Array = 3,
    /// `Uint8ClampedArray`
    Uint8ClampedArray = 4,
    /// `Uint16Array`
    Uint16Array = 5,
    /// `Uint32Array`
    Uint32Array = 6,
    /// `Float32Array`
    Float32Array = 7,
    /// `Float64Array`
    Float64Array = 8,
    /// `ArrayBuffer`
    ArrayBuffer = 9,
    /// Not a Typed Array
    None = 10,
}

extern "C" {
    /// Returns a JavaScript value's type.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` whose type you want to obtain.
    ///
    /// Returns a value of type `JSType` that identifies `value`'s type.
    pub fn JSValueGetType(ctx: JSContextRef, arg1: JSValueRef) -> JSType;

    /// Tests whether a JavaScript value's type is the `undefined` type.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` to test.
    ///
    /// Returns `true` if `value`'s type is the `undefined` type, otherwise `false`.
    pub fn JSValueIsUndefined(ctx: JSContextRef, value: JSValueRef) -> bool;

    /// Tests whether a JavaScript value's type is the `null` type.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` to test.
    ///
    /// Returns `true` if `value`'s type is the `null` type, otherwise `false`.
    pub fn JSValueIsNull(ctx: JSContextRef, value: JSValueRef) -> bool;

    /// Tests whether a JavaScript value's type is the `boolean` type.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` to test.
    ///
    /// Returns `true` if `value`'s type is the `boolean` type, otherwise `false`.
    pub fn JSValueIsBoolean(ctx: JSContextRef, value: JSValueRef) -> bool;

    /// Tests whether a JavaScript value's type is the `number` type.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` to test.
    ///
    /// Returns `true` if `value`'s type is the `number` type, otherwise `false`.
    pub fn JSValueIsNumber(ctx: JSContextRef, value: JSValueRef) -> bool;

    /// Tests whether a JavaScript value's type is the `string` type.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` to test.
    ///
    /// Returns `true` if `value`'s type is the `string` type, otherwise `false`.
    pub fn JSValueIsString(ctx: JSContextRef, value: JSValueRef) -> bool;

    /// Tests whether a JavaScript value's type is the `object` type.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` to test.
    ///
    /// Returns `true` if `value`'s type is the `object` type, otherwise `false`.
    pub fn JSValueIsObject(ctx: JSContextRef, value: JSValueRef) -> bool;

    /// Tests whether a JavaScript value is an `object` with a given class in its class chain.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` to test.
    /// * `jsClass`: The `JSClass` to test against.
    ///
    /// Returns `true` if `value` is an `object` and has `jsClass` in its
    /// class chain, otherwise `false`.
    pub fn JSValueIsObjectOfClass(
        ctx: JSContextRef,
        value: JSValueRef,
        jsClass: JSClassRef,
    ) -> bool;

    /// Tests whether a JavaScript value is an `array`.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` to test.
    ///
    /// Returns `true` if `value` is an `array`, otherwise `false`.
    pub fn JSValueIsArray(ctx: JSContextRef, value: JSValueRef) -> bool;

    /// Tests whether a JavaScript value is a `date`.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` to test.
    ///
    /// Returns `true` if `value` is a `date`, otherwise `false`.
    pub fn JSValueIsDate(ctx: JSContextRef, value: JSValueRef) -> bool;

    /// Returns a JavaScript value's Typed Array type.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` whose Typed Array type to return.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns a value of type `JSTypedArrayType` that identifies
    /// value's Typed Array type, or `JSTypedArrayType::None` if the
    /// value is not a Typed Array object.
    pub fn JSValueGetTypedArrayType(
        ctx: JSContextRef,
        value: JSValueRef,
        exception: *mut JSValueRef,
    ) -> JSTypedArrayType;

    /// Tests whether two JavaScript values are equal, as compared by the JS `==` operator.
    ///
    /// * `ctx`: The execution context to use.
    /// * `a`: The first value to test.
    /// * `b`: The second value to test.
    /// * `exception`: A pointer to a `JSValueRef` in which to
    ///   store an exception, if any. Pass `NULL` if you do
    ///   not care to store an exception.
    ///
    /// Returns `true` if the two values are equal, `false` if
    /// they are not equal or an exception is thrown.
    pub fn JSValueIsEqual(
        ctx: JSContextRef,
        a: JSValueRef,
        b: JSValueRef,
        exception: *mut JSValueRef,
    ) -> bool;

    /// Tests whether two JavaScript values are strict equal, as compared
    /// by the JS `===` operator.
    ///
    /// * `ctx`: The execution context to use.
    /// * `a`: The first value to test.
    /// * `b`: The second value to test.
    ///
    /// Returns `true` if the two values are strict equal, otherwise `false`.
    pub fn JSValueIsStrictEqual(ctx: JSContextRef, a: JSValueRef, b: JSValueRef) -> bool;

    /// Tests whether a JavaScript value is an object constructed by a
    /// given constructor, as compared by the JS `instanceof` operator.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` to test.
    /// * `constructor`: The constructor to test against.
    /// * `exception`: A pointer to a `JSValueRef` in which to
    ///   store an exception, if any. Pass `NULL` if you do
    ///   not care to store an exception.
    ///
    /// Returns `true` if value is an object constructed by constructor,
    /// as compared by the JS `instanceof` operator, otherwise `false`.
    pub fn JSValueIsInstanceOfConstructor(
        ctx: JSContextRef,
        value: JSValueRef,
        constructor: JSObjectRef,
        exception: *mut JSValueRef,
    ) -> bool;

    /// Creates a JavaScript value of the `undefined` type.
    ///
    /// * `ctx`: The execution context to use.
    ///
    /// Returns the unique `undefined` value.
    pub fn JSValueMakeUndefined(ctx: JSContextRef) -> JSValueRef;

    /// Creates a JavaScript value of the `null` type.
    ///
    /// * `ctx`: The execution context to use.
    ///
    /// Returns the unique `null` value.
    pub fn JSValueMakeNull(ctx: JSContextRef) -> JSValueRef;

    /// Creates a JavaScript value of the `boolean` type.
    ///
    /// * `ctx`: The execution context to use.
    /// * `boolean`: The `bool` to assign to the newly created `JSValue`.
    ///
    /// Returns a `JSValue` of the `boolean` type, representing the value of `boolean`.
    pub fn JSValueMakeBoolean(ctx: JSContextRef, boolean: bool) -> JSValueRef;

    /// Creates a JavaScript value of the `number` type.
    ///
    /// * `ctx`: The execution context to use.
    /// * `number`: The `f64` to assign to the newly created `JSValue`.
    ///
    /// Returns a `JSValue` of the `number` type, representing the value of `number`.
    pub fn JSValueMakeNumber(ctx: JSContextRef, number: f64) -> JSValueRef;

    /// Creates a JavaScript value of the string type.
    ///
    /// * `ctx`: The execution context to use.
    /// * `string`: The `JSString` to assign to the newly created
    ///   `JSValue`. The newly created `JSValue` retains string, and
    ///   releases it upon garbage collection.
    ///
    /// Returns a `JSValue` of the `string` type, representing the value of `string`.
    pub fn JSValueMakeString(ctx: JSContextRef, string: JSStringRef) -> JSValueRef;

    /// Creates a JavaScript value from a JSON formatted string.
    ///
    /// * `ctx`: The execution context to use.
    /// * `string`: The `JSString` containing the JSON string to be parsed.
    ///
    /// Returns a `JSValue` containing the parsed value, or `NULL` if the input is invalid.
    pub fn JSValueMakeFromJSONString(ctx: JSContextRef, string: JSStringRef) -> JSValueRef;

    /// Creates a JavaScript string containing the JSON serialized representation of a JS value.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The value to serialize.
    /// * `indent`: The number of spaces to indent when nesting.
    ///   If `0`, the resulting JSON will not contains newlines.
    ///   The size of the indent is clamped to `10` spaces.
    /// * `exception`: A pointer to a `JSValueRef` in which to
    ///   store an exception, if any. Pass `NULL` if you do not
    ///   care to store an exception.
    ///
    /// Returns a `JSString` with the result of serialization, or `NULL` if an exception is thrown.
    pub fn JSValueCreateJSONString(
        ctx: JSContextRef,
        value: JSValueRef,
        indent: ::std::os::raw::c_uint,
        exception: *mut JSValueRef,
    ) -> JSStringRef;

    /// Converts a JavaScript value to boolean and returns the resulting boolean.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` to convert.
    ///
    /// Returns the boolean result of conversion.
    pub fn JSValueToBoolean(ctx: JSContextRef, value: JSValueRef) -> bool;

    /// Converts a JavaScript value to number and returns the resulting number.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` to convert.
    /// * `exception`: A pointer to a `JSValueRef` in which to store an
    ///   exception, if any. Pass `NULL` if you do not care to store an
    ///   exception.
    ///
    /// Returns the numeric result of conversion, or `NaN` if an exception is thrown.
    pub fn JSValueToNumber(ctx: JSContextRef, value: JSValueRef, exception: *mut JSValueRef)
        -> f64;

    /// Converts a JavaScript value to string and copies the result into a JavaScript string.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` to convert.
    /// * `exception`:  A pointer to a `JSValueRef` in which to store an
    ///   exception, if any. Pass `NULL` if you do not care to store an
    ///   exception.
    ///
    /// Returns a `JSString` with the result of conversion, or `NULL`
    /// if an exception is thrown. Ownership follows the Create Rule.
    pub fn JSValueToStringCopy(
        ctx: JSContextRef,
        value: JSValueRef,
        exception: *mut JSValueRef,
    ) -> JSStringRef;

    /// Converts a JavaScript value to object and returns the resulting object.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` to convert.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to store
    ///   an exception.
    ///
    /// Returns the `JSObject` result of conversion, or `NULL` if
    /// an exception is thrown.
    pub fn JSValueToObject(
        ctx: JSContextRef,
        value: JSValueRef,
        exception: *mut JSValueRef,
    ) -> JSObjectRef;

    /// Protects a JavaScript value from garbage collection.
    ///
    /// Use this method when you want to store a `JSValue` in a
    /// global or on the heap, where the garbage collector will
    /// not be able to discover your reference to it.
    ///
    /// A value may be protected multiple times and must be
    /// unprotected an equal number of times before becoming
    /// eligible for garbage collection.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` to protect.
    pub fn JSValueProtect(ctx: JSContextRef, value: JSValueRef);

    /// Unprotects a JavaScript value from garbage collection.
    ///
    /// A value may be protected multiple times and must be unprotected
    /// an equal number of times before becoming eligible for garbage
    /// collection.
    ///
    /// * `ctx`: The execution context to use.
    /// * `value`: The `JSValue` to unprotect.
    pub fn JSValueUnprotect(ctx: JSContextRef, value: JSValueRef);
}
/// A set of `JSPropertyAttribute`s.
///
/// Combine multiple attributes by logically ORing them together.
pub type JSPropertyAttributes = ::std::os::raw::c_uint;

/// A set of `JSClassAttribute`s.
///
/// Combine multiple attributes by logically ORing them together.
pub type JSClassAttributes = ::std::os::raw::c_uint;

/// The callback invoked when an object is first created.
///
/// * `ctx`: The execution context to use.
/// * `object`: The `JSObject` being created.
///
/// If you named your function `Initialize`, you would declare it like this:
///
/// ```ignore
/// void
/// Initialize(JSContextRef ctx, JSObjectRef object);
/// ```
///
/// Unlike the other object callbacks, the initialize callback is
/// called on the least derived class (the parent class) first,
/// and the most derived class last.
pub type JSObjectInitializeCallback =
    ::std::option::Option<unsafe extern "C" fn(ctx: JSContextRef, object: JSObjectRef)>;

/// The callback invoked when an object is finalized (prepared
/// for garbage collection). An object may be finalized on any thread.
///
/// * `object`: The `JSObject` being finalized.
///
/// If you named your function `Finalize`, you would declare it like this:
///
/// ```ignore
/// void
/// Finalize(JSObjectRef object);
/// ```
///
/// The finalize callback is called on the most derived class
/// first, and the least derived class (the parent class) last.
///
/// You must not call any function that may cause a garbage
/// collection or an allocation of a garbage collected object
/// from within a `JSObjectFinalizeCallback`. This includes
/// all functions that have a `JSContextRef` parameter.
pub type JSObjectFinalizeCallback =
    ::std::option::Option<unsafe extern "C" fn(object: JSObjectRef)>;

/// The callback invoked when determining whether an object has a property.
///
/// * `ctx`: The execution context to use.
/// * `object`: The `JSObject` to search for the property.
/// * `propertyName`: A `JSString` containing the name of the property look up.
///
/// Returns `true` if object has the property, otherwise `false`.
///
/// If you named your function `HasProperty`, you would declare it like this:
///
/// ```ignore
/// bool
/// HasProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName);
/// ```
///
/// If this function returns `false`, the `hasProperty` request
/// forwards to object's statically declared properties, then
/// its parent class chain (which includes the default object
/// class), then its prototype chain.
///
/// This callback enables optimization in cases where only a
/// property's existence needs to be known, not its value,
/// and computing its value would be expensive.
///
/// If this callback is NULL, the getProperty callback will be used to service hasProperty requests.
pub type JSObjectHasPropertyCallback =
    ::std::option::Option<
        unsafe extern "C" fn(ctx: JSContextRef,
                             object: JSObjectRef,
                             propertyName: JSStringRef)
                             -> bool,
    >;

/// The callback invoked when getting a property's value.
///
/// * `ctx`: The execution context to use.
/// * `object`: The `JSObject` to search for the property.
/// * `propertyName`: A `JSString` containing the name of the property to get.
/// * `exception`: A pointer to a `JSValueRef` in which to return an exception, if any.
///
/// Returns the property's value if object has the property, otherwise `NULL`.
///
/// If you named your function `GetProperty`, you would declare it like this:
///
/// ```ignore
/// JSValueRef
/// GetProperty(JSContextRef ctx, JSObjectRef object,
///             JSStringRef propertyName, JSValueRef* exception);
/// ```
///
/// If this function returns `NULL`, the get request forwards to `object`'s
/// statically declared properties, then its parent class chain (which
/// includes the default object class), then its prototype chain.
pub type JSObjectGetPropertyCallback =
    ::std::option::Option<
        unsafe extern "C" fn(ctx: JSContextRef,
                             object: JSObjectRef,
                             propertyName: JSStringRef,
                             exception: *mut JSValueRef)
                             -> *const OpaqueJSValue,
    >;

/// The callback invoked when setting a property's value.
///
/// * `ctx`: The execution context to use.
/// * `object`: The `JSObject` on which to set the property's value.
/// * `propertyName`: A `JSString` containing the name of the property to set.
/// * `value`: A `JSValue` to use as the property's value.
/// * `exception`: A pointer to a `JSValueRef` in which to return an exception, if any.
///
/// Returns `true` if the property was set, otherwise `false`.
///
/// If you named your function `SetProperty`, you would declare it like this:
///
/// ```ignore
/// bool
/// SetProperty(JSContextRef ctx, JSObjectRef object,
///             JSStringRef propertyName, JSValueRef value,
///             JSValueRef* exception);
/// ```
///
/// If this function returns `false`, the set request forwards to
/// `object`'s statically declared properties, then its parent class
/// chain (which includes the default object class).
pub type JSObjectSetPropertyCallback =
    ::std::option::Option<
        unsafe extern "C" fn(ctx: JSContextRef,
                             object: JSObjectRef,
                             propertyName: JSStringRef,
                             value: JSValueRef,
                             exception: *mut JSValueRef)
                             -> bool,
    >;

/// The callback invoked when deleting a property.
///
/// * `ctx`: The execution context to use.
/// * `object`: The `JSObject` in which to delete the property.
/// * `propertyName`: A `JSString` containing the name of the property to delete.
/// * `exception`: A pointer to a `JSValueRef` in which to return an exception, if any.
///
/// Returns `true` if `propertyName` was successfully deleted, otherwise `false`.
///
/// If you named your function `DeleteProperty`, you would declare it like this:
///
/// ```ignore
/// bool
/// DeleteProperty(JSContextRef ctx, JSObjectRef object,
///                JSStringRef propertyName, JSValueRef* exception);
/// ```
///
/// If this function returns `false`, the delete request forwards to
/// `object`'s statically declared properties, then its parent class
/// chain (which includes the default object class).
pub type JSObjectDeletePropertyCallback =
    ::std::option::Option<
        unsafe extern "C" fn(ctx: JSContextRef,
                             object: JSObjectRef,
                             propertyName: JSStringRef,
                             exception: *mut JSValueRef)
                             -> bool,
    >;

/// The callback invoked when collecting the names of an object's properties.
///
/// * `ctx`: The execution context to use.
/// * `object`: The `JSObject` whose property names are being collected.
/// * `propertyNames`: A JavaScript property name accumulator in which to
///   accumulate the names of object's properties.
///
/// If you named your function `GetPropertyNames`, you would declare it like this:
///
/// ```ignore
/// void
/// GetPropertyNames(JSContextRef ctx, JSObjectRef object,
///                  JSPropertyNameAccumulatorRef propertyNames);
/// ```
///
/// Property name accumulators are used by `JSObjectCopyPropertyNames`
/// and JavaScript `for...in` loops.
///
/// Use [`JSPropertyNameAccumulatorAddName`] to add property names to
/// accumulator. A class's `getPropertyNames` callback only needs to
/// provide the names of properties that the class vends through a
/// custom `getProperty` or `setProperty` callback. Other properties,
/// including statically declared properties, properties vended by
/// other classes, and properties belonging to object's prototype,
/// are added independently.
///
/// [`JSPropertyNameAccumulatorAddName`]: fn.JSPropertyNameAccumulatorAddName.html
pub type JSObjectGetPropertyNamesCallback =
    ::std::option::Option<
        unsafe extern "C" fn(ctx: JSContextRef,
                             object: JSObjectRef,
                             propertyNames: JSPropertyNameAccumulatorRef),
    >;

/// The callback invoked when an object is called as a function.
///
/// * `ctx`: The execution context to use.
/// * `function`: A `JSObject` that is the function being called.
/// * `thisObject`: A `JSObject` that is the `this` variable in the function's scope.
/// * `argumentCount`: An integer count of the number of arguments in `arguments`.
/// * `arguments`: A `JSValue` array of the arguments passed to the function.
/// * `exception`: A pointer to a `JSValueRef` in which to return an exception, if any.
///
/// Returns a `JSValue` that is the function's return value.
///
/// If you named your function `CallAsFunction`, you would declare it like this:
///
/// ```ignore
/// JSValueRef
/// CallAsFunction(JSContextRef ctx, JSObjectRef function,
///                JSObjectRef thisObject,
///                size_t argumentCount, const JSValueRef arguments[],
///                JSValueRef* exception);
/// ```
///
/// If your callback were invoked by the JavaScript expression
/// `myObject.myFunction()`, function would be set to `myFunction`,
/// and `thisObject` would be set to `myObject`.
///
/// If this callback is `NULL`, calling your object as a function
/// will throw an exception.
pub type JSObjectCallAsFunctionCallback =
    ::std::option::Option<
        unsafe extern "C" fn(ctx: JSContextRef,
                             function: JSObjectRef,
                             thisObject: JSObjectRef,
                             argumentCount: usize,
                             arguments: *const JSValueRef,
                             exception: *mut JSValueRef)
                             -> *const OpaqueJSValue,
    >;

/// The callback invoked when an object is used as a constructor in a `new` expression.
///
/// * `ctx`: The execution context to use.
/// * `constructor`: A `JSObject` that is the constructor being called.
/// * `argumentCount`: An integer count of the number of arguments in `arguments`.
/// * `arguments`: A `JSValue` array of the arguments passed to the function.
/// * `exception`: A pointer to a `JSValueRef` in which to return an exception, if any.
///
/// Returns a `JSObject` that is the constructor's return value.
///
/// If you named your function `CallAsConstructor`, you would declare it like this:
///
/// ```ignore
/// JSObjectRef
/// CallAsConstructor(JSContextRef ctx, JSObjectRef constructor,
///                   size_t argumentCount, const JSValueRef arguments[],
///                   JSValueRef* exception);
/// ```
///
/// If your callback were invoked by the JavaScript expression
/// `new myConstructor()`, constructor would be set to `myConstructor`.
///
/// If this callback is `NULL`, using your object as a constructor in a
/// `new` expression will throw an exception.
pub type JSObjectCallAsConstructorCallback =
    ::std::option::Option<
        unsafe extern "C" fn(ctx: JSContextRef,
                             constructor: JSObjectRef,
                             argumentCount: usize,
                             arguments: *const JSValueRef,
                             exception: *mut JSValueRef)
                             -> *mut OpaqueJSValue,
    >;

/// The callback invoked when an object is used as the target
/// of an `instanceof` expression.
///
/// * `ctx`: The execution context to use.
/// * `constructor`: The `JSObject` that is the target of the
///   `instanceof` expression.
/// * `possibleInstance`: The `JSValue` being tested to determine if it
///   is an instance of `constructor`.
/// * `exception`: A pointer to a `JSValueRef` in which to return an exception, if any.
///
/// Returns `true` if `possibleInstance` is an instance of `constructor`,
/// otherwise `false`.
///
/// If you named your function `HasInstance`, you would declare it like this:
///
/// ```ignore
/// bool
/// HasInstance(JSContextRef ctx, JSObjectRef constructor,
///             JSValueRef possibleInstance, JSValueRef* exception);
/// ```
///
/// If your callback were invoked by the JavaScript expression
/// `someValue instanceof myObject`, constructor would be set
/// to `myObject` and `possibleInstance` would be set to `someValue`.
///
/// If this callback is `NULL`, `instanceof` expressions that target
/// your object will return `false`.
///
/// Standard JavaScript practice calls for objects that implement
/// the `callAsConstructor` callback to implement the `hasInstance`
/// callback as well.
pub type JSObjectHasInstanceCallback =
    ::std::option::Option<
        unsafe extern "C" fn(ctx: JSContextRef,
                             constructor: JSObjectRef,
                             possibleInstance: JSValueRef,
                             exception: *mut JSValueRef)
                             -> bool,
    >;

/// The callback invoked when converting an object to a particular
/// JavaScript type.
///
/// * `ctx`: The execution context to use.
/// * `object`: The `JSObject` to convert.
/// * `type`: A `JSType` specifying the JavaScript type to convert to.
/// * `exception`: A pointer to a `JSValueRef` in which to return an exception, if any.
///
///Returns the objects's converted value, or `NULL` if the object was not converted.
///
/// If you named your function `ConvertToType`, you would declare it like this:
///
/// ```ignore
/// JSValueRef
/// ConvertToType(JSContextRef ctx, JSObjectRef object, JSType type,
///               JSValueRef* exception);
/// ```
///
/// If this function returns `false`, the conversion request forwards
/// to object's parent class chain (which includes the default object
/// class).
///
/// This function is only invoked when converting an object to number
/// or string. An object converted to boolean is `true`. An object
/// converted to object is itself.
pub type JSObjectConvertToTypeCallback =
    ::std::option::Option<
        unsafe extern "C" fn(ctx: JSContextRef,
                             object: JSObjectRef,
                             type_: JSType,
                             exception: *mut JSValueRef)
                             -> *const OpaqueJSValue,
    >;

/// A statically declared value property.
#[repr(C)]
#[derive(Debug, Copy)]
pub struct JSStaticValue {
    /// A null-terminated UTF8 string containing the property's name.
    pub name: *const ::std::os::raw::c_char,
    /// A `JSObjectGetPropertyCallback` to invoke when getting the property's value.
    pub getProperty: JSObjectGetPropertyCallback,
    /// A `JSObjectSetPropertyCallback` to invoke when setting the property's value.
    /// May be `NULL` if the `ReadOnly` attribute is set.
    pub setProperty: JSObjectSetPropertyCallback,
    /// A logically ORed set of `JSPropertyAttributes` to give to the property.
    pub attributes: JSPropertyAttributes,
}

impl Clone for JSStaticValue {
    fn clone(&self) -> Self {
        *self
    }
}

/// A statically declared function property.
#[repr(C)]
#[derive(Debug, Copy)]
pub struct JSStaticFunction {
    /// A null-terminated UTF8 string containing the property's name.
    pub name: *const ::std::os::raw::c_char,
    /// A `JSObjectCallAsFunctionCallback` to invoke when the property
    /// is called as a function.
    pub callAsFunction: JSObjectCallAsFunctionCallback,
    /// A logically ORed set of `JSPropertyAttributes` to give to the property.
    pub attributes: JSPropertyAttributes,
}

impl Clone for JSStaticFunction {
    fn clone(&self) -> Self {
        *self
    }
}

/// Contains properties and callbacks that define a type of object.
///
/// All fields other than the version field are optional. Any pointer may be `NULL`.
///
/// The `staticValues` and `staticFunctions` arrays are the simplest and most
/// efficient means for vending custom properties. Statically declared
/// properties automatically service requests like `getProperty`,
/// `setProperty`, and `getPropertyNames`. Property access callbacks
/// are required only to implement unusual properties, like array
/// indexes, whose names are not known at compile-time.
///
/// If you named your getter function `GetX` and your setter function
/// `SetX`, you would declare a `JSStaticValue` array containing `"X"` like this:
///
/// ```ignore
/// JSStaticValue StaticValueArray[] = {
///     { "X", GetX, SetX, kJSPropertyAttributeNone },
///     { 0, 0, 0, 0 }
/// };
/// ```
///
/// Standard JavaScript practice calls for storing function objects in
/// prototypes, so they can be shared. The default `JSClass` created by
/// `JSClassCreate` follows this idiom, instantiating objects with a
/// shared, automatically generating prototype containing the class's
/// function objects. The `kJSClassAttributeNoAutomaticPrototype`
/// attribute specifies that a `JSClass` should not automatically
/// generate such a prototype. The resulting `JSClass` instantiates
/// objects with the default object prototype, and gives each instance
/// object its own copy of the class's function objects.
///
/// A `NULL` callback specifies that the default object callback
/// should substitute, except in the case of `hasProperty`, where it
/// specifies that `getProperty` should substitute.
#[repr(C)]
#[derive(Debug, Copy)]
pub struct JSClassDefinition {
    /// The version number of this structure. The current version is 0.
    pub version: ::std::os::raw::c_int,
    /// A logically ORed set of `JSClassAttributes` to give to the class.
    pub attributes: JSClassAttributes,
    /// A null-terminated UTF8 string containing the class's name.
    pub className: *const ::std::os::raw::c_char,
    /// A `JSClass` to set as the class's parent class. Pass `NULL` use the default object class.
    pub parentClass: JSClassRef,
    /// A `JSStaticValue` array containing the class's statically declared
    /// value properties. Pass `NULL` to specify no statically declared
    /// value properties. The array must be terminated by a `JSStaticValue`
    /// whose name field is NULL.
    pub staticValues: *const JSStaticValue,
    /// A `JSStaticFunction` array containing the class's statically
    /// declared function properties. Pass `NULL` to specify no
    /// statically declared function properties. The array must be
    /// terminated by a `JSStaticFunction` whose name field is `NULL`.
    pub staticFunctions: *const JSStaticFunction,
    /// The callback invoked when an object is first created. Use this callback
    /// to initialize the object.
    pub initialize: JSObjectInitializeCallback,
    /// The callback invoked when an object is finalized (prepared for garbage
    /// collection). Use this callback to release resources allocated for the
    /// object, and perform other cleanup.
    pub finalize: JSObjectFinalizeCallback,
    /// The callback invoked when determining whether an object has a property.
    ///
    /// If this field is `NULL`, `getProperty` is called instead. The
    /// `hasProperty` callback enables optimization in cases where
    /// only a property's existence needs to be known, not its value,
    /// and computing its value is expensive.
    pub hasProperty: JSObjectHasPropertyCallback,
    /// The callback invoked when getting a property's value.
    pub getProperty: JSObjectGetPropertyCallback,
    /// The callback invoked when setting a property's value.
    pub setProperty: JSObjectSetPropertyCallback,
    /// The callback invoked when deleting a property.
    pub deleteProperty: JSObjectDeletePropertyCallback,
    /// The callback invoked when collecting the names of an object's properties.
    pub getPropertyNames: JSObjectGetPropertyNamesCallback,
    /// The callback invoked when an object is called as a function.
    pub callAsFunction: JSObjectCallAsFunctionCallback,
    /// The callback invoked when an object is used as a constructor in a `new` expression.
    pub callAsConstructor: JSObjectCallAsConstructorCallback,
    /// The callback invoked when an object is used as the target of an `instanceof` expression.
    pub hasInstance: JSObjectHasInstanceCallback,
    /// The callback invoked when converting an object to a particular JavaScript type.
    pub convertToType: JSObjectConvertToTypeCallback,
}

impl Clone for JSClassDefinition {
    fn clone(&self) -> Self {
        *self
    }
}

impl Default for JSClassDefinition {
    fn default() -> Self {
        JSClassDefinition {
            version: 0,
            attributes: 0,
            className: ptr::null(),
            parentClass: ptr::null_mut(),
            staticValues: ptr::null(),
            staticFunctions: ptr::null(),
            initialize: None,
            finalize: None,
            hasProperty: None,
            getProperty: None,
            setProperty: None,
            deleteProperty: None,
            getPropertyNames: None,
            callAsFunction: None,
            callAsConstructor: None,
            hasInstance: None,
            convertToType: None,
        }
    }
}

extern "C" {
    /// Creates a JavaScript class suitable for use with `JSObjectMake`.
    ///
    /// * `definition`: A `JSClassDefinition` that defines the class.
    ///
    /// Returns a `JSClass` with the given definition. Ownership follows
    /// the Create Rule.
    pub fn JSClassCreate(definition: *const JSClassDefinition) -> JSClassRef;

    /// Retains a JavaScript class.
    ///
    /// `jsClass`: The `JSClass` to retain.
    ///
    /// Returns a `JSClass` that is the same as `jsClass`.
    pub fn JSClassRetain(jsClass: JSClassRef) -> JSClassRef;

    /// Releases a JavaScript class.
    ///
    /// `jsClass`: The `JSClass` to release.
    pub fn JSClassRelease(jsClass: JSClassRef);

    /// Creates a JavaScript object.
    ///
    /// The default object class does not allocate storage for private data,
    /// so you must provide a non-`NULL` `jsClass` to `JSObjectMake` if you
    /// want your object to be able to store private data.
    ///
    /// `data` is set on the created object before the initialize methods in
    /// its class chain are called. This enables the initialize methods to
    /// retrieve and manipulate data through `JSObjectGetPrivate`.
    ///
    /// * `ctx`: The execution context to use.
    /// * `jsClass`: The `JSClass` to assign to the object. Pass `NULL` to use
    ///   the default object class.
    /// * `data`: A `void*` to set as the object's private data.
    ///    Pass NULL to specify no private data.
    ///
    /// Returns a `JSObject` with the given class and private data.
    pub fn JSObjectMake(
        ctx: JSContextRef,
        jsClass: JSClassRef,
        data: *mut ::std::os::raw::c_void,
    ) -> JSObjectRef;

    /// Convenience method for creating a JavaScript function with a given
    /// callback as its implementation.
    ///
    /// * `ctx`: The execution context to use.
    /// * `name`: A `JSString` containing the function's name. This will be
    ///   used when converting the function to string. Pass `NULL` to create
    ///   an anonymous function.
    /// * `callAsFunction`: The `JSObjectCallAsFunctionCallback` to invoke
    ///   when the function is called.
    ///
    /// Returns a `JSObject` that is a function. The object's prototype will be
    /// the default function prototype.
    pub fn JSObjectMakeFunctionWithCallback(
        ctx: JSContextRef,
        name: JSStringRef,
        callAsFunction: JSObjectCallAsFunctionCallback,
    ) -> JSObjectRef;

    /// Convenience method for creating a JavaScript constructor.
    ///
    /// * `ctx`: The execution context to use.
    /// * `jsClass`: A `JSClass` that is the class your constructor
    ///   will assign to the objects its constructs. `jsClass` will
    ///   be used to set the constructor's `.prototype` property, and
    ///   to evaluate `instanceof` expressions. Pass `NULL` to use
    ///   the default object class.
    /// * `callAsConstructor` A `JSObjectCallAsConstructorCallback` to
    ///   invoke when your constructor is used in a `new` expression.
    ///   Pass `NULL` to use the default object constructor.
    ///
    /// Returns a `JSObject` that is a constructor. The object's
    /// prototype will be the default object prototype.
    ///
    /// The default object constructor takes no arguments and constructs
    /// an object of class `jsClass` with no private data.
    pub fn JSObjectMakeConstructor(
        ctx: JSContextRef,
        jsClass: JSClassRef,
        callAsConstructor: JSObjectCallAsConstructorCallback,
    ) -> JSObjectRef;

    /// Creates a JavaScript Array object.
    ///
    /// * `ctx`: The execution context to use.
    /// * `argumentCount`: An integer count of the number of
    ///   arguments in `arguments`.
    /// * `arguments`: A `JSValue` array of data to populate the
    ///   `Array` with. Pass `NULL` if `argumentCount` is `0`.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns a `JSObject` that is an `Array`.
    ///
    /// The behavior of this function does not exactly match the behavior
    /// of the built-in `Array` constructor. Specifically, if one argument
    ///  is supplied, this function returns an array with one element.
    pub fn JSObjectMakeArray(
        ctx: JSContextRef,
        argumentCount: usize,
        arguments: *const JSValueRef,
        exception: *mut JSValueRef,
    ) -> JSObjectRef;

    /// Creates a JavaScript `Date` object, as if by invoking the
    /// built-in `Date` constructor.
    ///
    /// * `ctx`: The execution context to use.
    /// * `argumentCount`: An integer count of the number of
    ///   arguments in `arguments`.
    /// * `arguments`: A `JSValue` array of arguments to pass to
    ///   the `Date` constructor. Pass `NULL` if `argumentCount` is `0`.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns a `JSObject` that is a `Date`.
    pub fn JSObjectMakeDate(
        ctx: JSContextRef,
        argumentCount: usize,
        arguments: *const JSValueRef,
        exception: *mut JSValueRef,
    ) -> JSObjectRef;

    /// Creates a JavaScript `Error` object, as if by invoking the
    /// built-in `Error` constructor.
    ///
    /// * `ctx`: The execution context to use.
    /// * `argumentCount`: An integer count of the number of
    ///   arguments in `arguments`.
    /// * `arguments`: A `JSValue` array of arguments to pass to
    ///   the `Error` constructor. Pass `NULL` if `argumentCount` is `0`.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns a `JSObject` that is a `Error`.
    pub fn JSObjectMakeError(
        ctx: JSContextRef,
        argumentCount: usize,
        arguments: *const JSValueRef,
        exception: *mut JSValueRef,
    ) -> JSObjectRef;

    /// Creates a JavaScript `RegExp` object, as if by invoking the
    /// built-in `RegExp` constructor.
    ///
    /// * `ctx`: The execution context to use.
    /// * `argumentCount`: An integer count of the number of
    ///   arguments in `arguments`.
    /// * `arguments`: A `JSValue` array of arguments to pass to
    ///   the `RegExp` constructor. Pass `NULL` if `argumentCount` is `0`.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns a `JSObject` that is a `RegExp`.
    pub fn JSObjectMakeRegExp(
        ctx: JSContextRef,
        argumentCount: usize,
        arguments: *const JSValueRef,
        exception: *mut JSValueRef,
    ) -> JSObjectRef;

    /// Creates a function with a given script as its body.
    ///
    /// * `ctx`: The execution context to use.
    /// * `name`: A `JSString` containing the function's name. This
    ///   will be used when converting the function to string. Pass
    ///   `NULL` to create an anonymous function.
    /// * `parameterCount`: An integer count of the number of parameter
    ///   names in `parameterNames`.
    /// * `parameterNames`: A `JSString` array containing the names of
    ///   the function's parameters. Pass `NULL` if `parameterCount` is `0`.
    /// * `body`: A `JSString` containing the script to use as the
    ///   function's body.
    /// * `sourceURL` A `JSString` containing a URL for the script's
    ///   source file. This is only used when reporting exceptions.
    ///   Pass `NULL` if you do not care to include source file
    ///   information in exceptions.
    /// * `startingLineNumber`: An integer value specifying the
    ///   script's starting line number in the file located at
    ///   `sourceURL`. This is only used when reporting exceptions.
    ///   The value is one-based, so the first line is line `1`
    ///   and invalid values are clamped to `1`.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns a `JSObject` that is a function, or `NULL` if either
    /// body or `parameterNames` contains a syntax error. The
    /// object's prototype will be the default function prototype.
    ///
    /// Use this method when you want to execute a script repeatedly, to
    /// avoid the cost of re-parsing the script before each execution.
    pub fn JSObjectMakeFunction(
        ctx: JSContextRef,
        name: JSStringRef,
        parameterCount: ::std::os::raw::c_uint,
        parameterNames: *const JSStringRef,
        body: JSStringRef,
        sourceURL: JSStringRef,
        startingLineNumber: ::std::os::raw::c_int,
        exception: *mut JSValueRef,
    ) -> JSObjectRef;

    /// Gets an object's prototype.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: A `JSObject` whose prototype you want to get.
    ///
    /// Returns a `JSValue` that is the object's prototype.
    pub fn JSObjectGetPrototype(ctx: JSContextRef, object: JSObjectRef) -> JSValueRef;

    ///Sets an object's prototype.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The `JSObject` whose prototype you want to set.
    /// * `value`: A `JSValue` to set as the object's prototype.
    pub fn JSObjectSetPrototype(ctx: JSContextRef, object: JSObjectRef, value: JSValueRef);

    /// Tests whether an object has a given property.
    ///
    /// * `object`: The `JSObject` to test.
    /// * `propertyName`: A `JSString` containing the property's name.
    ///
    /// Returns `true` if the object has a property whose name matches
    /// `propertyName`, otherwise `false`.
    pub fn JSObjectHasProperty(
        ctx: JSContextRef,
        object: JSObjectRef,
        propertyName: JSStringRef,
    ) -> bool;

    /// Gets a property from an object.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The `JSObject` whose property you want to get.
    /// * `propertyName`: A `JSString` containing the property's name.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns the property's value if object has the property, otherwise
    /// the undefined value.
    pub fn JSObjectGetProperty(
        ctx: JSContextRef,
        object: JSObjectRef,
        propertyName: JSStringRef,
        exception: *mut JSValueRef,
    ) -> JSValueRef;

    /// Sets a property on an object.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The `JSObject` whose property you want to set.
    /// * `propertyName`: A `JSString` containing the property's name.
    /// * `value`: A `JSValue` to use as the property's value.
    /// * `attributes`: A logically ORed set of `JSPropertyAttributes` to give to the property.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    pub fn JSObjectSetProperty(
        ctx: JSContextRef,
        object: JSObjectRef,
        propertyName: JSStringRef,
        value: JSValueRef,
        attributes: JSPropertyAttributes,
        exception: *mut JSValueRef,
    );

    /// Deletes a property from an object.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The `JSObject` whose property you want to delete.
    /// * `propertyName`: A `JSString` containing the property's name.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns `true` if the delete operation succeeds, otherwise `false`
    /// (for example, if the property has the `kJSPropertyAttributeDontDelete`
    /// attribute set).
    pub fn JSObjectDeleteProperty(
        ctx: JSContextRef,
        object: JSObjectRef,
        propertyName: JSStringRef,
        exception: *mut JSValueRef,
    ) -> bool;

    /// Gets a property from an object by numeric index.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The `JSObject` whose property you want to get.
    /// * `propertyIndex`: An integer value that is the property's name.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns the property's value if object has the property,
    /// otherwise the undefined value.
    ///
    /// Calling `JSObjectGetPropertyAtIndex` is equivalent to calling
    /// `JSObjectGetProperty` with a string containing `propertyIndex`,
    /// but `JSObjectGetPropertyAtIndex` provides optimized access to
    /// numeric properties.
    pub fn JSObjectGetPropertyAtIndex(
        ctx: JSContextRef,
        object: JSObjectRef,
        propertyIndex: ::std::os::raw::c_uint,
        exception: *mut JSValueRef,
    ) -> JSValueRef;

    /// Sets a property on an object by numeric index.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The `JSObject` whose property you want to set.
    /// * `propertyIndex`: The property's name as a number.
    /// * `value`: A `JSValue` to use as the property's value.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Calling `JSObjectSetPropertyAtIndex` is equivalent to calling
    /// `JSObjectSetProperty` with a string containing `propertyIndex`,
    /// but `JSObjectSetPropertyAtIndex` provides optimized access to
    /// numeric properties.
    pub fn JSObjectSetPropertyAtIndex(
        ctx: JSContextRef,
        object: JSObjectRef,
        propertyIndex: ::std::os::raw::c_uint,
        value: JSValueRef,
        exception: *mut JSValueRef,
    );

    /// Gets an object's private data.
    ///
    /// * `object`: A `JSObject` whose private data you want to get.
    ///
    /// Returns a `void*` that is the object's private data, if the
    /// object has private data, otherwise `NULL`.
    pub fn JSObjectGetPrivate(object: JSObjectRef) -> *mut ::std::os::raw::c_void;

    /// Sets a pointer to private data on an object.
    ///
    /// * `object`: The `JSObject` whose private data you want to set.
    /// * `data`: A `void*` to set as the object's private data.
    ///
    /// Returns `true` if object can store private data, otherwise `false`.
    ///
    /// The default object class does not allocate storage for private data.
    /// Only objects created with a non-`NULL` `JSClass` can store private data.
    pub fn JSObjectSetPrivate(object: JSObjectRef, data: *mut ::std::os::raw::c_void) -> bool;

    /// Tests whether an object can be called as a function.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The `JSObject` to test.
    ///
    /// Returns `true` if the object can be called as a function, otherwise `false`.
    pub fn JSObjectIsFunction(ctx: JSContextRef, object: JSObjectRef) -> bool;

    /// Calls an object as a function.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The `JSObject` to call as a function.
    /// * `thisObject`: The object to use as `this`, or `NULL` to use the global object as `this`.
    /// * `argumentCount`: An integer count of the number of arguments in `arguments`.
    /// * `arguments`: A `JSValue` array of arguments to pass to the function.
    ///   Pass `NULL` if `argumentCount` is `0`.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns the `JSValue` that results from calling `object` as a function,
    /// or `NULL` if an exception is thrown or `object` is not a function.
    pub fn JSObjectCallAsFunction(
        ctx: JSContextRef,
        object: JSObjectRef,
        thisObject: JSObjectRef,
        argumentCount: usize,
        arguments: *const JSValueRef,
        exception: *mut JSValueRef,
    ) -> JSValueRef;

    /// Tests whether an object can be called as a constructor.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The `JSObject` to test.
    ///
    /// Returns `true` if the object can be called as a constructor, otherwise `false`.
    pub fn JSObjectIsConstructor(ctx: JSContextRef, object: JSObjectRef) -> bool;

    /// Calls an object as a constructor.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The `JSObject` to call as a constructor.
    /// * `argumentCount`: An integer count of the number of arguments in `arguments`.
    /// * `arguments`: A `JSValue` array of arguments to pass to the constructor.
    ///   Pass `NULL` if `argumentCount` is `0`.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns the `JSObject` that results from calling `object` as a constructor,
    /// or `NULL` if an exception is thrown or `object` is not a constructor.
    pub fn JSObjectCallAsConstructor(
        ctx: JSContextRef,
        object: JSObjectRef,
        argumentCount: usize,
        arguments: *const JSValueRef,
        exception: *mut JSValueRef,
    ) -> JSObjectRef;

    /// Gets the names of an object's enumerable properties.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The object whose property names you want to get.
    ///
    /// Returns a `JSPropertyNameArray` containing the names of `object`'s
    /// enumerable properties. Ownership follows the Create Rule.
    pub fn JSObjectCopyPropertyNames(
        ctx: JSContextRef,
        object: JSObjectRef,
    ) -> JSPropertyNameArrayRef;

    /// Retains a JavaScript property name array.
    ///
    /// * `array`: The `JSPropertyNameArray` to retain.
    ///
    /// Returns a `JSPropertyNameArray` that is the same as array.
    pub fn JSPropertyNameArrayRetain(array: JSPropertyNameArrayRef) -> JSPropertyNameArrayRef;

    /// Releases a JavaScript property name array.
    ///
    /// * `array` The `JSPropertyNameArray` to release.
    pub fn JSPropertyNameArrayRelease(array: JSPropertyNameArrayRef);

    /// Gets a count of the number of items in a JavaScript property name array.
    ///
    /// * `array`: The array from which to retrieve the count.
    ///
    /// Return an integer count of the number of names in `array`.
    ///
    /// See also:
    ///
    /// * [`JSPropertyNameArrayGetNameAtIndex`]
    ///
    /// [`JSPropertyNameArrayGetNameAtIndex`]: fn.JSPropertyNameArrayGetNameAtIndex.html
    pub fn JSPropertyNameArrayGetCount(array: JSPropertyNameArrayRef) -> usize;

    /// Gets a property name at a given index in a JavaScript property name array.
    ///
    /// * `array`: The array from which to retrieve the property name.
    /// * `index`: The index of the property name to retrieve.
    ///
    /// Returns a `JSStringRef` containing the property name.
    ///
    /// See also:
    ///
    /// * [`JSPropertyNameArrayGetCount`]
    ///
    /// [`JSPropertyNameArrayGetCount`]: fn.JSPropertyNameArrayGetCount.html
    pub fn JSPropertyNameArrayGetNameAtIndex(
        array: JSPropertyNameArrayRef,
        index: usize,
    ) -> JSStringRef;

    /// Adds a property name to a JavaScript property name accumulator.
    ///
    /// * `accumulator`: The accumulator object to which to add the property name.
    /// * `propertyName`: The property name to add.
    pub fn JSPropertyNameAccumulatorAddName(
        accumulator: JSPropertyNameAccumulatorRef,
        propertyName: JSStringRef,
    );

    /// Creates a JavaScript context group.
    ///
    /// `JSContextGroup` associates JavaScript contexts with one another.
    /// Contexts in the same group may share and exchange JavaScript
    /// objects. Sharing and/or exchanging JavaScript objects between
    /// contexts in different groups will produce undefined behavior.
    /// When objects from the same context group are used in multiple threads,
    /// explicit synchronization is required.
    ///
    /// Returns the created `JSContextGroup`.
    pub fn JSContextGroupCreate() -> JSContextGroupRef;

    /// Retains a JavaScript context group.
    ///
    /// * `group`: The `JSContextGroup` to retain.
    ///
    /// Returns a `JSContextGroup` that is the same as group.
    pub fn JSContextGroupRetain(group: JSContextGroupRef) -> JSContextGroupRef;

    /// Releases a JavaScript context group.
    ///
    /// * `group`: The `JSContextGroup` to release.
    pub fn JSContextGroupRelease(group: JSContextGroupRef);

    /// Creates a global JavaScript execution context.
    ///
    /// `JSGlobalContextCreate` allocates a global object and populates
    /// it with all the built-in JavaScript objects, such as `Object`,
    /// `Function`, `String`, and `Array`.
    ///
    /// In WebKit version 4.0 and later, the context is created in a
    /// unique context group. Therefore, scripts may execute in it
    /// concurrently with scripts executing in other contexts. However,
    /// you may not use values created in the context in other contexts.
    ///
    /// * `globalObjectClass`: The class to use when creating the global
    ///   object. Pass `NULL` to use the default object class.
    ///
    /// Returns a `JSGlobalContext` with a global object of
    /// class `globalObjectClass`.
    pub fn JSGlobalContextCreate(globalObjectClass: JSClassRef) -> JSGlobalContextRef;

    /// Creates a global JavaScript execution context in the context
    /// group provided.
    ///
    /// `JSGlobalContextCreateInGroup` allocates a global object and
    /// populates it with all the built-in JavaScript objects, such as
    /// `Object`, `Function`, `String`, and `Array`.
    ///
    /// * `group`: The context group to use. The created global context
    ///   retains the group.  Pass `NULL` to create a unique group for
    ///   the context.
    /// * `globalObjectClass`: The class to use when creating the global
    ///   object. Pass NULL to use the default object class.
    ///
    /// Returns a `JSGlobalContext` with a global object of class
    /// `globalObjectClass` and a context group equal to `group`.
    pub fn JSGlobalContextCreateInGroup(
        group: JSContextGroupRef,
        globalObjectClass: JSClassRef,
    ) -> JSGlobalContextRef;

    /// Retains a global JavaScript execution context.
    ///
    /// * `ctx`: The `JSGlobalContext` to retain.
    ///
    /// Returns a `JSGlobalContext` that is the same as `ctx`.
    pub fn JSGlobalContextRetain(ctx: JSGlobalContextRef) -> JSGlobalContextRef;

    /// Releases a global JavaScript execution context.
    ///
    /// * `ctx` The `JSGlobalContext` to release.
    pub fn JSGlobalContextRelease(ctx: JSGlobalContextRef);

    /// Gets the global object of a JavaScript execution context.
    ///
    /// * `ctx` The `JSContext` whose global object you want to get.
    ///
    /// Returns `ctx`'s global object.
    pub fn JSContextGetGlobalObject(ctx: JSContextRef) -> JSObjectRef;

    /// Gets the context group to which a JavaScript execution context belongs.
    ///
    /// * `ctx`: The `JSContext` whose group you want to get.
    ///
    /// Returns `ctx`'s group.
    pub fn JSContextGetGroup(ctx: JSContextRef) -> JSContextGroupRef;

    /// Gets the global context of a JavaScript execution context.
    ///
    /// * `ctx`: The `JSContext` whose global context you want to get.
    ///
    /// Returns `ctx`'s global context.
    pub fn JSContextGetGlobalContext(ctx: JSContextRef) -> JSGlobalContextRef;

    /// Gets a copy of the name of a context.
    ///
    /// A `JSGlobalContext`'s name is exposed for remote debugging
    /// to make it easier to identify the context you would like to
    /// attach to.
    ///
    /// * `ctx`: The `JSGlobalContext` whose name you want to get.
    ///
    /// Returns the name for `ctx`.
    pub fn JSGlobalContextCopyName(ctx: JSGlobalContextRef) -> JSStringRef;

    /// Sets the remote debugging name for a context.
    ///
    /// * `ctx`: The `JSGlobalContext` that you want to name.
    /// * `name`: The remote debugging name to set on `ctx`.
    pub fn JSGlobalContextSetName(ctx: JSGlobalContextRef, name: JSStringRef);
}
/// A UTF-16 code unit.
///
/// One, or a sequence of two, can encode any Unicode character. As
/// with all scalar types, endianness depends on the underlying
/// architecture.
pub type JSChar = ::std::os::raw::c_ushort;
extern "C" {
    /// Creates a JavaScript string from a buffer of Unicode characters.
    ///
    /// * `chars`: The buffer of Unicode characters to copy into the
    ///   new `JSString`.
    /// * `numChars`: The number of characters to copy from the buffer
    ///   pointed to by `chars`.
    ///
    /// Returns a `JSString` containing `chars`. Ownership follows the
    /// Create Rule.
    pub fn JSStringCreateWithCharacters(chars: *const JSChar, numChars: usize) -> JSStringRef;

    /// Creates a JavaScript string from a null-terminated UTF8 string.
    ///
    /// * `string`: The null-terminated UTF8 string to copy into the
    ///   new `JSString`.
    ///
    /// Returns a `JSString` containing `string`. Ownership follows the
    /// Create Rule.
    pub fn JSStringCreateWithUTF8CString(string: *const ::std::os::raw::c_char) -> JSStringRef;

    /// Retains a JavaScript string.
    ///
    /// * `string`: The `JSString` to retain.
    ///
    /// Returns a `JSString` that is the same as `string`.
    pub fn JSStringRetain(string: JSStringRef) -> JSStringRef;

    /// Releases a JavaScript string.
    ///
    /// * `string`: The `JSString` to release.
    pub fn JSStringRelease(string: JSStringRef);

    /// Returns the number of Unicode characters in a JavaScript string.
    ///
    /// * `string`: The `JSString` whose length (in Unicode characters)
    ///   you want to know.
    ///
    /// Returns the number of Unicode characters stored in `string`.
    pub fn JSStringGetLength(string: JSStringRef) -> usize;

    /// Returns a pointer to the Unicode character buffer that
    /// serves as the backing store for a JavaScript string.
    ///
    /// * `string`: The `JSString` whose backing store you want to access.
    ///
    /// Returns a pointer to the Unicode character buffer that serves
    /// as `string`'s backing store, which will be deallocated when
    /// `string` is deallocated.
    pub fn JSStringGetCharactersPtr(string: JSStringRef) -> *const JSChar;

    /// Returns the maximum number of bytes a JavaScript string will
    /// take up if converted into a null-terminated UTF8 string.
    ///
    /// * `string`: The `JSString` whose maximum converted size (in bytes)
    ///   you want to know.
    ///
    /// Returns the maximum number of bytes that could be required to
    /// convert `string` into a null-terminated UTF8 string. The number
    /// of bytes that the conversion actually ends up requiring could
    /// be less than this, but never more.
    pub fn JSStringGetMaximumUTF8CStringSize(string: JSStringRef) -> usize;

    /// Converts a JavaScript string into a null-terminated UTF8 string,
    /// and copies the result into an external byte buffer.
    ///
    /// * `string`: The source `JSString`.
    /// * `buffer`: The destination byte buffer into which to copy a
    ///   null-terminated UTF8 representation of `string`. On return,
    ///   `buffer` contains a UTF8 string representation of `string`. If
    ///   `bufferSize` is too small, `buffer` will contain only
    ///   partial results. If `buffer` is not at least `bufferSize`
    ///   bytes in size, behavior is undefined.
    /// * `bufferSize`: The size of the external buffer in bytes.
    ///
    /// Returns the number of bytes written into buffer (including the null-terminator byte).
    pub fn JSStringGetUTF8CString(
        string: JSStringRef,
        buffer: *mut ::std::os::raw::c_char,
        bufferSize: usize,
    ) -> usize;

    /// Tests whether two JavaScript strings match.
    ///
    /// * `a`: The first `JSString` to test.
    /// * `b`: The second `JSString` to test.
    ///
    /// Returns `true` if the two strings match, otherwise `false`.
    pub fn JSStringIsEqual(a: JSStringRef, b: JSStringRef) -> bool;

    /// Tests whether a JavaScript string matches a null-terminated
    /// UTF8 string.
    ///
    /// * `a`: The `JSString` to test.
    /// * `b`: The null-terminated UTF8 string to test.
    ///
    /// Returns `true` if the two strings match, otherwise `false`.
    pub fn JSStringIsEqualToUTF8CString(a: JSStringRef, b: *const ::std::os::raw::c_char) -> bool;

    /// Creates a JavaScript Typed Array object with the given number of elements.
    ///
    /// * `ctx`: The execution context to use.
    /// * `arrayType`: A value identifying the type of array to
    ///   create. If `arrayType` is `JSTypedArrayType::None` or
    ///   `JSTypedArrayType::ArrayBuffer` then `NULL` will be returned.
    /// * `length`: The number of elements to be in the new Typed Array.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns a `JSObjectRef` that is a Typed Array with all elements set to
    /// zero or `NULL` if there was an error.
    pub fn JSObjectMakeTypedArray(
        ctx: JSContextRef,
        arrayType: JSTypedArrayType,
        length: usize,
        exception: *mut JSValueRef,
    ) -> JSObjectRef;

    /// Creates a JavaScript Typed Array object from an existing pointer.
    ///
    /// * `ctx`: The execution context to use.
    /// * `arrayType`: A value identifying the type of array to
    ///   create. If `arrayType` is `JSTypedArrayType::None` or
    ///   `JSTypedArrayType::ArrayBuffer` then `NULL` will be returned.
    /// * `bytes`: A pointer to the byte buffer to be used as the backing store
    ///   of the Typed Array object.
    /// * `byteLength`: The number of bytes pointed to by the parameter bytes.
    /// * `bytesDeallocator`: The allocator to use to deallocate the external
    ///    buffer when the JSTypedArrayData object is deallocated.
    /// * `deallocatorContext A pointer to pass back to the deallocator.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns a `JSObjectRef` Typed Array whose backing store is the same as
    /// the one pointed to by `bytes` or `NULL` if there was an error.
    ///
    /// If an exception is thrown during this function the `bytesDeallocator`
    /// will always be called.
    pub fn JSObjectMakeTypedArrayWithBytesNoCopy(
        ctx: JSContextRef,
        arrayType: JSTypedArrayType,
        bytes: *mut ::std::os::raw::c_void,
        byteLength: usize,
        bytesDeallocator: JSTypedArrayBytesDeallocator,
        deallocatorContext: *mut ::std::os::raw::c_void,
        exception: *mut JSValueRef,
    ) -> JSObjectRef;

    /// Creates a JavaScript Typed Array object from an existing
    /// JavaScript Array Buffer object.
    ///
    /// * `ctx`: The execution context to use.
    /// * `arrayType`: A value identifying the type of array to
    ///   create. If `arrayType` is `JSTypedArrayType::None` or
    ///   `JSTypedArrayType::ArrayBuffer` then `NULL` will be returned.
    /// * `buffer`: An Array Buffer object that should be used as the
    ///   backing store for the created JavaScript Typed Array object.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns a `JSObjectRef` that is a Typed Array or `NULL` if there
    /// was an error. The backing store of the Typed Array will be `buffer`.
    pub fn JSObjectMakeTypedArrayWithArrayBuffer(
        ctx: JSContextRef,
        arrayType: JSTypedArrayType,
        buffer: JSObjectRef,
        exception: *mut JSValueRef,
    ) -> JSObjectRef;

    /// Creates a JavaScript Typed Array object from an existing
    /// JavaScript Array Buffer object with the given offset and
    /// length.
    ///
    /// * `ctx`: The execution context to use.
    /// * `arrayType`: A value identifying the type of array to
    ///   create. If `arrayType` is `JSTypedArrayType::None` or
    ///   `JSTypedArrayType::ArrayBuffer` then `NULL` will be returned.
    /// * `buffer`: An Array Buffer object that should be used as the
    ///   backing store for the created JavaScript Typed Array object.
    /// * `byteOffset`: The byte offset for the created Typed Array.
    ///   `byteOffset` should aligned with the element size of `arrayType`.
    /// * `length`: The number of elements to include in the Typed Array.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns a `JSObjectRef` that is a Typed Array or `NULL` if there
    /// was an error. The backing store of the Typed Array will be `buffer`.
    pub fn JSObjectMakeTypedArrayWithArrayBufferAndOffset(
        ctx: JSContextRef,
        arrayType: JSTypedArrayType,
        buffer: JSObjectRef,
        byteOffset: usize,
        length: usize,
        exception: *mut JSValueRef,
    ) -> JSObjectRef;

    /// Returns a temporary pointer to the backing store of a
    /// JavaScript Typed Array object.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The Typed Array object whose backing store pointer
    ///   to return.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns a pointer to the raw data buffer that serves as `object`'s
    /// backing store or `NULL` if object is not a Typed Array object.
    ///
    /// The pointer returned by this function is temporary and is not
    /// guaranteed to remain valid across JavaScriptCore API calls.
    pub fn JSObjectGetTypedArrayBytesPtr(
        ctx: JSContextRef,
        object: JSObjectRef,
        exception: *mut JSValueRef,
    ) -> *mut ::std::os::raw::c_void;

    /// Returns the length of a JavaScript Typed Array object.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The Typed Array object whose length to return.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns the length of the Typed Array object or `0` if the object
    /// is not a Typed Array object.
    pub fn JSObjectGetTypedArrayLength(
        ctx: JSContextRef,
        object: JSObjectRef,
        exception: *mut JSValueRef,
    ) -> usize;

    /// Returns the byte length of a JavaScript Typed Array object.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The Typed Array object whose byte length to return.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns the byte length of the Typed Array object or `0` if the
    /// object is not a Typed Array object.
    pub fn JSObjectGetTypedArrayByteLength(
        ctx: JSContextRef,
        object: JSObjectRef,
        exception: *mut JSValueRef,
    ) -> usize;

    /// Returns the byte offset of a JavaScript Typed Array object.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The Typed Array object whose byte offset to return.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns the byte offset of the Typed Array object or `0` if the
    /// object is not a Typed Array object.
    pub fn JSObjectGetTypedArrayByteOffset(
        ctx: JSContextRef,
        object: JSObjectRef,
        exception: *mut JSValueRef,
    ) -> usize;

    /// Returns the JavaScript Array Buffer object that is used as the
    /// backing of a JavaScript Typed Array object.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The `JSObjectRef` whose Typed Array type data pointer
    ///   to obtain.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns a `JSObjectRef` with a `JSTypedArrayType` of
    /// `JSTypedArrayType::ArrayBuffer` or `NULL` if object is not
    /// a Typed Array.
    pub fn JSObjectGetTypedArrayBuffer(
        ctx: JSContextRef,
        object: JSObjectRef,
        exception: *mut JSValueRef,
    ) -> JSObjectRef;

    /// Creates a JavaScript Array Buffer object from an existing pointer.
    ///
    /// * `ctx`: The execution context to use.
    /// * `bytes`: A pointer to the byte buffer to be used as the backing
    ///   store of the Typed Array object.
    /// * `byteLength`: The number of bytes pointed to by the parameter `bytes`.
    /// * `bytesDeallocator`: The allocator to use to deallocate the
    ///   external buffer when the Typed Array data object is deallocated.
    /// * `deallocatorContext`: A pointer to pass back to the deallocator.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns a `JSObjectRef` Array Buffer whose backing store is
    /// the same as the one pointed to by `bytes` or `NULL` if there
    /// was an error.
    ///
    /// If an exception is thrown during this function the `bytesDeallocator`
    /// will always be called.
    pub fn JSObjectMakeArrayBufferWithBytesNoCopy(
        ctx: JSContextRef,
        bytes: *mut ::std::os::raw::c_void,
        byteLength: usize,
        bytesDeallocator: JSTypedArrayBytesDeallocator,
        deallocatorContext: *mut ::std::os::raw::c_void,
        exception: *mut JSValueRef,
    ) -> JSObjectRef;

    /// Returns a pointer to the data buffer that serves as the backing
    /// store for a JavaScript Typed Array object.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The Array Buffer object whose internal backing
    ///   store pointer to return.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns a pointer to the raw data buffer that serves as
    /// `object`'s backing store or `NULL` if `object` is not an
    /// Array Buffer object.
    ///
    /// The pointer returned by this function is temporary and is not
    /// guaranteed to remain valid across JavaScriptCore API calls.
    pub fn JSObjectGetArrayBufferBytesPtr(
        ctx: JSContextRef,
        object: JSObjectRef,
        exception: *mut JSValueRef,
    ) -> *mut ::std::os::raw::c_void;

    /// Returns the number of bytes in a JavaScript data object.
    ///
    /// * `ctx`: The execution context to use.
    /// * `object`: The JS Arary Buffer object whose length in bytes to return.
    /// * `exception`: A pointer to a `JSValueRef` in which to store
    ///   an exception, if any. Pass `NULL` if you do not care to
    ///   store an exception.
    ///
    /// Returns the number of bytes stored in the data `object`.
    pub fn JSObjectGetArrayBufferByteLength(
        ctx: JSContextRef,
        object: JSObjectRef,
        exception: *mut JSValueRef,
    ) -> usize;
}