import { COMPARATOR, SORT as SORT_IMPL } from "./util/sort";

import { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from "./util/error";

import { joinIntegerArray, joinFloatArray } from "./util/string";

import { idof } from "./builtins";

import { ArrayBufferView } from "./arraybuffer";

export class Int8Array extends ArrayBufferView {

[key: number]: i8;

// @ts-ignore: decorator

@lazy

static readonly BYTES_PER_ELEMENT: usize = sizeof<i8>();

constructor(length: i32) {

super(length, alignof<i8>());

}

get length(): i32 {

return this.byteLength;

}

@operator("[]")

private __get(index: i32): i8 {

if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);

return load<i8>(this.dataStart + <usize>index);

}

@unsafe @operator("{}")

private __uget(index: i32): i8 {

return load<i8>(this.dataStart + <usize>index);

}

@operator("[]=")

private __set(index: i32, value: native<i8>): void {

if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);

store<i8>(this.dataStart + <usize>index, value);

}

@unsafe @operator("{}=")

private __uset(index: i32, value: native<i8>): void {

store<i8>(this.dataStart + <usize>index, value);

}

includes(searchElement: i8, fromIndex: i32 = 0): bool {

return INCLUDES<Int8Array, i8>(this, searchElement, fromIndex);

}

indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {

return INDEX_OF<Int8Array, i8>(this, searchElement, fromIndex);

}

lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {

return LAST_INDEX_OF<Int8Array, i8>(this, searchElement, fromIndex);

}

fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {

return FILL<Int8Array, i8>(this, value, start, end);

}

sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR<i8>()): Int8Array {

return SORT<Int8Array, i8>(this, comparator);

}

slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {

return SLICE<Int8Array, i8>(this, begin, end);

}

subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {

return SUBARRAY<Int8Array, i8>(this, begin, end);

}

copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {

return COPY_WITHIN<Int8Array, i8>(this, target, start, end);

}

reduce<T>(

fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,

initialValue: T,

): T {

return REDUCE<Int8Array, i8, T>(this, fn, initialValue);

}

reduceRight<T>(

fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,

initialValue: T,

): T {

return REDUCE_RIGHT<Int8Array, i8, T>(this, fn, initialValue);

}

map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {

return MAP<Int8Array, i8>(this, fn);

}

filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {

return FILTER<Int8Array, i8>(this, fn);

}

findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {

return FIND_INDEX<Int8Array, i8>(this, fn);

}

some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {

return SOME<Int8Array, i8>(this, fn);

}

every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {

return EVERY<Int8Array, i8>(this, fn);

}

forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {

FOREACH<Int8Array, i8>(this, fn);

}

reverse(): this {

return REVERSE<this, i8>(this);

}

join(separator: string = ","): string {

return joinIntegerArray<i8>(this.dataStart, this.length, separator);

}

toString(): string {

return this.join();

}

static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {

return WRAP<Int8Array, i8>(buffer, byteOffset, length);

}

}

export class Uint8Array extends ArrayBufferView {

[key: number]: u8;

// @ts-ignore: decorator

@lazy

static readonly BYTES_PER_ELEMENT: usize = sizeof<u8>();

constructor(length: i32) {

super(length, alignof<u8>());

}

get length(): i32 {

return this.byteLength;

}

@operator("[]")

private __get(index: i32): u8 {

if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);

return load<u8>(this.dataStart + <usize>index);

}

@unsafe @operator("{}")

private __uget(index: i32): u8 {

return load<u8>(this.dataStart + <usize>index);

}

@operator("[]=")

private __set(index: i32, value: native<u8>): void {

if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);

store<u8>(this.dataStart + <usize>index, value);

}

@unsafe @operator("{}=")

private __uset(index: i32, value: native<u8>): void {

store<u8>(this.dataStart + <usize>index, value);

}

includes(searchElement: u8, fromIndex: i32 = 0): bool {

return INCLUDES<Uint8Array, u8>(this, searchElement, fromIndex);

}

indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {

return INDEX_OF<Uint8Array, u8>(this, searchElement, fromIndex);

}

lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {

return LAST_INDEX_OF<Uint8Array, u8>(this, searchElement, fromIndex);

}

fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {

return FILL<Uint8Array, u8>(this, value, start, end);

}

sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR<u8>()): Uint8Array {

return SORT<Uint8Array, u8>(this, comparator);

}

slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {

return SLICE<Uint8Array, u8>(this, begin, end);

}

subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {

return SUBARRAY<Uint8Array, u8>(this, begin, end);

}

copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {

return COPY_WITHIN<Uint8Array, u8>(this, target, start, end);

}

reduce<T>(

fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,

initialValue: T,

): T {

return REDUCE<Uint8Array, u8, T>(this, fn, initialValue);

}

reduceRight<T>(

fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,

initialValue: T,

): T {

return REDUCE_RIGHT<Uint8Array, u8, T>(this, fn, initialValue);

}

map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {

return MAP<Uint8Array, u8>(this, fn);

}

filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {

return FILTER<Uint8Array, u8>(this, fn);

}

findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {

return FIND_INDEX<Uint8Array, u8>(this, fn);

}

some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {

return SOME<Uint8Array, u8>(this, fn);

}

every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {

return EVERY<Uint8Array, u8>(this, fn);

}

forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {

FOREACH<Uint8Array, u8>(this, fn);

}

reverse(): this {

return REVERSE<this, u8>(this);

}

join(separator: string = ","): string {

return joinIntegerArray<u8>(this.dataStart, this.length, separator);

}

toString(): string {

return this.join();

}

static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {

return WRAP<Uint8Array, u8>(buffer, byteOffset, length);

}

}

export class Uint8ClampedArray extends ArrayBufferView {

[key: number]: u8;

// @ts-ignore: decorator

@lazy

static readonly BYTES_PER_ELEMENT: usize = sizeof<u8>();

constructor(length: i32) {

super(length, alignof<u8>());

}

get length(): i32 {

return this.byteLength;

}

@operator("[]")

private __get(index: i32): u8 {

if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);

return load<u8>(this.dataStart + <usize>index);

}

@unsafe @operator("{}")

private __uget(index: i32): u8 {

return load<u8>(this.dataStart + <usize>index);

}

@operator("[]=")

private __set(index: i32, value: native<u8>): void {

if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);

store<u8>(this.dataStart + <usize>index, ~(<i32>value >> 31) & (((255 - value) >> 31) | value));

}

@unsafe @operator("{}=")

private __uset(index: i32, value: native<u8>): void {

store<u8>(this.dataStart + <usize>index, ~(<i32>value >> 31) & (((255 - value) >> 31) | value));

}

includes(searchElement: u8, fromIndex: i32 = 0): bool {

return INCLUDES<Uint8ClampedArray, u8>(this, searchElement, fromIndex);

}

indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {

return INDEX_OF<Uint8ClampedArray, u8>(this, searchElement, fromIndex);

}

lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {

return LAST_INDEX_OF<Uint8ClampedArray, u8>(this, searchElement, fromIndex);

}

fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {

return FILL<Uint8ClampedArray, u8>(this, value, start, end);

}

sort(fn: (a: u8, b: u8) => i32 = COMPARATOR<u8>()): Uint8ClampedArray {

return SORT<Uint8ClampedArray, u8>(this, fn);

}

slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {

return SLICE<Uint8ClampedArray, u8>(this, begin, end);

}

subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {

return SUBARRAY<Uint8ClampedArray, u8>(this, start, end);

}

copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {

return COPY_WITHIN<Uint8ClampedArray, u8>(this, target, start, end);

}

reduce<T>(

fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,

initialValue: T,

): T {

return REDUCE<Uint8ClampedArray, u8, T>(this, fn, initialValue);

}

reduceRight<T>(

fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,

initialValue: T,

): T {

return REDUCE_RIGHT<Uint8ClampedArray, u8, T>(this, fn, initialValue);

}

map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {

return MAP<Uint8ClampedArray, u8>(this, fn);

}

filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {

return FILTER<Uint8ClampedArray, u8>(this, fn);

}

findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {

return FIND_INDEX<Uint8ClampedArray, u8>(this, fn);

}

some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {

return SOME<Uint8ClampedArray, u8>(this, fn);

}

every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {

return EVERY<Uint8ClampedArray, u8>(this, fn);

}

forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {

FOREACH<Uint8ClampedArray, u8>(this, fn);

}

reverse(): this {

return REVERSE<this, u8>(this);

}

join(separator: string = ","): string {

return joinIntegerArray<u8>(this.dataStart, this.length, separator);

}

toString(): string {

return this.join();

}

static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {

return WRAP<Uint8ClampedArray, u8>(buffer, byteOffset, length);

}

}

export class Int16Array extends ArrayBufferView {

[key: number]: i16;

// @ts-ignore: decorator

@lazy

static readonly BYTES_PER_ELEMENT: usize = sizeof<i16>();

constructor(length: i32) {

super(length, alignof<i16>());

}

get length(): i32 {

return this.byteLength >>> alignof<i16>();

}

@operator("[]")

private __get(index: i32): i16 {

if (<u32>index >= <u32>this.byteLength >>> alignof<i16>()) throw new RangeError(E_INDEXOUTOFRANGE);

return load<i16>(this.dataStart + (<usize>index << alignof<i16>()));

}

@unsafe @operator("{}")

private __uget(index: i32): i16 {

return load<i16>(this.dataStart + (<usize>index << alignof<i16>()));

}

@operator("[]=")

private __set(index: i32, value: native<i16>): void {

if (<u32>index >= <u32>this.byteLength >>> alignof<i16>()) throw new RangeError(E_INDEXOUTOFRANGE);

store<i16>(this.dataStart + (<usize>index << alignof<i16>()), value);

}

@unsafe @operator("{}=")

private __uset(index: i32, value: native<i16>): void {

store<i16>(this.dataStart + (<usize>index << alignof<i16>()), value);

}

includes(searchElement: i16, fromIndex: i32 = 0): bool {

return INCLUDES<Int16Array, i16>(this, searchElement, fromIndex);

}

indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {

return INDEX_OF<Int16Array, i16>(this, searchElement, fromIndex);

}

lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {

return LAST_INDEX_OF<Int16Array, i16>(this, searchElement, fromIndex);

}

fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {

return FILL<Int16Array, i16>(this, value, start, end);

}

sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR<i16>()): Int16Array {

return SORT<Int16Array, i16>(this, comparator);

}

slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {

return SLICE<Int16Array, i16>(this, begin, end);

}

subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {

return SUBARRAY<Int16Array, i16>(this, begin, end);

}

copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {

return COPY_WITHIN<Int16Array, i16>(this, target, start, end);

}

reduce<T>(

fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,

initialValue: T,

): T {

return REDUCE<Int16Array, i16, T>(this, fn, initialValue);

}

reduceRight<T>(

fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,

initialValue: T,

): T {

return REDUCE_RIGHT<Int16Array, i16, T>(this, fn, initialValue);

}

map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {

return MAP<Int16Array, i16>(this, fn);

}

filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {

return FILTER<Int16Array, i16>(this, fn);

}

findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {

return FIND_INDEX<Int16Array, i16>(this, fn);

}

some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {

return SOME<Int16Array, i16>(this, fn);

}

every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {

return EVERY<Int16Array, i16>(this, fn);

}

forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {

FOREACH<Int16Array, i16>(this, fn);

}

reverse(): this {

return REVERSE<this, i16>(this);

}

join(separator: string = ","): string {

return joinIntegerArray<i16>(this.dataStart, this.length, separator);

}

toString(): string {

return this.join();

}

static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {

return WRAP<Int16Array, i16>(buffer, byteOffset, length);

}

}

export class Uint16Array extends ArrayBufferView {

[key: number]: u16;

// @ts-ignore: decorator

@lazy

static readonly BYTES_PER_ELEMENT: usize = sizeof<u16>();

constructor(length: i32) {

super(length, alignof<u16>());

}

get length(): i32 {

return this.byteLength >>> alignof<u16>();

}

@operator("[]")

private __get(index: i32): u16 {

if (<u32>index >= <u32>this.byteLength >>> alignof<u16>()) throw new RangeError(E_INDEXOUTOFRANGE);

return load<u16>(this.dataStart + (<usize>index << alignof<u16>()));

}

@unsafe @operator("{}")

private __uget(index: i32): u16 {

return load<u16>(this.dataStart + (<usize>index << alignof<u16>()));

}

@operator("[]=")

private __set(index: i32, value: native<u16>): void {

if (<u32>index >= <u32>this.byteLength >>> alignof<u16>()) throw new RangeError(E_INDEXOUTOFRANGE);

store<u16>(this.dataStart + (<usize>index << alignof<u16>()), value);

}

@unsafe @operator("{}=")

private __uset(index: i32, value: native<u16>): void {

store<u16>(this.dataStart + (<usize>index << alignof<u16>()), value);

}

includes(searchElement: u16, fromIndex: i32 = 0): bool {

return INCLUDES<Uint16Array, u16>(this, searchElement, fromIndex);

}

indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {

return INDEX_OF<Uint16Array, u16>(this, searchElement, fromIndex);

}

lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {

return LAST_INDEX_OF<Uint16Array, u16>(this, searchElement, fromIndex);

}

fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {

return FILL<Uint16Array, u16>(this, value, start, end);

}

sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR<u16>()): Uint16Array {

return SORT<Uint16Array, u16>(this, comparator);

}

slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {

return SLICE<Uint16Array, u16>(this, begin, end);

}

subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {

return SUBARRAY<Uint16Array, u16>(this, begin, end);

}

copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {

return COPY_WITHIN<Uint16Array, u16>(this, target, start, end);

}

reduce<T>(

fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,

initialValue: T,

): T {

return REDUCE<Uint16Array, u16, T>(this, fn, initialValue);

}

reduceRight<T>(

fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,

initialValue: T,

): T {

return REDUCE_RIGHT<Uint16Array, u16, T>(this, fn, initialValue);

}

map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {

return MAP<Uint16Array, u16>(this, fn);

}

filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {

return FILTER<Uint16Array, u16>(this, fn);

}

findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {

return FIND_INDEX<Uint16Array, u16>(this, fn);

}

some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {

return SOME<Uint16Array, u16>(this, fn);

}

every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {

return EVERY<Uint16Array, u16>(this, fn);

}

forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {

FOREACH<Uint16Array, u16>(this, fn);

}

reverse(): this {

return REVERSE<this, u16>(this);

}

join(separator: string = ","): string {

return joinIntegerArray<u16>(this.dataStart, this.length, separator);

}

toString(): string {

return this.join();

}

static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {

return WRAP<Uint16Array, u16>(buffer, byteOffset, length);

}

}

export class Int32Array extends ArrayBufferView {

[key: number]: i32;

// @ts-ignore: decorator

@lazy

static readonly BYTES_PER_ELEMENT: usize = sizeof<i32>();

constructor(length: i32) {

super(length, alignof<i32>());

}

get length(): i32 {

return this.byteLength >>> alignof<i32>();

}

@operator("[]")

private __get(index: i32): i32 {

if (<u32>index >= <u32>this.byteLength >>> alignof<i32>()) throw new RangeError(E_INDEXOUTOFRANGE);

return load<i32>(this.dataStart + (<usize>index << alignof<i32>()));

}

@unsafe @operator("{}")

private __uget(index: i32): i32 {

return load<i32>(this.dataStart + (<usize>index << alignof<i32>()));

}

@operator("[]=")

private __set(index: i32, value: i32): void {

if (<u32>index >= <u32>this.byteLength >>> alignof<i32>()) throw new RangeError(E_INDEXOUTOFRANGE);

store<i32>(this.dataStart + (<usize>index << alignof<i32>()), value);

}

@unsafe @operator("{}=")

private __uset(index: i32, value: i32): void {

store<i32>(this.dataStart + (<usize>index << alignof<i32>()), value);

}

includes(searchElement: i32, fromIndex: i32 = 0): bool {

return INCLUDES<Int32Array, i32>(this, searchElement, fromIndex);

}

indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {

return INDEX_OF<Int32Array, i32>(this, searchElement, fromIndex);

}

lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {

return LAST_INDEX_OF<Int32Array, i32>(this, searchElement, fromIndex);

}

fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {

return FILL<Int32Array, i32>(this, value, start, end);

}

sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR<i32>()): Int32Array {

return SORT<Int32Array, i32>(this, comparator);

}

slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {

return SLICE<Int32Array, i32>(this, begin, end);

}

subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {

return SUBARRAY<Int32Array, i32>(this, begin, end);

}

copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {

return COPY_WITHIN<Int32Array, i32>(this, target, start, end);

}

reduce<T>(

fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,

initialValue: T,

): T {

return REDUCE<Int32Array, i32, T>(this, fn, initialValue);

}

reduceRight<T>(

fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,

initialValue: T,

): T {

return REDUCE_RIGHT<Int32Array, i32, T>(this, fn, initialValue);

}

map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {

return MAP<Int32Array, i32>(this, fn);

}

filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {

return FILTER<Int32Array, i32>(this, fn);

}

findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {

return FIND_INDEX<Int32Array, i32>(this, fn);

}

some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {

return SOME<Int32Array, i32>(this, fn);

}

every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {

return EVERY<Int32Array, i32>(this, fn);

}

forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {

FOREACH<Int32Array, i32>(this, fn);

}

reverse(): this {

return REVERSE<this, i32>(this);

}

join(separator: string = ","): string {

return joinIntegerArray<i32>(this.dataStart, this.length, separator);

}

toString(): string {

return this.join();

}

static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {

return WRAP<Int32Array, i32>(buffer, byteOffset, length);

}

}

export class Uint32Array extends ArrayBufferView {

[key: number]: u32;

// @ts-ignore: decorator

@lazy

static readonly BYTES_PER_ELEMENT: usize = sizeof<u32>();

constructor(length: i32) {

super(length, alignof<u32>());

}

get length(): i32 {

return this.byteLength >>> alignof<u32>();

}

@operator("[]")

private __get(index: i32): u32 {

if (<u32>index >= <u32>this.byteLength >>> alignof<u32>()) throw new RangeError(E_INDEXOUTOFRANGE);

return load<u32>(this.dataStart + (<usize>index << alignof<u32>()));

}

@unsafe @operator("{}")

private __uget(index: i32): u32 {

return load<u32>(this.dataStart + (<usize>index << alignof<u32>()));

}

@operator("[]=")

private __set(index: i32, value: u32): void {

if (<u32>index >= <u32>this.byteLength >>> alignof<u32>()) throw new RangeError(E_INDEXOUTOFRANGE);

store<u32>(this.dataStart + (<usize>index << alignof<u32>()), value);

}

@unsafe @operator("{}=")

private __uset(index: i32, value: u32): void {

store<u32>(this.dataStart + (<usize>index << alignof<u32>()), value);

}

includes(searchElement: u32, fromIndex: i32 = 0): bool {

return INCLUDES<Uint32Array, u32>(this, searchElement, fromIndex);

}

indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {

return INDEX_OF<Uint32Array, u32>(this, searchElement, fromIndex);

}

lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {

return LAST_INDEX_OF<Uint32Array, u32>(this, searchElement, fromIndex);

}

fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {

return FILL<Uint32Array, u32>(this, value, start, end);

}

sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR<u32>()): Uint32Array {

return SORT<Uint32Array, u32>(this, comparator);

}

slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {

return SLICE<Uint32Array, u32>(this, begin, end);

}

subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {

return SUBARRAY<Uint32Array, u32>(this, begin, end);

}

copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {

return COPY_WITHIN<Uint32Array, u32>(this, target, start, end);

}

reduce<T>(

fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,

initialValue: T,

): T {

return REDUCE<Uint32Array, u32, T>(this, fn, initialValue);

}

reduceRight<T>(

fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,

initialValue: T,

): T {

return REDUCE_RIGHT<Uint32Array, u32, T>(this, fn, initialValue);

}

map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {

return MAP<Uint32Array, u32>(this, fn);

}

filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {

return FILTER<Uint32Array, u32>(this, fn);

}

findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {

return FIND_INDEX<Uint32Array, u32>(this, fn);

}

some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {

return SOME<Uint32Array, u32>(this, fn);

}

every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {

return EVERY<Uint32Array, u32>(this, fn);

}

forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {

FOREACH<Uint32Array, u32>(this, fn);

}

reverse(): this {

return REVERSE<this, u32>(this);

}

join(separator: string = ","): string {

return joinIntegerArray<u32>(this.dataStart, this.length, separator);

}

toString(): string {

return this.join();

}

static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {

return WRAP<Uint32Array, u32>(buffer, byteOffset, length);

}

}

export class Int64Array extends ArrayBufferView {

[key: number]: i64;

// @ts-ignore: decorator

@lazy

static readonly BYTES_PER_ELEMENT: usize = sizeof<i64>();

constructor(length: i32) {

super(length, alignof<i64>());

}

get length(): i32 {

return this.byteLength >>> alignof<i64>();

}

@operator("[]")

private __get(index: i32): i64 {

if (<u32>index >= <u32>this.byteLength >>> alignof<i64>()) throw new RangeError(E_INDEXOUTOFRANGE);

return load<i64>(this.dataStart + (<usize>index << alignof<i64>()));

}

@unsafe @operator("{}")

private __uget(index: i32): i64 {

return load<i64>(this.dataStart + (<usize>index << alignof<i64>()));

}

@operator("[]=")

private __set(index: i32, value: i64): void {

if (<u32>index >= <u32>this.byteLength >>> alignof<i64>()) throw new RangeError(E_INDEXOUTOFRANGE);

store<i64>(this.dataStart + (<usize>index << alignof<i64>()), value);

}

@unsafe @operator("{}=")

private __uset(index: i32, value: i64): void {

store<i64>(this.dataStart + (<usize>index << alignof<i64>()), value);

}

includes(searchElement: i64, fromIndex: i32 = 0): bool {

return INCLUDES<Int64Array, i64>(this, searchElement, fromIndex);

}

indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {

return INDEX_OF<Int64Array, i64>(this, searchElement, fromIndex);

}

lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {

return LAST_INDEX_OF<Int64Array, i64>(this, searchElement, fromIndex);

}

fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {

return FILL<Int64Array, i64>(this, value, start, end);

}

sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR<i64>()): Int64Array {

return SORT<Int64Array, i64>(this, comparator);

}

slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {

return SLICE<Int64Array, i64>(this, begin, end);

}

subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {

return SUBARRAY<Int64Array, i64>(this, begin, end);

}

copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {

return COPY_WITHIN<Int64Array, i64>(this, target, start, end);

}

reduce<T>(

fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,

initialValue: T,

): T {

return REDUCE<Int64Array, i64, T>(this, fn, initialValue);

}

reduceRight<T>(

fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,

initialValue: T,

): T {

return REDUCE_RIGHT<Int64Array, i64, T>(this, fn, initialValue);

}

map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {

return MAP<Int64Array, i64>(this, fn);

}

filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {

return FILTER<Int64Array, i64>(this, fn);

}

findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {

return FIND_INDEX<Int64Array, i64>(this, fn);

}

some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {

return SOME<Int64Array, i64>(this, fn);

}

every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {

return EVERY<Int64Array, i64>(this, fn);

}

forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {

FOREACH<Int64Array, i64>(this, fn);

}

reverse(): this {

return REVERSE<this, i64>(this);

}

join(separator: string = ","): string {

return joinIntegerArray<i64>(this.dataStart, this.length, separator);

}

toString(): string {

return this.join();

}

static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {

return WRAP<Int64Array, i64>(buffer, byteOffset, length);

}

}

export class Uint64Array extends ArrayBufferView {

[key: number]: u64;