Module Typed_array.Uint8Array

type elt = int

type elt = int;

type 'a typed_array = Js.uint8Array

type typed_array('a) = Js.uint8Array;

type t = elt typed_array

type t = typed_array(elt);

val unsafe_get : t -> int -> elt

let unsafe_get: t => int => elt;

val unsafe_set : t -> int -> elt -> unit

let unsafe_set: t => int => elt => unit;

val buffer : t -> Js.arrayBuffer

let buffer: t => Js.arrayBuffer;

val byteLength : t -> int

let byteLength: t => int;

val byteOffset : t -> int

let byteOffset: t => int;

val setArray : elt array -> t -> unit

let setArray: array(elt) => t => unit;

val setArrayOffset : elt array -> int -> t -> unit

let setArrayOffset: array(elt) => int => t => unit;

val length : t -> int

let length: t => int;

val copyWithin : to_:int -> ?start:int -> ?end_:int -> t -> t

let copyWithin: to_:int => ?start:int => ?end_:int => t => t;

val fill : elt -> ?start:int -> ?end_:int -> t -> t

let fill: elt => ?start:int => ?end_:int => t => t;

val reverseInPlace : t -> t

let reverseInPlace: t => t;

val sortInPlace : t -> t

let sortInPlace: t => t;

val sortInPlaceWith : f:(elt -> elt -> int) -> t -> t

let sortInPlaceWith: f:(elt => elt => int) => t => t;

val includes : value:elt -> t -> bool

let includes: value:elt => t => bool;

val indexOf : value:elt -> ?start:int -> t -> int

let indexOf: value:elt => ?start:int => t => int;

val join : ?sep:string -> t -> string

let join: ?sep:string => t => string;

val lastIndexOf : value:elt -> t -> int

let lastIndexOf: value:elt => t => int;

val lastIndexOfFrom : value:elt -> from:int -> t -> int

let lastIndexOfFrom: value:elt => from:int => t => int;

val slice : ?start:int -> ?end_:int -> t -> t

let slice: ?start:int => ?end_:int => t => t;

start is inclusive, end_ exclusive

val copy : t -> t

let copy: t => t;

val subarray : ?start:int -> ?end_:int -> t -> t

let subarray: ?start:int => ?end_:int => t => t;

start is inclusive, end_ exclusive

val toString : t -> string

let toString: t => string;

val toLocaleString : t -> string

let toLocaleString: t => string;

val entries : t -> (int * elt) Js.iterator

let entries: t => Js.iterator((int, elt));

val every : f:(elt -> bool) -> t -> bool

let every: f:(elt => bool) => t => bool;

val everyi : f:(elt -> int -> bool) -> t -> bool

let everyi: f:(elt => int => bool) => t => bool;

val filter : f:(elt -> bool) -> t -> t

let filter: f:(elt => bool) => t => t;

val filteri : f:(elt -> int -> bool) -> t -> t

let filteri: f:(elt => int => bool) => t => t;

val find : f:(elt -> bool) -> t -> elt Js.undefined

let find: f:(elt => bool) => t => Js.undefined(elt);

val findi : f:(elt -> int -> bool) -> t -> elt Js.undefined

let findi: f:(elt => int => bool) => t => Js.undefined(elt);

val findIndex : f:(elt -> bool) -> t -> int

let findIndex: f:(elt => bool) => t => int;

val findIndexi : f:(elt -> int -> bool) -> t -> int

let findIndexi: f:(elt => int => bool) => t => int;

val forEach : f:(elt -> unit) -> t -> unit

let forEach: f:(elt => unit) => t => unit;

val forEachi : f:(elt -> int -> unit) -> t -> unit

let forEachi: f:(elt => int => unit) => t => unit;

val keys : t -> int Js.iterator

let keys: t => Js.iterator(int);

val map : f:(elt -> 'b) -> t -> 'b typed_array

let map: f:(elt => 'b) => t => typed_array('b);

val mapi : f:(elt -> int -> 'b) -> t -> 'b typed_array

let mapi: f:(elt => int => 'b) => t => typed_array('b);

val reduce : f:('b -> elt -> 'b) -> init:'b -> t -> 'b

let reduce: f:('b => elt => 'b) => init:'b => t => 'b;

val reducei : f:('b -> elt -> int -> 'b) -> init:'b -> t -> 'b

let reducei: f:('b => elt => int => 'b) => init:'b => t => 'b;

val reduceRight : f:('b -> elt -> 'b) -> init:'b -> t -> 'b

let reduceRight: f:('b => elt => 'b) => init:'b => t => 'b;

val reduceRighti : f:('b -> elt -> int -> 'b) -> init:'b -> t -> 'b

let reduceRighti: f:('b => elt => int => 'b) => init:'b => t => 'b;

val some : f:(elt -> bool) -> t -> bool

let some: f:(elt => bool) => t => bool;

val somei : f:(elt -> int -> bool) -> t -> bool

let somei: f:(elt => int => bool) => t => bool;

val _BYTES_PER_ELEMENT : int

let _BYTES_PER_ELEMENT: int;

val make : elt array -> t

let make: array(elt) => t;

val fromBuffer : Js.arrayBuffer -> ?off:int -> ?len:int -> unit -> t

let fromBuffer: Js.arrayBuffer => ?off:int => ?len:int => unit => t;

raises Js.Exn.Error raises Js exception parameter offset is in bytes, length in elements

val fromLength : int -> t

let fromLength: int => t;

val from : elt Js.array_like -> t

let from: Js.array_like(elt) => t;

val values : t -> elt Js.iterator

let values: t => Js.iterator(elt);